/*
    * Copyright (C) 2008 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.util.concurrent.testing.MockFutureListener;
  
  import junit.framework.TestCase;
  
  import java.util.concurrent.TimeUnit;
  import java.util.concurrent.TimeoutException;
  
  /**
   * Unit tests for any listenable future that chains other listenable futures.
   * Unit tests need only override buildChainingFuture and getSuccessfulResult,
   * but they can add custom tests as needed.
   *
   * @author Nishant Thakkar
   */
  public abstract class AbstractChainedListenableFutureTest<T> extends TestCase {
    protected static final int EXCEPTION_DATA = -1;
    protected static final int VALID_INPUT_DATA = 1;
    protected static final Exception EXCEPTION = new Exception("Test exception");
  
    protected SettableFuture<Integer> inputFuture;
    protected ListenableFuture<T> resultFuture;
    protected MockFutureListener listener;
  
    @Override
    protected void setUp() throws Exception {
      super.setUp();
  
      inputFuture = SettableFuture.create();
      resultFuture = buildChainingFuture(inputFuture);
      listener = new MockFutureListener(resultFuture);
  
    }
  
    public void testFutureGetBeforeCallback() throws Exception {
      // Verify that get throws a timeout exception before the callback is called.
      try {
        resultFuture.get(1L, TimeUnit.MILLISECONDS);
        fail("The data is not yet ready, so a TimeoutException is expected");
      } catch (TimeoutException expected) {}
    }
  
    public void testFutureGetThrowsWrappedException() throws Exception {
      inputFuture.setException(EXCEPTION);
      listener.assertException(EXCEPTION);
    }
  
    public void testFutureGetThrowsWrappedError() throws Exception {
      Error error = new Error();
      inputFuture.setException(error);
      // Verify that get throws an ExecutionException, caused by an Error, when
      // the callback is called.
      listener.assertException(error);
    }
  
    public void testAddListenerAfterCallback() throws Throwable {
      inputFuture.set(VALID_INPUT_DATA);
  
      listener.assertSuccess(getSuccessfulResult());
    }
  
    public void testFutureBeforeCallback() throws Throwable {
      inputFuture.set(VALID_INPUT_DATA);
  
      listener.assertSuccess(getSuccessfulResult());
    }
  
    /**
     * Override to return a chaining listenableFuture that returns the result of
     * getSuccessfulResult() when inputFuture returns VALID_INPUT_DATA, and sets
     * the exception to EXCEPTION in all other cases.
     */
    protected abstract ListenableFuture<T> buildChainingFuture(
        ListenableFuture<Integer> inputFuture);
  
    /**
     * Override to return the result when VALID_INPUT_DATA is passed in to
     * the chaining listenableFuture
     */
    protected abstract T getSuccessfulResult();
  }