/** * Returns an object that holds a stack trace created at the moment this method is executed. This * should be used specifically for {@link java.io.Closeable} objects and in conjunction with * {@link #logCloseableLeak(String, Object)}. */ public Object getStackTraceForCloseable(String closer) { if (logger.isLoggable(Level.FINE)) { return new Throwable(closer); // These are expensive to allocate. } return null; }
@Override public boolean matches(Method method, Class<?> targetClass, Object... args) { this.evaluations++; for (StackTraceElement element : new Throwable().getStackTrace()) { if (element.getClassName().equals(this.clazz.getName()) && (this.methodName == null || element.getMethodName().equals(this.methodName))) { return true; } } return false; }
@Override public void subscribe(Subscriber<? super String> subscriber) { subscribed.set(true); subscriber.onSubscribe(bs); subscriber.onError(new Throwable("test failed")); } });
public void testTrustedGetFailure_Failed() { SettableFuture<String> future = SettableFuture.create(); Throwable failure = new Throwable(); future.setException(failure); assertThat(future.tryInternalFastPathGetFailure()).isEqualTo(failure); }
@Override public void subscribe(Observer<? super String> observer) { subscribed.set(true); observer.onSubscribe(bs); observer.onError(new Throwable("test failed")); } });
public void testAllAsList_immediateFailure() throws Exception { Throwable exception = new Throwable("failed"); ListenableFuture<String> future1 = immediateFailedFuture(exception); ListenableFuture<String> future2 = immediateFuture("results"); ListenableFuture<List<String>> compound = allAsList(ImmutableList.of(future1, future2)); try { getDone(compound); fail(); } catch (ExecutionException expected) { assertSame(exception, expected.getCause()); } }
@Override public void subscribe(Subscriber<? super String> subscriber) { subscriber.onSubscribe(new BooleanSubscription()); subscriber.onNext("one"); subscriber.onError(new Throwable("test failed")); } });
public void testAllAsList_singleFailure() throws Exception { Throwable exception = new Throwable("failed"); ListenableFuture<String> future = immediateFailedFuture(exception); ListenableFuture<List<String>> compound = allAsList(ImmutableList.of(future)); try { getDone(compound); fail(); } catch (ExecutionException expected) { assertSame(exception, expected.getCause()); } }
@Test public void testDematerialize2() { Throwable exception = new Throwable("test"); Observable<Integer> o = Observable.error(exception); Observable<Integer> dematerialize = o.materialize().dematerialize(); Observer<Integer> observer = TestHelper.mockObserver(); dematerialize.subscribe(observer); verify(observer, times(1)).onError(exception); verify(observer, times(0)).onComplete(); verify(observer, times(0)).onNext(any(Integer.class)); }
public void testGetFailure_Failed() { AbstractFuture<String> future = new AbstractFuture<String>() {}; final Throwable failure = new Throwable(); future.setException(failure); assertThat(future.tryInternalFastPathGetFailure()).isNull(); }
@Test public void testDematerialize2() { Throwable exception = new Throwable("test"); Flowable<Integer> flowable = Flowable.error(exception); Flowable<Integer> dematerialize = flowable.materialize().dematerialize(); Subscriber<Integer> subscriber = TestHelper.mockSubscriber(); dematerialize.subscribe(subscriber); verify(subscriber, times(1)).onError(exception); verify(subscriber, times(0)).onComplete(); verify(subscriber, times(0)).onNext(any(Integer.class)); }
@Override public void subscribe(Subscriber<? super String> subscriber) { subscriber.onSubscribe(new BooleanSubscription()); subscriber.onNext("one"); subscriber.onError(new Throwable("injected failure")); subscriber.onNext("two"); subscriber.onNext("three"); } });
@Override public void subscribe(Observer<? super String> observer) { observer.onSubscribe(Disposables.empty()); observer.onNext("one"); observer.onError(new Throwable("test failed")); } });
@Override public void subscribe(Observer<? super String> observer) { observer.onSubscribe(Disposables.empty()); observer.onNext("one"); observer.onError(new Throwable("test failed")); } });
@Test public void isCheckedException() { assertTrue(ObjectUtils.isCheckedException(new Exception())); assertTrue(ObjectUtils.isCheckedException(new SQLException())); assertFalse(ObjectUtils.isCheckedException(new RuntimeException())); assertFalse(ObjectUtils.isCheckedException(new IllegalArgumentException(""))); // Any Throwable other than RuntimeException and Error // has to be considered checked according to the JLS. assertTrue(ObjectUtils.isCheckedException(new Throwable())); }
@Override public void subscribe(Observer<? super String> observer) { observer.onSubscribe(Disposables.empty()); observer.onNext("one"); observer.onError(new Throwable("injected failure")); observer.onNext("two"); observer.onNext("three"); } });
@Test public void delayedErrorsShouldBeEmittedWhenCompleteAfterApplyingBackpressure_NormalPath() { Throwable exception = new Throwable(); Flowable<Integer> source = Flowable.mergeDelayError(Flowable.range(1, 2), Flowable.<Integer>error(exception)); TestSubscriber<Integer> subscriber = new TestSubscriber<Integer>(0L); source.subscribe(subscriber); subscriber.request(3); // 1, 2, <error> subscriber.assertValues(1, 2); subscriber.assertTerminated(); assertEquals(asList(exception), subscriber.errors()); }
@Test public void delayedErrorsShouldBeEmittedWhenCompleteAfterApplyingBackpressure_FastPath() { Throwable exception = new Throwable(); Flowable<Integer> source = Flowable.mergeDelayError(Flowable.just(1), Flowable.<Integer>error(exception)); TestSubscriber<Integer> subscriber = new TestSubscriber<Integer>(0L); source.subscribe(subscriber); subscriber.request(2); // 1, <error> subscriber.assertValue(1); subscriber.assertTerminated(); assertEquals(asList(exception), subscriber.errors()); }
@Test public void shouldNotReceivedDelayedErrorWhileThereAreStillScalarSynchronousEmissionsInTheQueue() { Throwable exception = new Throwable(); Flowable<Integer> source = Flowable.mergeDelayError(Flowable.just(1), Flowable.just(2), Flowable.<Integer>error(exception)); TestSubscriber<Integer> subscriber = new TestSubscriber<Integer>(0L); subscriber.request(1); source.subscribe(subscriber); subscriber.assertValue(1); assertEquals(Collections.<Throwable>emptyList(), subscriber.errors()); subscriber.request(1); subscriber.assertValues(1, 2); assertEquals(asList(exception), subscriber.errors()); }
@Test public void shouldNotReceivedDelayedErrorWhileThereAreStillNormalEmissionsInTheQueue() { Throwable exception = new Throwable(); Flowable<Integer> source = Flowable.mergeDelayError(Flowable.range(1, 2), Flowable.range(3, 2), Flowable.<Integer>error(exception)); TestSubscriber<Integer> subscriber = new TestSubscriber<Integer>(0L); subscriber.request(3); source.subscribe(subscriber); subscriber.assertValues(1, 2, 3); assertEquals(Collections.<Throwable>emptyList(), subscriber.errors()); subscriber.request(2); subscriber.assertValues(1, 2, 3, 4); assertEquals(asList(exception), subscriber.errors()); }