Merge pull request #1672 from benjchristensen/merge-0_20_4

Merge 0.20.4 Fixes

Author: benjchristensen

src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunction.java

@@ -18,6 +18,7 @@
 import rx.Observable;
 import rx.Observable.Operator;
 import rx.Subscriber;
+import rx.exceptions.Exceptions;
 import rx.functions.Func1;
 import rx.plugins.RxJavaPlugins;
 
@@ -49,17 +50,29 @@ public OperatorOnErrorResumeNextViaFunction(Func1<Throwable, ? extends Observabl
 
     @Override
     public Subscriber<? super T> call(final Subscriber<? super T> child) {
-        return new Subscriber<T>(child) {
+        Subscriber<T> parent = new Subscriber<T>() {
 
+            private boolean done = false;
+            
             @Override
             public void onCompleted() {
+                if (done) {
+                    return;
+                }
+                done = true;
                 child.onCompleted();
             }
 
             @Override
             public void onError(Throwable e) {
+                if (done) {
+                    Exceptions.throwIfFatal(e);
+                    return;
+                }
+                done = true;
                 try {
                     RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                    unsubscribe();
                     Observable<? extends T> resume = resumeFunction.call(e);
                     resume.unsafeSubscribe(child);
                 } catch (Throwable e2) {
@@ -69,10 +82,15 @@ public void onError(Throwable e) {
 
             @Override
             public void onNext(T t) {
+                if (done) {
+                    return;
+                }
                 child.onNext(t);
             }
 
         };
+        child.add(parent);
+        return parent;
     }
 
 }

src/main/java/rx/internal/operators/OperatorOnErrorResumeNextViaObservable.java

@@ -18,6 +18,7 @@
 import rx.Observable;
 import rx.Observable.Operator;
 import rx.Subscriber;
+import rx.exceptions.Exceptions;
 import rx.plugins.RxJavaPlugins;
 
 /**
@@ -51,20 +52,35 @@ public OperatorOnErrorResumeNextViaObservable(Observable<? extends T> resumeSequ
     public Subscriber<? super T> call(final Subscriber<? super T> child) {
         // shared subscription won't work here
         Subscriber<T> s = new Subscriber<T>() {
+            
+            private boolean done = false;
+            
             @Override
             public void onNext(T t) {
+                if (done) {
+                    return;
+                }
                 child.onNext(t);
             }
 
             @Override
             public void onError(Throwable e) {
+                if (done) {
+                    Exceptions.throwIfFatal(e);
+                    return;
+                }
+                done = true;
                 RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
                 unsubscribe();
                 resumeSequence.unsafeSubscribe(child);
             }
 
             @Override
             public void onCompleted() {
+                if (done) {
+                    return;
+                }
+                done = true;
                 child.onCompleted();
             }
 

src/main/java/rx/internal/operators/OperatorOnErrorReturn.java

@@ -16,9 +16,11 @@
 package rx.internal.operators;
 
 import java.util.Arrays;
+
 import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.exceptions.CompositeException;
+import rx.exceptions.Exceptions;
 import rx.functions.Func1;
 import rx.plugins.RxJavaPlugins;
 
@@ -50,19 +52,29 @@ public OperatorOnErrorReturn(Func1<Throwable, ? extends T> resultFunction) {
 
     @Override
     public Subscriber<? super T> call(final Subscriber<? super T> child) {
-        return new Subscriber<T>(child) {
+        Subscriber<T> parent = new Subscriber<T>() {
+
+            private boolean done = false;
 
             @Override
             public void onNext(T t) {
+                if (done) {
+                    return;
+                }
                 child.onNext(t);
             }
 
             @Override
             public void onError(Throwable e) {
+                if (done) {
+                    Exceptions.throwIfFatal(e);
+                    return;
+                }
+                done = true;
                 try {
                     RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
+                    unsubscribe();
                     T result = resultFunction.call(e);
-                    
                     child.onNext(result);
                 } catch (Throwable x) {
                     child.onError(new CompositeException(Arrays.asList(e, x)));
@@ -73,9 +85,15 @@ public void onError(Throwable e) {
 
             @Override
             public void onCompleted() {
+                if (done) {
+                    return;
+                }
+                done = true;
                 child.onCompleted();
             }
 
         };
+        child.add(parent);
+        return parent;
     }
 }

src/main/java/rx/internal/operators/OperatorOnExceptionResumeNextViaObservable.java

@@ -18,6 +18,7 @@
 import rx.Observable;
 import rx.Observable.Operator;
 import rx.Subscriber;
+import rx.exceptions.Exceptions;
 import rx.plugins.RxJavaPlugins;
 
 /**
@@ -56,13 +57,23 @@ public Subscriber<? super T> call(final Subscriber<? super T> child) {
         // needs to independently unsubscribe so child can continue with the resume
         Subscriber<T> s = new Subscriber<T>() {
 
+            private boolean done = false;
+            
             @Override
             public void onNext(T t) {
+                if (done) {
+                    return;
+                }
                 child.onNext(t);
             }
 
             @Override
             public void onError(Throwable e) {
+                if (done) {
+                    Exceptions.throwIfFatal(e);
+                    return;
+                }
+                done = true;
                 if (e instanceof Exception) {
                     RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
                     unsubscribe();
@@ -74,6 +85,10 @@ public void onError(Throwable e) {
 
             @Override
             public void onCompleted() {
+                if (done) {
+                    return;
+                }
+                done = true;
                 child.onCompleted();
             }
 

src/main/java/rx/internal/operators/OperatorScan.java

@@ -129,7 +129,7 @@ public void setProducer(final Producer producer) {
                     @Override
                     public void request(long n) {
                         if (once.compareAndSet(false, true)) {
-                            if (initialValue == NO_INITIAL_VALUE) {
+                            if (initialValue == NO_INITIAL_VALUE || n == Long.MAX_VALUE) {
                                 producer.request(n);
                             } else {
                                 producer.request(n - 1);

src/main/java/rx/internal/operators/OperatorSwitch.java

@@ -62,6 +62,7 @@ private static final class SwitchSubscriber<T> extends Subscriber<Observable<? e
         volatile boolean infinite = false;
 
         public SwitchSubscriber(Subscriber<? super T> child) {
+            super(child);
             s = new SerializedSubscriber<T>(child);
             ssub = new SerialSubscription();
             child.add(ssub);

src/main/java/rx/internal/operators/OperatorTakeUntil.java

@@ -18,6 +18,7 @@
 import rx.Observable;
 import rx.Observable.Operator;
 import rx.Subscriber;
+import rx.observers.SerializedSubscriber;
 
 /**
  * Returns an Observable that emits the items from the source Observable until another Observable
@@ -35,7 +36,7 @@ public OperatorTakeUntil(final Observable<? extends E> other) {
 
     @Override
     public Subscriber<? super T> call(final Subscriber<? super T> child) {
-        final Subscriber<T> parent = new Subscriber<T>(child) {
+        final Subscriber<T> parent = new SerializedSubscriber<T>(child) {
 
             @Override
             public void onCompleted() {

src/test/java/rx/internal/operators/OperatorOnErrorResumeNextViaFunctionTest.java

@@ -35,6 +35,7 @@
 import rx.Subscription;
 import rx.functions.Func1;
 import rx.observers.TestSubscriber;
+import rx.schedulers.Schedulers;
 
 public class OperatorOnErrorResumeNextViaFunctionTest {
 
@@ -47,6 +48,8 @@ public void testResumeNextWithSynchronousExecution() {
             public void call(Subscriber<? super String> observer) {
                 observer.onNext("one");
                 observer.onError(new Throwable("injected failure"));
+                observer.onNext("two");
+                observer.onNext("three");
             }
         });
 
@@ -226,6 +229,47 @@ public Observable<String> call(Throwable t1) {
         System.out.println(ts.getOnNextEvents());
         ts.assertReceivedOnNext(Arrays.asList("success"));
     }
+    
+    @Test
+    public void testMapResumeAsyncNext() {
+        // Trigger multiple failures
+        Observable<String> w = Observable.just("one", "fail", "two", "three", "fail");
+
+        // Introduce map function that fails intermittently (Map does not prevent this when the observer is a
+        //  rx.operator incl onErrorResumeNextViaObservable)
+        w = w.map(new Func1<String, String>() {
+            @Override
+            public String call(String s) {
+                if ("fail".equals(s))
+                    throw new RuntimeException("Forced Failure");
+                System.out.println("BadMapper:" + s);
+                return s;
+            }
+        });
+
+        Observable<String> observable = w.onErrorResumeNext(new Func1<Throwable, Observable<String>>() {
+
+            @Override
+            public Observable<String> call(Throwable t1) {
+                return Observable.just("twoResume", "threeResume").subscribeOn(Schedulers.computation());
+            }
+            
+        });
+
+        @SuppressWarnings("unchecked")
+        Observer<String> observer = mock(Observer.class);
+        TestSubscriber<String> ts = new TestSubscriber<String>(observer);
+        observable.subscribe(ts);
+        ts.awaitTerminalEvent();
+
+        verify(observer, Mockito.never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+        verify(observer, times(1)).onNext("one");
+        verify(observer, Mockito.never()).onNext("two");
+        verify(observer, Mockito.never()).onNext("three");
+        verify(observer, times(1)).onNext("twoResume");
+        verify(observer, times(1)).onNext("threeResume");
+    }
 
     private static class TestObservable implements Observable.OnSubscribe<String> {
 

src/test/java/rx/internal/operators/OperatorOnErrorReturnTest.java

@@ -31,6 +31,8 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.functions.Func1;
+import rx.observers.TestSubscriber;
+import rx.schedulers.Schedulers;
 
 public class OperatorOnErrorReturnTest {
 
@@ -104,6 +106,46 @@ public String call(Throwable e) {
         verify(observer, times(0)).onCompleted();
         assertNotNull(capturedException.get());
     }
+    
+    @Test
+    public void testMapResumeAsyncNext() {
+        // Trigger multiple failures
+        Observable<String> w = Observable.just("one", "fail", "two", "three", "fail");
+
+        // Introduce map function that fails intermittently (Map does not prevent this when the observer is a
+        //  rx.operator incl onErrorResumeNextViaObservable)
+        w = w.map(new Func1<String, String>() {
+            @Override
+            public String call(String s) {
+                if ("fail".equals(s))
+                    throw new RuntimeException("Forced Failure");
+                System.out.println("BadMapper:" + s);
+                return s;
+            }
+        });
+
+        Observable<String> observable = w.onErrorReturn(new Func1<Throwable, String>() {
+
+            @Override
+            public String call(Throwable t1) {
+                return "resume";
+            }
+            
+        });
+
+        @SuppressWarnings("unchecked")
+        Observer<String> observer = mock(Observer.class);
+        TestSubscriber<String> ts = new TestSubscriber<String>(observer);
+        observable.subscribe(ts);
+        ts.awaitTerminalEvent();
+
+        verify(observer, Mockito.never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+        verify(observer, times(1)).onNext("one");
+        verify(observer, Mockito.never()).onNext("two");
+        verify(observer, Mockito.never()).onNext("three");
+        verify(observer, times(1)).onNext("resume");
+    }
 
     private static class TestObservable implements Observable.OnSubscribe<String> {
 

src/test/java/rx/internal/operators/OperatorSwitchTest.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.Matchers.anyString;
 import static org.mockito.Mockito.inOrder;
@@ -25,6 +26,7 @@
 
 import java.util.Arrays;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -513,4 +515,19 @@ public void onNext(String s) {
         testSubscriber.assertNoErrors();
         testSubscriber.assertTerminalEvent();
     }
+
+    @Test
+    public void testUnsubscribe() {
+        final AtomicBoolean isUnsubscribed = new AtomicBoolean();
+        Observable.switchOnNext(
+                Observable.create(new Observable.OnSubscribe<Observable<Integer>>() {
+                    @Override
+                    public void call(final Subscriber<? super Observable<Integer>> subscriber) {
+                        subscriber.onNext(Observable.just(1));
+                        isUnsubscribed.set(subscriber.isUnsubscribed());
+                    }
+                })
+        ).take(1).subscribe();
+        assertTrue("Switch doesn't propagate 'unsubscribe'", isUnsubscribed.get());
+    }
 }