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 byteArrayRange() {
    val contentType = "text/plain".toMediaType()
    val body: RequestBody = ".abcd".toByteArray().toRequestBody(contentType, 1, 3)
    assertThat(body.contentType()).isEqualTo(contentType)
    assertThat(body.contentLength()).isEqualTo(3)
    assertThat(bodyToHex(body)).isEqualTo("616263")
    assertThat(bodyToHex(body), "Retransmit body").isEqualTo("616263")

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

@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());
  }

        assertEquals(resultFile, file);
        FileUtil.writeBytes(file.getAbsolutePath(), "abc".getBytes());

        path = "foo1/hoge.html";
        file = fileTransformer.createFile(path);
        resultFile = new File(fileTransformer.baseDir, path);
        assertEquals(resultFile, file);
        FileUtil.writeBytes(file.getAbsolutePath(), "abc".getBytes());

        path = "foo1/foo2/hoge.html";

        DcerpcBinding.addInterface("srvsvc", "4B324FC8-1670-01D3-1278-5A47BF6EE188:3.0");
        DcerpcBinding.addInterface("lsarpc", "12345778-1234-ABCD-EF00-0123456789AB:2.1");
        DcerpcBinding.addInterface("samr", "12345778-1234-ABCD-EF00-0123456789AC:1.0");
        DcerpcBinding.addInterface("netlogon", "12345678-1234-abcd-ef00-01234567cffb:1.0");
        DcerpcBinding.addInterface("wkssvc", "6BFFD098-A112-3610-9833-46C3F87E345A:1.0");
    }

    @Test

        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
     */

        assertEquals("aaa bbb", normalizeText("aaa \u00a0 bbb", 100, -1, -1, false));
        assertEquals("123 abc", normalizeText(" 123 abc ", 100, -1, -1, false));
        assertEquals("１２３ あいう", normalizeText("　１２３　あいう　", 100, -1, -1, false));
        assertEquals("123 abc", normalizeText(" 123\nabc ", 100, -1, -1, false));
        assertEquals("1234567890 1234567890", normalizeText("1234567890 1234567890", 100, -1, -1, false));

        .build(),
    )
    val webSocket: WebSocket = newWebSocket()
    clientListener.assertOpen()
    val server = serverListener.assertOpen()
    webSocket.send("abc")
    serverListener.assertTextMessage("abc")
    server.send("def")
    clientListener.assertTextMessage("def")
    closeWebSockets(webSocket, server)
  }

  @Test
  @Throws(IOException::class)