ByteSource source = out.asByteSource();

    out.write(data);
    assertThat(source.read()).isEqualTo(data);

    out.close();
    assertThrows(IOException.class, () -> out.write(42));

    // Verify that write had no effect
    assertThat(source.read()).isEqualTo(data);
    out.reset();
  }

  public void testReset() throws Exception {
    byte[] data = newPreFilledByteArray(100);

    ImmutableSortedSet<String> set =
        ImmutableSortedSet.copyOf(new String[] {"e", "a", "e", "f", "b", "i", "d", "a", "c", "k"});
    assertThat(set.floor("f")).isEqualTo("f");
    assertThat(set.floor("j")).isEqualTo("i");
    assertThat(set.floor("q")).isEqualTo("k");
  }

  public void testFloor_elementAbsent() {
    ImmutableSortedSet<String> set =

    assertThat(decoded.version).isEqualTo(0L)
    assertThat(decoded.algorithmIdentifier).isEqualTo(AlgorithmIdentifier(RSA_ENCRYPTION, null))
    assertThat(decoded.privateKey.size).isEqualTo(607)

    val encoded = CertificateAdapters.privateKeyInfo.toDer(decoded)
    assertThat(encoded).isEqualTo(privateKeyInfoByteString)
  }

  @Test
  fun `RSA issuer and signature`() {

    Object value = new Object();
    Callable<Object> callable = Callables.returning(value);
    assertThat(callable.call()).isEqualTo(value);
    // Expect the same value on subsequent calls
    assertThat(callable.call()).isEqualTo(value);
  }

  @J2ktIncompatible
  @GwtIncompatible
  public void testAsAsyncCallable() throws Exception {
    String expected = "MyCallableString";

    Object value = new Object();
    Callable<Object> callable = Callables.returning(value);
    assertThat(callable.call()).isEqualTo(value);
    // Expect the same value on subsequent calls
    assertThat(callable.call()).isEqualTo(value);
  }

  @J2ktIncompatible
  @GwtIncompatible
  public void testAsAsyncCallable() throws Exception {
    String expected = "MyCallableString";

      }
    assertThat(url.scheme, "scheme").isEqualTo(testData.scheme)
    assertThat(effectiveHost, "host").isEqualTo(testData.host)
    assertThat(effectivePort, "port").isEqualTo(testData.port)
    assertThat(url.encodedPath, "path").isEqualTo(testData.path)
    assertThat(effectiveQuery, "query").isEqualTo(testData.query)
    assertThat(effectiveFragment, "fragment").isEqualTo(testData.fragment)
  }

  companion object {

    assertThat(iia.indexOf(1)).isEqualTo(0);
    assertThat(iia.indexOf(8)).isEqualTo(5);
    assertThat(iia.indexOf(4)).isEqualTo(-1);
    assertThat(ImmutableDoubleArray.of(13).indexOf(13)).isEqualTo(0);
    assertThat(ImmutableDoubleArray.of().indexOf(21)).isEqualTo(-1);
    assertThat(iia.subArray(1, 5).indexOf(1)).isEqualTo(0);
  }

  public void testIndexOf_specialValues() {

    assertThat(peekedBody.string()).isEqualTo("abc")
    assertThat(response.body.string()).isEqualTo("abcdef")
  }

  @Test fun peekLongerThanResponse() {
    val response = newResponse(responseBody("abc"))
    val peekedBody = response.peekBody(6)
    assertThat(peekedBody.string()).isEqualTo("abc")
    assertThat(response.body.string()).isEqualTo("abc")
  }

  @Test fun eachPeakIsIndependent() {

    val call = client.newCall(request)
    val response1 = call.execute()

    val cloned = call.clone()
    val response2 = cloned.execute()

    assertThat("abc").isEqualTo(response1.body.string())
    assertThat("def").isEqualTo(response2.body.string())
  }

  @Test
  @Flaky
  fun testMockWebserverRequest() {
    enableTls()

    server.enqueue(MockResponse(body = "abc"))

      assertThat(cache.getUnchecked(keyPrefix + i)).isEqualTo(i + shift1);
    }
    assertThat(CacheTesting.expirationQueueSize(cache)).isEqualTo(10);
    assertThat(removalListener.getCount()).isEqualTo(0);

    // wait, so that entries have just 10 ms to live
    ticker.advance(ttl * 2 / 3, MILLISECONDS);

    assertThat(CacheTesting.expirationQueueSize(cache)).isEqualTo(10);
    assertThat(removalListener.getCount()).isEqualTo(0);