postBodyRetransmittedAfterAuthorizationFail("abc")
  }

  @Test
  fun postBodyRetransmittedAfterAuthorizationFail_HTTPS() {
    enableTls()
    postBodyRetransmittedAfterAuthorizationFail("abc")
  }

  @Test
  fun postBodyRetransmittedAfterAuthorizationFail_HTTP_2() {
    enableProtocol(Protocol.HTTP_2)
    postBodyRetransmittedAfterAuthorizationFail("abc")
  }

  }

  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

            return createCharSequence("search_");
        }

        /**
         * @return CharSequence
         */
        public static CharSequence abc_() {
            return createCharSequence("abc_");
        }

    }

}

func ExampleToValidUTF8() {
	fmt.Printf("%s\n", bytes.ToValidUTF8([]byte("abc"), []byte("\uFFFD")))
	fmt.Printf("%s\n", bytes.ToValidUTF8([]byte("a\xffb\xC0\xAFc\xff"), []byte("")))
	fmt.Printf("%s\n", bytes.ToValidUTF8([]byte("\xed\xa0\x80"), []byte("abc")))
	// Output:
	// abc
	// abc
	// abc
}

func ExampleTrim() {
	fmt.Printf("[%q]", bytes.Trim([]byte(" !!! Achtung! Achtung! !!! "), "! "))

        assertFalse(request.isHiraganaQuery("こ犬"));
        assertFalse(request.isHiraganaQuery("abc"));
        assertFalse(request.isHiraganaQuery("カキク"));
        assertFalse(request.isHiraganaQuery("あカ"));
        assertFalse(request.isHiraganaQuery("アか"));
        assertFalse(request.isHiraganaQuery("abcあ"));
    }

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

  @Test
  fun clientAuthForNeeds() {
    val client = buildClient(clientCert, clientIntermediateCa.certificate)
    val socketFactory = buildServerSslSocketFactory()
    server.useHttps(socketFactory)
    server.requireClientAuth()
    server.enqueue(
      MockResponse
        .Builder()
        .body("abc")
        .build(),
    )

  @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(

	a, b []byte
	i    int
}{
	{[]byte(""), []byte(""), 0},
	{[]byte("a"), []byte(""), 1},
	{[]byte(""), []byte("a"), -1},
	{[]byte("abc"), []byte("abc"), 0},
	{[]byte("abd"), []byte("abc"), 1},
	{[]byte("abc"), []byte("abd"), -1},
	{[]byte("ab"), []byte("abc"), -1},
	{[]byte("abc"), []byte("ab"), 1},
	{[]byte("x"), []byte("ab"), 1},
	{[]byte("ab"), []byte("x"), -1},
	{[]byte("x"), []byte("a"), 1},

@NullUnmarked
public class PackageSanityTests extends AbstractPackageSanityTests {
  public PackageSanityTests() {
    setDefault(BaseEncoding.class, BaseEncoding.base64());
    setDefault(int.class, 32);
    setDefault(String.class, "abcd");
    setDefault(Method.class, AbstractPackageSanityTests.class.getDeclaredMethods()[0]);
    setDefault(MapMode.class, MapMode.READ_ONLY);
    setDefault(CharsetEncoder.class, UTF_8.newEncoder());
  }

    /**
     * @throws Exception
     */
    @Test
    public void pend_testDot() throws Exception {
        final Tokenizer tokenizer = new Tokenizer("abc.hoge");
        assertThat(tokenizer.nextToken(), is(Tokenizer.TT_WORD));
        assertThat(tokenizer.getStringValue(), is("abc.hoge"));
        assertThat(tokenizer.nextToken(), is(Tokenizer.TT_EOF));
    }