assertThat(url.resolve("#s")).isEqualTo(parse("http://a/b/c/d;p?q#s"))
    assertThat(url.resolve("g#s")).isEqualTo(parse("http://a/b/c/g#s"))
    assertThat(url.resolve("g?y#s")).isEqualTo(parse("http://a/b/c/g?y#s"))
    assertThat(url.resolve(";x")).isEqualTo(parse("http://a/b/c/;x"))
    assertThat(url.resolve("g;x")).isEqualTo(parse("http://a/b/c/g;x"))
    assertThat(url.resolve("g;x?y#s")).isEqualTo(parse("http://a/b/c/g;x?y#s"))

                    String v4,
                    String v5) -> {
                  assertThat(v1).isEqualTo(closeable1);
                  assertThat(v2).isEqualTo("value2");
                  assertThat(v3).isEqualTo("value3");
                  assertThat(v4).isEqualTo("value4");
                  assertThat(v5).isEqualTo("value5");
                  assertStillOpen(closeable1);

    assertThat(synStream.outFinished).isFalse()
    val data = peer.takeFrame()
    assertThat(data.type).isEqualTo(Http2.TYPE_DATA)
    assertArrayEquals("square".toByteArray(), data.data)
    val fin = peer.takeFrame()
    assertThat(fin.type).isEqualTo(Http2.TYPE_DATA)
    assertThat(fin.inFinished).isTrue()
    assertThat(fin.outFinished).isFalse()
    val rstStream = peer.takeFrame()

    assertThat(stats.loadSuccessCount()).isEqualTo(3);
    assertThat(stats.loadExceptionCount()).isEqualTo(0);
    assertThat(stats.hitCount()).isEqualTo(0);

    assertThat(cache.get(key)).isSameInstanceAs(key);
    stats = cache.stats();
    assertThat(stats.missCount()).isEqualTo(2);
    assertThat(stats.loadSuccessCount()).isEqualTo(3);
    assertThat(stats.loadExceptionCount()).isEqualTo(0);

    assertThat(call2Get.method).isEqualTo("GET")
    assertThat(call2Get.url.encodedPath).isEqualTo("/call2")
    assertThat(call2Get.exchangeIndex).isEqualTo(0)
    val call1Get = server.takeRequest()
    assertThat(call1Get.method).isEqualTo("GET")
    assertThat(call1Get.url.encodedPath).isEqualTo("/call1")
    assertThat(call1Get.exchangeIndex).isEqualTo(1)

    abcd.callStart(FailingCall())

    assertThat(a.takeEvent()).isInstanceOf<CallStart>()
    assertThat(a.eventSequence).isEmpty()
    assertThat(b.takeEvent()).isInstanceOf<CallStart>()
    assertThat(b.eventSequence).isEmpty()
    assertThat(c.takeEvent()).isInstanceOf<CallStart>()
    assertThat(c.eventSequence).isEmpty()
    assertThat(d.takeEvent()).isInstanceOf<CallStart>()

    Entry<String, String> entry = iter.next();
    assertThat(entry.getKey()).isEqualTo("Hello");
    assertThat(entry.getValue()).isEqualTo("World");
    assertTrue(iter.hasNext());

    entry = iter.next();
    assertThat(entry.getKey()).isEqualTo("first");
    assertThat(entry.getValue()).isEqualTo("second");
    assertTrue(iter.hasNext());

    entry = iter.next();
    assertThat(entry.getKey()).isEqualTo("polygene");

  private fun assertGarbageFilesAllDeleted() {
    assertThat(filesystem.exists(getCleanFile("g1", 0))).isFalse()
    assertThat(filesystem.exists(getCleanFile("g1", 1))).isFalse()
    assertThat(filesystem.exists(getCleanFile("g2", 0))).isFalse()
    assertThat(filesystem.exists(getCleanFile("g2", 1))).isFalse()
    assertThat(filesystem.exists(cacheDir / "otherFile0")).isFalse()
    assertThat(filesystem.exists(cacheDir / "dir1")).isFalse()
  }

    assertThat(consumingIterator.toString()).isEqualTo("Iterators.consumingIterator(...)");

    assertThat(list).containsExactly("a", "b").inOrder();

    assertTrue(consumingIterator.hasNext());
    assertThat(list).containsExactly("a", "b").inOrder();
    assertThat(consumingIterator.next()).isEqualTo("a");
    assertThat(list).contains("b");

    TypeToken<Object>.TypeSet types = new TypeToken<Object>() {}.getTypes();
    assertThat(types).contains(TypeToken.of(Object.class));
    assertThat(types.rawTypes()).contains(Object.class);
    assertThat(types.interfaces()).isEmpty();
    assertThat(types.interfaces().rawTypes()).isEmpty();
    assertThat(types.classes()).contains(TypeToken.of(Object.class));
    assertThat(types.classes().rawTypes()).contains(Object.class);
  }