Down to 7 of 893 unit tests failing

Author: benjchristensen

rxjava-core/src/test/java/rx/ObservableTests.java

@@ -27,6 +27,7 @@
 import org.junit.Test;
 import org.mockito.MockitoAnnotations;
 
+import rx.observers.TestObserver;
 import rx.schedulers.TestScheduler;
 import rx.subscriptions.Subscriptions;
 import rx.util.functions.Action0;
@@ -57,9 +58,9 @@ public void call() {
         });
         Observable<Integer> refCounted = observable.publish().refCount();
         Observer<Integer> observer = mock(Observer.class);
-        Subscription first = refCounted.subscribe(observer);
+        Subscription first = refCounted.subscribe(new TestObserver<Integer>(observer));
         assertEquals(1, subscriptionCount.get());
-        Subscription second = refCounted.subscribe(observer);
+        Subscription second = refCounted.subscribe(new TestObserver<Integer>(observer));
         assertEquals(1, subscriptionCount.get());
         first.unsubscribe();
         assertEquals(0, unsubscriptionCount.get());

rxjava-core/src/test/java/rx/RefCountTests.java

@@ -22,6 +22,7 @@
 import org.junit.Test;
 import org.mockito.InOrder;
 
+import rx.observers.TestObserver;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
@@ -33,7 +34,7 @@ public void testThrottle() {
         Observer<Integer> observer = mock(Observer.class);
         TestScheduler s = new TestScheduler();
         PublishSubject<Integer> o = PublishSubject.create();
-        o.toObservable().throttleFirst(500, TimeUnit.MILLISECONDS, s).subscribe(observer);
+        o.toObservable().throttleFirst(500, TimeUnit.MILLISECONDS, s).subscribe(new TestObserver<Integer>(observer));
 
         // send events with simulated time increments
         s.advanceTimeTo(0, TimeUnit.MILLISECONDS);

rxjava-core/src/test/java/rx/ThrottleFirstTests.java

@@ -22,6 +22,7 @@
 import org.junit.Test;
 import org.mockito.InOrder;
 
+import rx.observers.TestObserver;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
@@ -33,7 +34,7 @@ public void testThrottle() {
         Observer<Integer> observer = mock(Observer.class);
         TestScheduler s = new TestScheduler();
         PublishSubject<Integer> o = PublishSubject.create();
-        o.toObservable().throttleLast(500, TimeUnit.MILLISECONDS, s).subscribe(observer);
+        o.toObservable().throttleLast(500, TimeUnit.MILLISECONDS, s).subscribe(new TestObserver<Integer>(observer));
 
         // send events with simulated time increments
         s.advanceTimeTo(0, TimeUnit.MILLISECONDS);

rxjava-core/src/test/java/rx/ThrottleLastTests.java

@@ -22,6 +22,7 @@
 import org.junit.Test;
 import org.mockito.InOrder;
 
+import rx.observers.TestObserver;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
@@ -33,7 +34,7 @@ public void testThrottle() {
         Observer<Integer> observer = mock(Observer.class);
         TestScheduler s = new TestScheduler();
         PublishSubject<Integer> o = PublishSubject.create();
-        o.toObservable().throttleWithTimeout(500, TimeUnit.MILLISECONDS, s).subscribe(observer);
+        o.toObservable().throttleWithTimeout(500, TimeUnit.MILLISECONDS, s).subscribe(new TestObserver<Integer>(observer));
 
         // send events with simulated time increments
         s.advanceTimeTo(0, TimeUnit.MILLISECONDS);

rxjava-core/src/test/java/rx/ThrottleWithTimeoutTests.java

@@ -26,6 +26,7 @@
 import org.mockito.InOrder;
 import org.mockito.MockitoAnnotations;
 
+import rx.observers.TestObserver;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
@@ -49,7 +50,7 @@ public void setUp() {
     public void shouldNotTimeoutIfOnNextWithinTimeout() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Subscription subscription = withTimeout.subscribe(observer);
+        Subscription subscription = withTimeout.subscribe(new TestObserver<String>(observer));
         testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
         underlyingSubject.onNext("One");
         verify(observer).onNext("One");
@@ -62,7 +63,7 @@ public void shouldNotTimeoutIfOnNextWithinTimeout() {
     public void shouldNotTimeoutIfSecondOnNextWithinTimeout() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Subscription subscription = withTimeout.subscribe(observer);
+        Subscription subscription = withTimeout.subscribe(new TestObserver<String>(observer));
         testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
         underlyingSubject.onNext("One");
         testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
@@ -77,7 +78,7 @@ public void shouldNotTimeoutIfSecondOnNextWithinTimeout() {
     public void shouldTimeoutIfOnNextNotWithinTimeout() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Subscription subscription = withTimeout.subscribe(observer);
+        Subscription subscription = withTimeout.subscribe(new TestObserver<String>(observer));
         testScheduler.advanceTimeBy(TIMEOUT + 1, TimeUnit.SECONDS);
         verify(observer).onError(any(TimeoutException.class));
         subscription.unsubscribe();
@@ -87,7 +88,7 @@ public void shouldTimeoutIfOnNextNotWithinTimeout() {
     public void shouldTimeoutIfSecondOnNextNotWithinTimeout() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Subscription subscription = withTimeout.subscribe(observer);
+        Subscription subscription = withTimeout.subscribe(new TestObserver<String>(observer));
         testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
         underlyingSubject.onNext("One");
         verify(observer).onNext("One");
@@ -100,7 +101,7 @@ public void shouldTimeoutIfSecondOnNextNotWithinTimeout() {
     public void shouldCompleteIfUnderlyingComletes() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Subscription subscription = withTimeout.subscribe(observer);
+        Subscription subscription = withTimeout.subscribe(new TestObserver<String>(observer));
         testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
         underlyingSubject.onCompleted();
         testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
@@ -113,7 +114,7 @@ public void shouldCompleteIfUnderlyingComletes() {
     public void shouldErrorIfUnderlyingErrors() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Subscription subscription = withTimeout.subscribe(observer);
+        Subscription subscription = withTimeout.subscribe(new TestObserver<String>(observer));
         testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
         underlyingSubject.onError(new UnsupportedOperationException());
         testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
@@ -128,7 +129,7 @@ public void shouldSwitchToOtherIfOnNextNotWithinTimeout() {
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Subscription subscription = source.subscribe(observer);
+        Subscription subscription = source.subscribe(new TestObserver<String>(observer));
 
         testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
         underlyingSubject.onNext("One");
@@ -151,7 +152,7 @@ public void shouldSwitchToOtherIfOnErrorNotWithinTimeout() {
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Subscription subscription = source.subscribe(observer);
+        Subscription subscription = source.subscribe(new TestObserver<String>(observer));
 
         testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
         underlyingSubject.onNext("One");
@@ -174,7 +175,7 @@ public void shouldSwitchToOtherIfOnCompletedNotWithinTimeout() {
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Subscription subscription = source.subscribe(observer);
+        Subscription subscription = source.subscribe(new TestObserver<String>(observer));
 
         testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
         underlyingSubject.onNext("One");
@@ -197,7 +198,7 @@ public void shouldSwitchToOtherAndCanBeUnsubscribedIfOnNextNotWithinTimeout() {
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Subscription subscription = source.subscribe(observer);
+        Subscription subscription = source.subscribe(new TestObserver<String>(observer));
 
         testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
         underlyingSubject.onNext("One");

rxjava-core/src/test/java/rx/TimeoutTests.java

@@ -370,7 +370,8 @@ public void whenComplicated() {
                 xs.toObservable().and(zs.toObservable()).then(mul2),
                 ys.toObservable().and(zs.toObservable()).then(sub2)
                 );
-        m.subscribe(new TestObserver<Object>(observer));
+        TestObserver<Object> to = new TestObserver<Object>(observer);
+        m.subscribe(to);
 
         xs.onNext(1); // t == 210
 
@@ -392,6 +393,8 @@ public void whenComplicated() {
 
         zs.onCompleted(); // t == 300
 
+        System.out.println("Events: " + to.getOnNextEvents());
+        
         InOrder inOrder = inOrder(observer);
         inOrder.verify(observer, times(1)).onNext(1 * 7);
         inOrder.verify(observer, times(1)).onNext(2 * 8);

rxjava-core/src/test/java/rx/operators/OperationJoinsTest.java

@@ -28,6 +28,7 @@
 
 import rx.Observer;
 import rx.Subscription;
+import rx.observers.TestObserver;
 import rx.util.functions.Action1;
 
 public class AsyncSubjectTest {
@@ -39,77 +40,77 @@ public void testNeverCompleted() {
         AsyncSubject<String> subject = AsyncSubject.create();
 
         @SuppressWarnings("unchecked")
-        Observer<String> aObserver = mock(Observer.class);
-        subject.toObservable().subscribe(aObserver);
+        Observer<String> observer = mock(Observer.class);
+        subject.toObservable().subscribe(new TestObserver<String>(observer));
 
         subject.onNext("one");
         subject.onNext("two");
         subject.onNext("three");
 
-        verify(aObserver, Mockito.never()).onNext(anyString());
-        verify(aObserver, Mockito.never()).onError(testException);
-        verify(aObserver, Mockito.never()).onCompleted();
+        verify(observer, Mockito.never()).onNext(anyString());
+        verify(observer, Mockito.never()).onError(testException);
+        verify(observer, Mockito.never()).onCompleted();
     }
 
     @Test
     public void testCompleted() {
         AsyncSubject<String> subject = AsyncSubject.create();
 
         @SuppressWarnings("unchecked")
-        Observer<String> aObserver = mock(Observer.class);
-        subject.toObservable().subscribe(aObserver);
+        Observer<String> observer = mock(Observer.class);
+        subject.toObservable().subscribe(new TestObserver<String>(observer));
 
         subject.onNext("one");
         subject.onNext("two");
         subject.onNext("three");
         subject.onCompleted();
 
-        verify(aObserver, times(1)).onNext("three");
-        verify(aObserver, Mockito.never()).onError(any(Throwable.class));
-        verify(aObserver, times(1)).onCompleted();
+        verify(observer, times(1)).onNext("three");
+        verify(observer, Mockito.never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
     }
 
     @Test
     public void testNull() {
         AsyncSubject<String> subject = AsyncSubject.create();
 
         @SuppressWarnings("unchecked")
-        Observer<String> aObserver = mock(Observer.class);
-        subject.toObservable().subscribe(aObserver);
+        Observer<String> observer = mock(Observer.class);
+        subject.toObservable().subscribe(new TestObserver<String>(observer));
 
         subject.onNext(null);
         subject.onCompleted();
 
-        verify(aObserver, times(1)).onNext(null);
-        verify(aObserver, Mockito.never()).onError(any(Throwable.class));
-        verify(aObserver, times(1)).onCompleted();
+        verify(observer, times(1)).onNext(null);
+        verify(observer, Mockito.never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
     }
 
     @Test
     public void testSubscribeAfterCompleted() {
         AsyncSubject<String> subject = AsyncSubject.create();
 
         @SuppressWarnings("unchecked")
-        Observer<String> aObserver = mock(Observer.class);
+        Observer<String> observer = mock(Observer.class);
 
         subject.onNext("one");
         subject.onNext("two");
         subject.onNext("three");
         subject.onCompleted();
 
-        subject.toObservable().subscribe(aObserver);
+        subject.toObservable().subscribe(new TestObserver<String>(observer));
 
-        verify(aObserver, times(1)).onNext("three");
-        verify(aObserver, Mockito.never()).onError(any(Throwable.class));
-        verify(aObserver, times(1)).onCompleted();
+        verify(observer, times(1)).onNext("three");
+        verify(observer, Mockito.never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
     }
 
     @Test
     public void testSubscribeAfterError() {
         AsyncSubject<String> subject = AsyncSubject.create();
 
         @SuppressWarnings("unchecked")
-        Observer<String> aObserver = mock(Observer.class);
+        Observer<String> observer = mock(Observer.class);
 
         subject.onNext("one");
         subject.onNext("two");
@@ -118,20 +119,20 @@ public void testSubscribeAfterError() {
         RuntimeException re = new RuntimeException("failed");
         subject.onError(re);
 
-        subject.toObservable().subscribe(aObserver);
+        subject.toObservable().subscribe(new TestObserver<String>(observer));
 
-        verify(aObserver, times(1)).onError(re);
-        verify(aObserver, Mockito.never()).onNext(any(String.class));
-        verify(aObserver, Mockito.never()).onCompleted();
+        verify(observer, times(1)).onError(re);
+        verify(observer, Mockito.never()).onNext(any(String.class));
+        verify(observer, Mockito.never()).onCompleted();
     }
 
     @Test
     public void testError() {
         AsyncSubject<String> subject = AsyncSubject.create();
 
         @SuppressWarnings("unchecked")
-        Observer<String> aObserver = mock(Observer.class);
-        subject.toObservable().subscribe(aObserver);
+        Observer<String> observer = mock(Observer.class);
+        subject.toObservable().subscribe(new TestObserver<String>(observer));
 
         subject.onNext("one");
         subject.onNext("two");
@@ -141,50 +142,50 @@ public void testError() {
         subject.onError(new Throwable());
         subject.onCompleted();
 
-        verify(aObserver, Mockito.never()).onNext(anyString());
-        verify(aObserver, times(1)).onError(testException);
-        verify(aObserver, Mockito.never()).onCompleted();
+        verify(observer, Mockito.never()).onNext(anyString());
+        verify(observer, times(1)).onError(testException);
+        verify(observer, Mockito.never()).onCompleted();
     }
 
     @Test
     public void testUnsubscribeBeforeCompleted() {
         AsyncSubject<String> subject = AsyncSubject.create();
 
         @SuppressWarnings("unchecked")
-        Observer<String> aObserver = mock(Observer.class);
-        Subscription subscription = subject.toObservable().subscribe(aObserver);
+        Observer<String> observer = mock(Observer.class);
+        Subscription subscription = subject.toObservable().subscribe(new TestObserver<String>(observer));
 
         subject.onNext("one");
         subject.onNext("two");
 
         subscription.unsubscribe();
 
-        verify(aObserver, Mockito.never()).onNext(anyString());
-        verify(aObserver, Mockito.never()).onError(any(Throwable.class));
-        verify(aObserver, Mockito.never()).onCompleted();
+        verify(observer, Mockito.never()).onNext(anyString());
+        verify(observer, Mockito.never()).onError(any(Throwable.class));
+        verify(observer, Mockito.never()).onCompleted();
 
         subject.onNext("three");
         subject.onCompleted();
 
-        verify(aObserver, Mockito.never()).onNext(anyString());
-        verify(aObserver, Mockito.never()).onError(any(Throwable.class));
-        verify(aObserver, Mockito.never()).onCompleted();
+        verify(observer, Mockito.never()).onNext(anyString());
+        verify(observer, Mockito.never()).onError(any(Throwable.class));
+        verify(observer, Mockito.never()).onCompleted();
     }
 
     @Test
     public void testEmptySubjectCompleted() {
         AsyncSubject<String> subject = AsyncSubject.create();
 
         @SuppressWarnings("unchecked")
-        Observer<String> aObserver = mock(Observer.class);
-        subject.toObservable().subscribe(aObserver);
+        Observer<String> observer = mock(Observer.class);
+        subject.toObservable().subscribe(new TestObserver<String>(observer));
 
         subject.onCompleted();
 
-        InOrder inOrder = inOrder(aObserver);
-        inOrder.verify(aObserver, never()).onNext(null);
-        inOrder.verify(aObserver, never()).onNext(any(String.class));
-        inOrder.verify(aObserver, times(1)).onCompleted();
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, never()).onNext(null);
+        inOrder.verify(observer, never()).onNext(any(String.class));
+        inOrder.verify(observer, times(1)).onCompleted();
         inOrder.verifyNoMoreInteractions();
     }