@Override public void run() { delayedCancelled.cancel(true); } };
@Override protected void finalize() { future.cancel(false); } };
public void testFutureGetThrowsCancellationIfOutputCancelled() throws Exception { inputFuture.set(SLOW_OUTPUT_VALID_INPUT_DATA); outputFuture.cancel(true); // argument is ignored try { resultFuture.get(); fail( "Result future must throw CancellationException" + " if function output future is cancelled."); } catch (CancellationException expected) { } }
public void testFutureGetThrowsCancellationIfInputCancelled() throws Exception { inputFuture.cancel(true); // argument is ignored try { resultFuture.get(); fail("Result future must throw CancellationException" + " if input future is cancelled."); } catch (CancellationException expected) { } }
public void testCancel_beforeSet() throws Exception { SettableFuture<Object> async = SettableFuture.create(); async.cancel(true); assertFalse(async.set(42)); }
public void testTrustedGetFailure_CanceledNoCause() { SettableFuture<String> future = SettableFuture.create(); future.cancel(false); assertThat(future.tryInternalFastPathGetFailure()).isNull(); }
public void testGetCheckedUntimed_cancelled() throws TwoArgConstructorException { SettableFuture<String> future = SettableFuture.create(); future.cancel(true); try { getChecked(future, TwoArgConstructorException.class); fail(); } catch (CancellationException expected) { } }
public void testGetUnchecked_cancelled() { SettableFuture<String> future = SettableFuture.create(); future.cancel(true); try { getUnchecked(future); fail(); } catch (CancellationException expected) { } }
public void testGetCheckedTimed_cancelled() throws TwoArgConstructorException { SettableFuture<String> future = SettableFuture.create(); future.cancel(true); try { getChecked(future, TwoArgConstructorException.class, 0, SECONDS); fail(); } catch (CancellationException expected) { } }
public void testCancel() throws Exception { assertTrue(future.cancel(true)); tester.testCancelledFuture(); }
public void testCancel_multipleBeforeSetFuture_interruptFirst() throws Exception { SettableFuture<Object> async = SettableFuture.create(); async.cancel(true); async.cancel(false); SettableFuture<Object> inner = SettableFuture.create(); assertFalse(async.setFuture(inner)); assertTrue(inner.isCancelled()); assertTrue(inner.wasInterrupted()); } }
public void testCancel_multipleBeforeSetFuture_noInterruptFirst() throws Exception { SettableFuture<Object> async = SettableFuture.create(); async.cancel(false); async.cancel(true); SettableFuture<Object> inner = SettableFuture.create(); assertFalse(async.setFuture(inner)); assertTrue(inner.isCancelled()); assertFalse(inner.wasInterrupted()); }
@GwtIncompatible // threads public void testSubmitAsync_asyncCallable_returnsInterruptedFuture() throws InterruptedException { assertThat(Thread.interrupted()).isFalse(); SettableFuture<Integer> cancelledFuture = SettableFuture.create(); cancelledFuture.cancel(true); assertThat(Thread.interrupted()).isFalse(); ListenableFuture<Integer> future = submitAsync(constantAsyncCallable(cancelledFuture), directExecutor()); assertThat(future.isDone()).isTrue(); assertThat(Thread.interrupted()).isFalse(); }
public void testSetFutureSelf_cancel() { SettableFuture<String> orig = SettableFuture.create(); orig.setFuture(orig); orig.cancel(true); assertTrue(orig.isCancelled()); }
public void testCancel_innerCancelsAsync() throws Exception { SettableFuture<Object> async = SettableFuture.create(); SettableFuture<Object> inner = SettableFuture.create(); async.setFuture(inner); inner.cancel(true); assertTrue(async.isCancelled()); try { async.get(); fail("Expected CancellationException"); } catch (CancellationException expected) { /* expected */ } }
public void testCancel_resultCancelsInner() throws Exception { SettableFuture<Object> async = SettableFuture.create(); SettableFuture<Object> inner = SettableFuture.create(); async.setFuture(inner); async.cancel(false); assertTrue(inner.isCancelled()); assertFalse(inner.wasInterrupted()); try { inner.get(); fail("Expected CancellationException"); } catch (CancellationException expected) { /* expected */ } }
public void testCancel_resultCancelsInner_interrupted() throws Exception { SettableFuture<Object> async = SettableFuture.create(); SettableFuture<Object> inner = SettableFuture.create(); async.setFuture(inner); async.cancel(true); assertTrue(inner.isCancelled()); assertTrue(inner.wasInterrupted()); try { inner.get(); fail("Expected CancellationException"); } catch (CancellationException expected) { /* expected */ } }
public void testNonCancellationPropagating_delegateCancelled() throws Exception { SettableFuture<Foo> input = SettableFuture.create(); ListenableFuture<Foo> wrapper = nonCancellationPropagating(input); assertFalse(wrapper.isDone()); assertTrue(input.cancel(false)); assertTrue(wrapper.isCancelled()); }
public void testCancel_stackOverflow() { SettableFuture<String> orig = SettableFuture.create(); SettableFuture<String> prev = orig; for (int i = 0; i < 100000; i++) { SettableFuture<String> curr = SettableFuture.create(); prev.setFuture(curr); prev = curr; } // orig is the 'outermost future', this should propagate fully down the stack of futures. orig.cancel(true); assertTrue(orig.isCancelled()); assertTrue(prev.isCancelled()); assertTrue(prev.wasInterrupted()); }
public void testSuccessfulAsList_cancelled() throws Exception { SingleCallListener listener = new SingleCallListener(); SettableFuture<String> future1 = SettableFuture.create(); SettableFuture<String> future2 = SettableFuture.create(); @SuppressWarnings("unchecked") // array is never modified ListenableFuture<List<String>> compound = successfulAsList(future1, future2); compound.addListener(listener, directExecutor()); assertFalse(compound.isDone()); future1.cancel(true); assertFalse(compound.isDone()); listener.expectCall(); future2.set(DATA2); assertTrue(listener.wasCalled()); List<String> results = getDone(compound); assertThat(results).containsExactly(null, DATA2).inOrder(); }