val multipart =
      """
      |--simple boundary
      |
      |abcd
      |--simple boundary
      |
      |efgh
      |--simple boundary--
      """.trimMargin()
        .replace("\n", "\r\n")
        .replace(Regex("(?m)abcd\r\n"), "abcd\n")

    val parts =
      MultipartReader(
        boundary = "simple boundary",

  }

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

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

    assertThat(response1.body.string()).isEqualTo("abcd")
    val response2 = get(server.url("/"))
    assertThat(response2.header("Alpha")).isEqualTo("α")
    assertThat(response2.header("β")).isEqualTo("Beta")
    assertThat(response2.header("Gamma")).isEqualTo("Γ")
    assertThat(response2.header("Δ")).isEqualTo("Delta")
    assertThat(response2.body.string()).isEqualTo("abcd")
  }

  @Test

  }

  @Test fun testParameter() {
    val mediaType = parse("multipart/mixed; boundary=\"abcd\"")
    assertEquals("abcd", mediaType.parameter("boundary"))
    assertEquals("abcd", mediaType.parameter("BOUNDARY"))
  }

  @Test fun testMultipleParameters() {
    val mediaType = parse("Message/Partial; number=2; total=3; id=\"oc=abc@example.com\"")
    assertEquals("2", mediaType.parameter("number"))

  }

  @Test
  fun hostnameLowercaseCharactersMappedDirectly() {
    assertThat(parse("http://abcd").host).isEqualTo("abcd")
    assertThat(parse("http://σ").host).isEqualTo("xn--4xa")
  }

  @Test
  fun hostnameUppercaseCharactersConvertedToLowercase() {
    assertThat(parse("http://ABCD").host).isEqualTo("abcd")
    assertThat(parse("http://Σ").host).isEqualTo("xn--4xa")
  }

  @Test

    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 addressC = byteArrayOf(192.toByte(), 168.toByte(), 0, 1)
    assertThat(canonicalizeInetAddress(addressC)).isEqualTo(addressC)

    val addressD = decodeIpv6("abcd:ef01:2345:6789:abcd:ef01:2345:6789")!!
    assertThat(canonicalizeInetAddress(addressD)).isEqualTo(addressD)

    val addressE = decodeIpv6("2001:db8::1:0:0:1")!!
    assertThat(canonicalizeInetAddress(addressE)).isEqualTo(addressE)

foo:////://///  s:foo p:////://///
c:/foo  s:c p:/foo
//foo/bar  s:http h:foo p:/bar
http://foo/path;a??e#f#g  s:http h:foo p:/path;a q:??e f:#f#g
http://foo/abcd?efgh?ijkl  s:http h:foo p:/abcd q:?efgh?ijkl
http://foo/abcd#foo?bar  s:http h:foo p:/abcd f:#foo?bar
[61:24:74]:98  s:http h:example.org p:/foo/[61:24:74]:98
http:[61:27]/:foo  s:http h:example.org p:/foo/[61:27]/:foo
http://[1::2]:3:4
http://2001::1
http://2001::1]

            },
          ),
        )
        .sslSocketFactory(sslSocketFactory, handshakeCertificates.trustManager)
        .build()

    server.enqueue(MockResponse(body = "abc1"))
    server.enqueue(MockResponse(body = "abc2"))

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

    client.newCall(request).execute().use { response ->
      assertEquals(200, response.code)
    }

    this.server = server
  }

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