// '/foo/bar' for a URL like 'http://example.com/foo/bar/baz'. It always starts with '/'.
      if (path == null || !path.startsWith("/")) {
        val encodedPath = url.encodedPath
        val lastSlash = encodedPath.lastIndexOf('/')
        path = if (lastSlash != 0) encodedPath.substring(0, lastSlash) else "/"
      }

      return Cookie(
        cookieName, cookieValue, expiresAt, domain, path, secureOnly, httpOnly,

   tlsVersion
 * **HandshakeCertificates**: keyManager, trustManager
 * **Headers**: size
 * **HeldCertificate**: certificate, keyPair
 * **HttpLoggingInterceptor**: level
 * **HttpUrl**: encodedFragment, encodedPassword, encodedPath, encodedPathSegments, encodedQuery,
   encodedUsername, fragment, host, password, pathSegments, pathSize, port, query,
   queryParameterNames, querySize, scheme, username

func getCanonicalRequest(extractedSignedHeaders http.Header, payload, queryStr, urlPath, method string) string {
	rawQuery := strings.ReplaceAll(queryStr, "+", "%20")
	encodedPath := s3utils.EncodePath(urlPath)
	canonicalRequest := strings.Join([]string{
		method,
		encodedPath,
		rawQuery,
		getCanonicalHeaders(extractedSignedHeaders),
		getSignedHeaders(extractedSignedHeaders),
		payload,
	}, "\n")
	return canonicalRequest
}

    val password: String = httpUrl.password()
    val host: String = httpUrl.host()
    val port: Int = httpUrl.port()
    val pathSize: Int = httpUrl.pathSize()
    val encodedPath: String = httpUrl.encodedPath()
    val encodedPathSegments: List<String> = httpUrl.encodedPathSegments()
    val pathSegments: List<String> = httpUrl.pathSegments()
    val encodedQuery: String? = httpUrl.encodedQuery()

    client =
      client.newBuilder()
        .addInterceptor(
          Interceptor { chain: Interceptor.Chain ->
            if (chain.request().url.encodedPath == "/b") {
              val requestA =
                Request.Builder()
                  .url(server.url("/a"))
                  .build()
              val responseA = client.newCall(requestA).execute()

    val password: String = httpUrl.password
    val host: String = httpUrl.host
    val port: Int = httpUrl.port
    val pathSize: Int = httpUrl.pathSize
    val encodedPath: String = httpUrl.encodedPath
    val encodedPathSegments: List<String> = httpUrl.encodedPathSegments
    val pathSegments: List<String> = httpUrl.pathSegments
    val encodedQuery: String? = httpUrl.encodedQuery

    },

    PATH {
      override fun urlString(value: String): String = "http://example.com/a${value}z/"

      override fun encodedValue(url: HttpUrl): String {
        val path = url.encodedPath
        return path.substring(2, path.length - 2)
      }

      override operator fun set(
        builder: HttpUrl.Builder,
        value: String,
      ) {
        builder.addPathSegment("a${value}z")

    assertThat(requestUrl!!.scheme).isEqualTo("http")
    assertThat(requestUrl.host).isEqualTo(server.hostName)
    assertThat(requestUrl.port).isEqualTo(server.port)
    assertThat(requestUrl.encodedPath).isEqualTo("/a/deep/path")
    assertThat(requestUrl.queryParameter("key")).isEqualTo("foo bar")
  }

  @Test
  fun shutdownServerAfterRequest() {

    assertThat(requestUrl!!.scheme).isEqualTo("http")
    assertThat(requestUrl.host).isEqualTo(server.hostName)
    assertThat(requestUrl.port).isEqualTo(server.port)
    assertThat(requestUrl.encodedPath).isEqualTo("/a/deep/path")
    assertThat(requestUrl.queryParameter("key")).isEqualTo("foo bar")
  }

  @Test
  fun shutdownServerAfterRequest() {
    server.enqueue(
      MockResponse.Builder()