val response = client.newCall(request).execute()
    assertThat(response.body.string()).isEqualTo("abc")
    assertThat(socksProxy.connectionCount()).isEqualTo(1)
  }

  @Test
  fun checkRemoteDNSResolve() {
    // This testcase will fail if the target is resolved locally instead of through the proxy.
    server.enqueue(MockResponse.Builder().body("abc").build())
    val client =
      clientTestRule
        .newClientBuilder()

          ),
        body = "ABC.1",
      ),
    )
    server.enqueue(
      MockResponse(
        headers =
          headersOf(
            "Last-Modified",
            formatDate(-1, TimeUnit.HOURS)!!,
            "Expires",
            formatDate(1, TimeUnit.HOURS)!!,
          ),
        body = "ABC.2",
      ),
    )
    client =
      client

      String.valueOf(Character.MIN_LOW_SURROGATE),
      Character.MIN_LOW_SURROGATE + "xyz",
      "abc" + Character.MIN_LOW_SURROGATE,
      "abc" + Character.MIN_LOW_SURROGATE + "xyz",
      String.valueOf(Character.MAX_LOW_SURROGATE),
      Character.MAX_LOW_SURROGATE + "xyz",
      "abc" + Character.MAX_LOW_SURROGATE,
      "abc" + Character.MAX_LOW_SURROGATE + "xyz",
    };
    for (String s : BAD_STRINGS) {

        assertEquals("", StringConversionUtil.fromWindowsMapping(""));
        assertEquals("abc 123", StringConversionUtil.fromWindowsMapping("abc 123"));
        assertEquals("abc\uFF5E\u2225\uFF0D\uFFE0\uFFE1\uFFE2",
                StringConversionUtil.fromWindowsMapping("abc\u301C\u2016\u2212\u00A2\u00A3\u00AC"));
    }

    /**
     * @throws Exception
     */

        "/form-json-list", data={"items": json.dumps(["abc", "def"])}
    )
    assert response.status_code == 200, response.text
    assert response.json() == ["abc", "def"]


def test_query_json_list():
    response = client.get(
        "/query-json-list", params={"items": json.dumps(["abc", "def"])}
    )
    assert response.status_code == 200, response.text
    assert response.json() == ["abc", "def"]


def test_header_json_list():

  }

  public void testEmptiesFirst() {
    Optional<String> empty = Optional.empty();
    Optional<String> abc = Optional.of("abc");
    Optional<String> z = Optional.of("z");

    Comparator<Optional<String>> comparator = emptiesFirst(comparing(String::length));
    testComparator(comparator, empty, z, abc);

    // Just demonstrate that no explicit type parameter is required

	cases := []string{
		`select * from s3object where Name like 'abcd'`,
		`select Name like 'abc' from s3object`,
		`select * from s3object where Name not like 'abc'`,
		`select * from s3object where Name like 'abc' escape 't'`,
		`select * from s3object where Name like 'a\%' escape '?'`,
		`select * from s3object where Name not like 'abc\' escape '?'`,
		`select * from s3object where Name like 'a\%' escape LOWER('?')`,

  }

  public void testEmptiesFirst() {
    Optional<String> empty = Optional.empty();
    Optional<String> abc = Optional.of("abc");
    Optional<String> z = Optional.of("z");

    Comparator<Optional<String>> comparator = emptiesFirst(comparing(String::length));
    testComparator(comparator, empty, z, abc);

    // Just demonstrate that no explicit type parameter is required

  @Test
  fun suspendCall() {
    runTest {
      server.enqueue(MockResponse(body = "abc"))

      val call = client.newCall(request)

      call.executeAsync().use {
        withContext(Dispatchers.IO) {
          assertThat(it.body.string()).isEqualTo("abc")
        }
      }
    }
  }

  @Test
  fun timeoutCall() {
    runTest {
      server.enqueue(

    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() {