import java.util.concurrent.TimeoutException;
import junit.framework.TestCase;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Base class for tests for emulated {@link AbstractFuture} that allow subclasses to swap in a
 * different "source Future" for {@link AbstractFuture#setFuture} calls.
 */
@GwtCompatible(emulated = true)
abstract class AbstractAbstractFutureTest extends TestCase {

      try {
        Object actualReturnValue = method.invoke(wrapper, passedArgs);
        // If we think this might be a 'chaining' call then we allow the return value to either
        // be the wrapper or the returnValue.
        if (!isPossibleChainingCall || wrapper != actualReturnValue) {
          assertEquals(

      Correspondence.from(
          new BinaryPredicate<Double, Double>() {
            @Override
            public boolean apply(@Nullable Double actual, @Nullable Double expected) {
              // Test for equality to allow non-finite values to match; otherwise, use the finite
              // test.
              return actual.equals(expected)
                  || FINITE_QUANTILE_CORRESPONDENCE.compare(actual, expected);
            }

    assertFalse(inputFuture.isCancelled());
    assertFalse(outputFuture.isCancelled());
    assertThrows(CancellationException.class, () -> resultFuture.get());

    funcCompletionLatch.countDown(); // allow the function to complete
    assertThrows(CancellationException.class, () -> outputFuture.get());
  }

  public void testFutureCancelAfterCompletion() throws Exception {
    inputFuture.set(VALID_INPUT_DATA);

   * is permitted and similarly for decrease/remove(). We assume that a
   * setCount() no-op is permitted if either add() or remove() is permitted,
   * though we also allow it to "succeed" if neither is permitted.
   */

  private void assertSetCount(E element, int count) {
    setCountCheckReturnValue(element, count);

    assertEquals(

       */
      @Override
      protected int tryAcquireShared(int ignored) {
        if (isDone()) {
          return 1;
        }
        return -1;
      }

      /*
       * We always allow a release to go through, this means the state has been
       * successfully changed and the result is available.
       */
      @Override
      protected boolean tryReleaseShared(int finalState) {

 */
@GwtCompatible(emulated = true)
final class LenientSerializableTester {
  /*
   * TODO(cpovirk): move this to c.g.c.testing if we allow for c.g.c.annotations dependencies so
   * that it can be GWTified?
   */
  @CanIgnoreReturnValue
  @GwtIncompatible // SerializableTester
  static <E> Set<E> reserializeAndAssertLenient(Set<E> original) {

 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public class MinimalCollection<E extends @Nullable Object> extends AbstractCollection<E> {
  // TODO: expose allow nulls parameter?

  public static <E extends @Nullable Object> MinimalCollection<E> of(E... contents) {
    return new MinimalCollection<>(Object.class, true, contents);
  }

  // TODO: use this

        @Override
        public @Nullable Object apply(Optional<?> optional) {
          return optional.orNull();
        }
      };

  /**
   * Sets.cartesianProduct doesn't allow sets that contain null, but we want null to mean "don't
   * call the associated CacheBuilder method" - that is, get the default CacheBuilder behavior. This

      fail("no exception thrown");
    } catch (IllegalArgumentException e) {
      assertThat(e).hasMessageThat().isEqualTo("A null C");
    }
  }

  @J2ktIncompatible // TODO(b/319404022): Allow passing null array as varargs
  public void testCheckArgument_singleNullArray_failure() {
    try {
      Preconditions.checkArgument(false, "A %s C", (Object[]) null);
      fail("no exception thrown");