assertFalse(resultFuture.cancel(true));
    assertFalse(resultFuture.isCancelled());
    assertFalse(inputFuture.isCancelled());
    assertFalse(outputFuture.isCancelled());
    assertThat(resultFuture.get()).isEqualTo(RESULT_DATA);
  }

  public void testFutureGetThrowsRuntimeException() throws Exception {
    BadFuture badInput = new BadFuture(immediateFuture(20));
    ListenableFuture<String> chain = buildChainingFuture(badInput);

 */

@file:Suppress(
  "CANNOT_OVERRIDE_INVISIBLE_MEMBER",
  "INVISIBLE_MEMBER",
  "INVISIBLE_REFERENCE",
)

package okhttp3.internal.concurrent

import assertk.assertThat
import assertk.assertions.isEqualTo
import java.io.Closeable
import java.util.AbstractQueue
import java.util.concurrent.BlockingQueue
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
import java.util.logging.Logger

  public <T> void testToString() {
    assertThat(new TypeToken<String>() {}.toString()).isEqualTo(String.class.getName());
    assertThat(TypeToken.of(new TypeCapture<T>() {}.capture()).toString()).isEqualTo("T");
    assertThat(new Entry<String, Integer>() {}.keyType().toString()).isEqualTo("java.lang.String");
  }

  private static <K, V> TypeToken<Map<K, V>> mapOf(Class<K> keyType, Class<V> valueType) {

    runner.start();
    isInterruptibleRegistered.await();
    RuntimeException expected = assertThrows(RuntimeException.class, task::interruptTask);
    assertThat(expected)
        .hasMessageThat()
        .isEqualTo("I bet you didn't think Thread.interrupt could throw");
    /*
     * We need to wait for the runner to exit. It used to be that the runner would get stuck in the
     * busy loop when interrupt threw.
     *

    runner.start();
    isInterruptibleRegistered.await();
    RuntimeException expected = assertThrows(RuntimeException.class, task::interruptTask);
    assertThat(expected)
        .hasMessageThat()
        .isEqualTo("I bet you didn't think Thread.interrupt could throw");
    /*
     * We need to wait for the runner to exit. It used to be that the runner would get stuck in the
     * busy loop when interrupt threw.
     *

    assertEquals(emptySet(), multimap.keySet());
    assertEquals(0, multimap.size());
    assertTrue(multimap.values().isEmpty());
    assertThat(multimap.toString()).isEqualTo("{}");
  }

  public void testEmptyMultimapWrites() {
    Multimap<String, Integer> multimap = ImmutableListMultimap.of();
    UnmodifiableCollectionTests.assertMultimapIsUnmodifiable(multimap, "foo", 1);
  }

    assertEquals(LIST1, ImmutableList.copyOf(newDelegatingListWithEquals(LIST1)));
  }

  public void testToString() {
    List<String> proxy = newDelegatingList(LIST1);
    assertThat(proxy.toString()).isEqualTo(Proxy.getInvocationHandler(proxy).toString());
  }

  interface A {}

  interface B {}

  public void testEquals() {
    new EqualsTester()
        .addEqualityGroup(newDelegatingList(LIST1))

  }

  public void testConstantsEverySixteenthFactorial() {
    for (int i = 0, n = 0; n <= DoubleMath.MAX_FACTORIAL; i++, n += 16) {
      assertThat(DoubleMath.everySixteenthFactorial[i])
          .isEqualTo(BigIntegerMath.factorial(n).doubleValue());
    }
  }

  @GwtIncompatible // DoubleMath.roundToInt(double, RoundingMode)
  public void testRoundIntegralDoubleToInt() {
    for (double d : INTEGRAL_DOUBLE_CANDIDATES) {

    ImmutableBiMap<String, Integer> copy = SerializableTester.reserializeAndAssert(bimap);
    assertEquals(Integer.valueOf(1), copy.get("one"));
    assertThat(copy.inverse().get(1)).isEqualTo("one");
    assertThat(copy.inverse().inverse()).isSameInstanceAs(copy);
  }

  @J2ktIncompatible
  @GwtIncompatible // SerializableTester
  public void testInverseSerialization() {

    assertEquals(emptySet(), multimap.keySet());
    assertEquals(0, multimap.size());
    assertTrue(multimap.values().isEmpty());
    assertThat(multimap.toString()).isEqualTo("{}");
  }

  public void testEmptyMultimapWrites() {
    Multimap<String, Integer> multimap = ImmutableListMultimap.of();
    UnmodifiableCollectionTests.assertMultimapIsUnmodifiable(multimap, "foo", 1);
  }