@Test
  public void testScanIntegersWithoutInitialValue() {
    Subscriber<Integer> observer = TestHelper.mockSubscriber();

    Observable<Integer> observable = Observable.just(1, 2, 3);

    Observable<Integer> m =
        observable.scan(
            new BiFunction<Integer, Integer, Integer>() {

              @Override
              public Integer apply(Integer t1, Integer t2) {
                return t1 + t2;
              }
            });
    m.subscribe(observer);

    verify(observer, never()).onError(any(Throwable.class));
    verify(observer, never()).onNext(0);
    verify(observer, times(1)).onNext(1);
    verify(observer, times(1)).onNext(3);
    verify(observer, times(1)).onNext(6);
    verify(observer, times(3)).onNext(anyInt());
    verify(observer, times(1)).onComplete();
    verify(observer, never()).onError(any(Throwable.class));
  }
  @Test
  public void testScanIntegersWithInitialValue() {
    Subscriber<String> observer = TestHelper.mockSubscriber();

    Observable<Integer> observable = Observable.just(1, 2, 3);

    Observable<String> m =
        observable.scan(
            "",
            new BiFunction<String, Integer, String>() {

              @Override
              public String apply(String s, Integer n) {
                return s + n.toString();
              }
            });
    m.subscribe(observer);

    verify(observer, never()).onError(any(Throwable.class));
    verify(observer, times(1)).onNext("");
    verify(observer, times(1)).onNext("1");
    verify(observer, times(1)).onNext("12");
    verify(observer, times(1)).onNext("123");
    verify(observer, times(4)).onNext(anyString());
    verify(observer, times(1)).onComplete();
    verify(observer, never()).onError(any(Throwable.class));
  }
  @Test
  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 Publisher<Observable<String>>() {
                @Override
                public void subscribe(Subscriber<? super Observable<String>> op) {
                  op.onSubscribe(EmptySubscription.INSTANCE);
                  op.onNext(Observable.create(o1));
                  op.onNext(Observable.create(o2));
                  op.onError(new NullPointerException("throwing exception in parent"));
                }
              });

      Subscriber<String> stringObserver = TestHelper.mockSubscriber();

      TestSubscriber<String> ts = new TestSubscriber<>(stringObserver);
      Observable<String> m = Observable.mergeDelayError(parentObservable);
      m.subscribe(ts);
      System.out.println("testErrorInParentObservableDelayed | " + i);
      ts.awaitTerminalEvent(2000, TimeUnit.MILLISECONDS);
      ts.assertTerminated();

      verify(stringObserver, times(2)).onNext("hello");
      verify(stringObserver, times(1)).onError(any(NullPointerException.class));
      verify(stringObserver, never()).onComplete();
    }
  }
  @Test
  @Ignore("Subscribers should not throw")
  public void testMergeSourceWhichDoesntPropagateExceptionBack() {
    Observable<Integer> source =
        Observable.create(
            new Publisher<Integer>() {
              @Override
              public void subscribe(Subscriber<? super Integer> t1) {
                t1.onSubscribe(EmptySubscription.INSTANCE);
                try {
                  t1.onNext(0);
                } catch (Throwable swallow) {

                }
                t1.onNext(1);
                t1.onComplete();
              }
            });

    Observable<Integer> result = Observable.mergeDelayError(source, Observable.just(2));

    final Subscriber<Integer> o = TestHelper.mockSubscriber();
    InOrder inOrder = inOrder(o);

    result.unsafeSubscribe(
        new Observer<Integer>() {
          int calls;

          @Override
          public void onNext(Integer t) {
            if (calls++ == 0) {
              throw new TestException();
            }
            o.onNext(t);
          }

          @Override
          public void onError(Throwable e) {
            o.onError(e);
          }

          @Override
          public void onComplete() {
            o.onComplete();
          }
        });

    /*
     * If the child onNext throws, why would we keep accepting values from
     * other sources?
     */
    inOrder.verify(o).onNext(2);
    inOrder.verify(o, never()).onNext(0);
    inOrder.verify(o, never()).onNext(1);
    inOrder.verify(o, never()).onNext(anyInt());
    inOrder.verify(o).onError(any(TestException.class));
    verify(o, never()).onComplete();
  }
 @Before
 public void before() {
   observer = TestHelper.mockSubscriber();
 }