How to use

java.lang.UnsupportedOperationException

constructor

 @Override
 public Condition newCondition() {
  throw new UnsupportedOperationException();
 }
}

  @Override
  public final boolean offer(R v1, R v2) {
    throw new UnsupportedOperationException("Should not be called!");
  }
}

  @Override
  public final boolean offer(R v1, R v2) {
    throw new UnsupportedOperationException("Should not be called!");
  }
}

@Override
public Condition newCondition() {
 throw new UnsupportedOperationException();
}

  @Override
  public final boolean offer(T v1, T v2) {
    throw new UnsupportedOperationException("Should not be called");
  }
}

  @Override
  public void run() {
    throw new UnsupportedOperationException();
  }
})

  @Override
  public void remove() {
    throw new UnsupportedOperationException();
  }
}

  @Override
  public void run() throws Exception {
    throw new UnsupportedOperationException();
  }
})

  @Override
  public Object call() throws Exception {
    throw new UnsupportedOperationException();
  }
})

  @Override
  public void remove() {
    throw new UnsupportedOperationException();
  }
}

  @Override
  public void remove() {
    throw new UnsupportedOperationException();
  }
}

  @Override
  public void remove() {
    throw new UnsupportedOperationException();
  }
}

  @NonNull
  @Override
  public Disposable schedulePeriodically(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) {
    throw new UnsupportedOperationException("This scheduler doesn't support periodic execution");
  }
}

@Test
public void shouldErrorIfUnderlyingErrors() {
  Observer<String> observer = TestHelper.mockObserver();
  TestObserver<String> to = new TestObserver<String>(observer);
  withTimeout.subscribe(observer);
  testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
  underlyingSubject.onError(new UnsupportedOperationException());
  testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
  verify(observer).onError(any(UnsupportedOperationException.class));
  to.dispose();
}

@Test
public void fromPublisherThrows() {
  Completable.fromPublisher(Flowable.error(new UnsupportedOperationException()))
    .test()
    .assertFailure(UnsupportedOperationException.class);
}

@Test
public void fromSingleThrows() {
  Maybe.fromSingle(Single.error(new UnsupportedOperationException()))
    .test()
    .assertFailure(UnsupportedOperationException.class);
}

  @Test
  public void fromSingleError() {
    Completable.fromSingle(Single.error(new UnsupportedOperationException()))
      .test()
      .assertFailure(UnsupportedOperationException.class);
  }
}

  @Test
  public void fromMaybeError() {
    Completable.fromMaybe(Maybe.error(new UnsupportedOperationException()))
      .test()
      .assertFailure(UnsupportedOperationException.class);
  }
}

@Test
public void shouldErrorIfUnderlyingErrors() {
  Subscriber<String> subscriber = TestHelper.mockSubscriber();
  TestSubscriber<String> ts = new TestSubscriber<String>(subscriber);
  withTimeout.subscribe(subscriber);
  testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
  underlyingSubject.onError(new UnsupportedOperationException());
  testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
  verify(subscriber).onError(any(UnsupportedOperationException.class));
  ts.dispose();
}

  @Test
  public void fromObservableError() {
    Completable.fromObservable(Observable.error(new UnsupportedOperationException()))
      .test()
      .assertFailure(UnsupportedOperationException.class);
  }
}