util/concurrent/FutureCallbackTest.java

/*
 * Copyright (C) 2011 The Guava Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.util.concurrent;

import com.google.common.base.Preconditions;

import junit.framework.TestCase;

import org.mockito.Mockito;

import java.util.concurrent.CancellationException;
import java.util.concurrent.Executor;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

import javax.annotation.Nullable;

/**
 * Test for {@link FutureCallback}.
 *
 * @author Anthony Zana
 */
public class FutureCallbackTest extends TestCase {
  public void testSameThreadSuccess() {
    SettableFuture<String> f = SettableFuture.create();
    MockCallback callback = new MockCallback("foo");
    Futures.addCallback(f, callback);
    f.set("foo");
  }

  public void testExecutorSuccess() {
    CountingSameThreadExecutor ex = new CountingSameThreadExecutor();
    SettableFuture<String> f = SettableFuture.create();
    MockCallback callback = new MockCallback("foo");
    Futures.addCallback(f, callback, ex);
    f.set("foo");
    assertEquals(1, ex.runCount);
  }

  // Error cases
  public void testSameThreadExecutionException() {
    SettableFuture<String> f = SettableFuture.create();
    Exception e = new IllegalArgumentException("foo not found");
    MockCallback callback = new MockCallback(e);
    Futures.addCallback(f, callback);
    f.setException(e);
  }

  public void testCancel() {
    SettableFuture<String> f = SettableFuture.create();
    FutureCallback<String> callback =
        new FutureCallback<String>() {
          private boolean called = false;
          @Override
          public void onSuccess(String result) {
            fail("Was not expecting onSuccess() to be called.");
          }

          @Override
          public synchronized void onFailure(Throwable t) {
            assertFalse(called);
            assertTrue(t instanceof CancellationException);
            called = true;
          }
        };
    Futures.addCallback(f, callback);
    f.cancel(true);
  }

  public void testThrowErrorFromGet() {
    Error error = new AssertionError("ASSERT!");
    ListenableFuture<String> f = ThrowingFuture.throwingError(error);
    MockCallback callback = new MockCallback(error);
    Futures.addCallback(f, callback);
  }

  public void testRuntimeExeceptionFromGet() {
    RuntimeException e = new IllegalArgumentException("foo not found");
    ListenableFuture<String> f = ThrowingFuture.throwingRuntimeException(e);
    MockCallback callback = new MockCallback(e);
    Futures.addCallback(f, callback);
  }

  public void testOnSuccessThrowsRuntimeException() throws Exception {
    RuntimeException exception = new RuntimeException();
    String result = "result";
    SettableFuture<String> future = SettableFuture.create();
    @SuppressWarnings("unchecked") // Safe for a mock
    FutureCallback<String> callback = Mockito.mock(FutureCallback.class);
    Futures.addCallback(future, callback);
    Mockito.doThrow(exception).when(callback).onSuccess(result);
    future.set(result);
    assertEquals(result, future.get());
    Mockito.verify(callback).onSuccess(result);
    Mockito.verifyNoMoreInteractions(callback);
  }

  public void testOnSuccessThrowsError() throws Exception {
    class TestError extends Error {}
    TestError error = new TestError();
    String result = "result";
    SettableFuture<String> future = SettableFuture.create();
    @SuppressWarnings("unchecked") // Safe for a mock
    FutureCallback<String> callback = Mockito.mock(FutureCallback.class);
    Futures.addCallback(future, callback);
    Mockito.doThrow(error).when(callback).onSuccess(result);
    try {
      future.set(result);
      fail("Should have thrown");
    } catch (TestError e) {
      assertSame(error, e);
    }
    assertEquals(result, future.get());
    Mockito.verify(callback).onSuccess(result);
    Mockito.verifyNoMoreInteractions(callback);
  }

  public void testWildcardFuture() {
    SettableFuture<String> settable = SettableFuture.create();
    ListenableFuture<?> f = settable;
    FutureCallback<Object> callback = new FutureCallback<Object>() {
      @Override
      public void onSuccess(Object result) {}

      @Override
      public void onFailure(Throwable t) {}
    };
    Futures.addCallback(f, callback);
  }

  private class CountingSameThreadExecutor implements Executor {
    int runCount = 0;
    @Override
    public void execute(Runnable command) {
      command.run();
      runCount++;
    }
  }

  // TODO(user): Move to testing, unify with RuntimeExceptionThrowingFuture

  /**
   * A {@link Future} implementation which always throws directly from calls to
   * get() (i.e. not wrapped in ExecutionException.
   * For just a normal Future failure, use {@link SettableFuture}).
   *
   * <p>Useful for testing the behavior of Future utilities against odd futures.
   *
   * @author Anthony Zana
   */
  private static class ThrowingFuture<V> implements ListenableFuture<V> {
    private final Error error;
    private final RuntimeException runtime;

    public static <V> ListenableFuture<V> throwingError(Error error) {
      return new ThrowingFuture<V>(error);
    }

    public static <V> ListenableFuture<V>
        throwingRuntimeException(RuntimeException e) {
      return new ThrowingFuture<V>(e);
    }

    private ThrowingFuture(Error error) {
      this.error = Preconditions.checkNotNull(error);
      this.runtime = null;
    }

    public ThrowingFuture(RuntimeException e) {
      this.runtime = Preconditions.checkNotNull(e);
      this.error = null;
    }

    @Override
    public boolean cancel(boolean mayInterruptIfRunning) {
      return false;
    }

    @Override
    public boolean isCancelled() {
      return false;
    }

    @Override
    public boolean isDone() {
      return true;
    }

    @Override
    public V get() {
      throwOnGet();
      throw new AssertionError("Unreachable");
    }

    @Override
    public V get(long timeout, TimeUnit unit) {
      throwOnGet();
      throw new AssertionError("Unreachable");
    }

    @Override
    public void addListener(Runnable listener, Executor executor) {
      executor.execute(listener);
    }

    private void throwOnGet() {
      if (error != null) {
        throw error;
      } else {
        throw runtime;
      }
    }
  }

  private final class MockCallback implements FutureCallback<String> {
    @Nullable private String value = null;
    @Nullable private Throwable failure = null;
    private boolean wasCalled = false;

    MockCallback(String expectedValue) {
      this.value = expectedValue;
    }

    public MockCallback(Throwable expectedFailure) {
      this.failure = expectedFailure;
    }

    @Override
    public synchronized void onSuccess(String result) {
      assertFalse(wasCalled);
      wasCalled = true;
      assertEquals(value, result);
    }

    @Override
    public synchronized void onFailure(Throwable t) {
      assertFalse(wasCalled);
      wasCalled = true;
      assertEquals(failure, t);
    }
  }
}