TypeToken<?> keyType =
        TypeToken.of(returnType).resolveType(WithFalseRecursiveType.class.getTypeParameters()[0]);
    assertThat(keyType.getType().toString()).isEqualTo("java.util.List<V>");
  }

  public void testFalseRecursiveType_notRealRecursiveMapping() {
    Type returnType = genericReturnType(WithFalseRecursiveType.class, "shouldNotCauseInfiniteLoop");
    TypeToken<?> keyType =

    TypeToken<?> keyType =
        TypeToken.of(returnType).resolveType(WithFalseRecursiveType.class.getTypeParameters()[0]);
    assertThat(keyType.getType().toString()).isEqualTo("java.util.List<V>");
  }

  public void testFalseRecursiveType_notRealRecursiveMapping() {
    Type returnType = genericReturnType(WithFalseRecursiveType.class, "shouldNotCauseInfiniteLoop");
    TypeToken<?> keyType =

    assertEquals(42, queue.maximumSize);
    assertThat(queue.comparator()).isEqualTo(SOME_COMPARATOR);
  }

  // TODO: tests that check the weird interplay between expected size,
  // maximum size, size of initial contents, default capacity...

  private static void checkNatural(MinMaxPriorityQueue<Integer> queue) {
    assertThat(queue.comparator()).isEqualTo(Ordering.natural());
  }

        .addEqualityGroup(testTable)
        .addEqualityGroup(ArrayTable.create(ImmutableSet.of('A'), ImmutableSet.of(1)))
        .testEquals();
  }

  public void testToString() {
    assertThat(testTable.toString()).isEqualTo("{a={1=blah}}");
  }

  public void testContains() {
    assertTrue(testTable.contains('a', 1));
    assertFalse(testTable.contains('a', 2));
    assertFalse(testTable.contains('A', 1));

    generator.addSampleInstances(String.class, ImmutableList.of("a", "b"));
    assertThat(generator.generateFresh(String.class)).isEqualTo("a");
    assertThat(generator.generateFresh(String.class)).isEqualTo("b");
    assertThat(generator.generateFresh(String.class)).isEqualTo("a");
  }

  public void testAddSampleInstances_oneInstance() {
    FreshValueGenerator generator = new FreshValueGenerator();

      assertThat(lastMethodCalled).isEqualTo(method);
      assertEquals(delay, lastDelay);
      assertEquals(unit, lastUnit);
    }

    void assertLastMethodCalled(String method, long initialDelay, long delay, TimeUnit unit) {
      assertThat(lastMethodCalled).isEqualTo(method);
      assertEquals(initialDelay, lastInitialDelay);
      assertEquals(delay, lastDelay);

            "chile", "peso",
            "switzerland", "franc");
    HashBiMap<String, String> bimap = HashBiMap.create(map);
    assertThat(bimap.get("canada")).isEqualTo("dollar");
    assertThat(bimap.inverse().get("dollar")).isEqualTo("canada");
  }

  private static final int N = 1000;

  public void testBashIt() throws Exception {
    BiMap<Integer, Integer> bimap = HashBiMap.create(N);

    // Ensure we get a unique execution exception on each get
    assertThat(ee1).isNotSameInstanceAs(ee2);

    assertThat(ee1).hasCauseThat().isEqualTo(failure);
    assertThat(ee2).hasCauseThat().isEqualTo(failure);

    checkStackTrace(ee1);
    checkStackTrace(ee2);
  }

  public void testCancel_notDoneNoInterrupt() throws Exception {

 */
package okhttp3

import assertk.assertThat
import assertk.assertions.containsExactly
import assertk.assertions.containsExactlyInAnyOrder
import assertk.assertions.isEmpty
import assertk.assertions.isEqualTo
import assertk.assertions.isFalse
import assertk.assertions.isNull
import assertk.assertions.isTrue
import java.util.concurrent.CopyOnWriteArraySet
import javax.net.ssl.SSLSocket
import javax.net.ssl.SSLSocketFactory

    // already finished (we explicitly set the result of it above).
    listenableFuture.addListener(singleCallListener, directExecutor());
    assertThat(listenableFuture.get()).isEqualTo(DATA1);

    // 'spy' should have been ignored since 'abstractFuture' was done before
    // a listener was added.
    assertFalse(spy.wasExecuted);
    assertTrue(singleCallListener.wasCalled());