// TODO test jdk.tls.client.enableSessionTicketExtension
    // TODO check debugging information

    enableTls()

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

    val request = Request(server.url("/"))

    val response = client.newCall(request).execute()

    response.use {
      assertEquals(200, response.code)
      if (PlatformVersion.majorVersion > 11) {

    }
  }

  @Test
  fun writeBounds() {
    val operator =
      FileOperator(
        randomAccessFile!!.getChannel(),
      )
    val buffer = Buffer().writeUtf8("abc")
    assertFailsWith<IndexOutOfBoundsException> {
      operator.write(0, buffer, -1L)
    }
    assertFailsWith<IndexOutOfBoundsException> {
      operator.write(0, buffer, 4L)
    }
  }

//
//	LBRA rel
label4:
	BFPT	1(PC)
	BFPT	label4	// BFPT 87


	//
	// floating point operate
	//
	//	LFCONV freg ',' freg
	//	{
	//		outcode(int($1), &$2, 0, &$4);
	//	}
	ABSD	F1, F2

	//	LFADD freg ',' freg
	//	{
	//		outcode(int($1), &$2, 0, &$4);
	//	}
	ADDD	F1, F2

	//	LFADD freg ',' freg ',' freg
	//	{
	//		outcode(int($1), &$2, int($4.Reg), &$6);
	//	}

          } else if (socketMode == Channel) {
            socketFactory(ChannelSocketFactory())
          }
        }.build()

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

    @Suppress("HttpUrlsUsage")
    val url =
      if (socketMode is TlsInstance) {
        "https://$hostname:${server.port}/get"
      } else {
        "http://$hostname:${server.port}/get"
      }

    String msg = "Alphanumeric characters are always 'safe' and should not be explicitly specified";
    IllegalArgumentException expected =
        assertThrows(IllegalArgumentException.class, () -> new PercentEscaper("-+#abc.!", false));
    assertThat(expected).hasMessageThat().isEqualTo(msg);
  }

  public void testBadArguments_plusforspace() {
    // space can be a safe char if plusForSpace is false

func TestSignV4TrimAll(t *testing.T) {
	testCases := []struct {
		// Input.
		inputStr string
		// Expected result.
		result string
	}{
		{"本語", "本語"},
		{" abc ", "abc"},
		{" a b ", "a b"},
		{"a b ", "a b"},
		{"a  b", "a b"},
		{"a   b", "a b"},
		{"   a   b  c   ", "a b c"},
		{"a \t b  c   ", "a b c"},
		{"\"a \t b  c   ", "\"a b c"},

  private static final ImmutableSet<String> VALID_NAME =
      ImmutableSet.of(
          // keep-sorted start
          "123.cn",
          "8server.shop",
          "a" + DELTA + "b.com",
          "abc.a23",
          "biz.com.ua",
          "f--1.com",
          "f--o",
          "f-_-o.cOM",
          "f11-1.com",
          "fOo",
          "f_a",
          "foo.com",
          "foo.net.us\uFF61ocm",

    @DisplayName("readUTF(): decodes bytes after size prefix")
    void readUTF_decodes() throws Exception {
        SmbRandomAccessFile raf = spy(newInstance("r", false, false, false));
        // Size prefix 3, then bytes for "abc"
        doReturn(3).when(raf).readUnsignedShort();
        doAnswer(inv -> {
            byte[] b = inv.getArgument(0);
            int off = inv.getArgument(1);
            b[off] = 'a';

  }

  @SuppressWarnings("unchecked") // functor classes have no type parameters
  public void testGet_functors() {
    assertEquals(0, ArbitraryInstances.get(Comparator.class).compare("abc", 123));
    assertTrue(ArbitraryInstances.get(Predicate.class).apply("abc"));
    assertTrue(ArbitraryInstances.get(Equivalence.class).equivalent(1, 1));
    assertFalse(ArbitraryInstances.get(Equivalence.class).equivalent(1, 2));
  }

    assertEquals(2, CharStreams.readLines(r, conditional).intValue());
    assertEquals("ab", sb.toString());
  }

  public void testSkipFully_eof() throws IOException {
    Reader reader = new StringReader("abcde");
    assertThrows(EOFException.class, () -> CharStreams.skipFully(reader, 6));
  }

  public void testSkipFully() throws IOException {
    String testString = "abcdef";