encodedPathSegments.add("") // Always leave at least one '/'.
        }
      }

    fun encodedPath(encodedPath: String) =
      apply {
        require(encodedPath.startsWith("/")) { "unexpected encodedPath: $encodedPath" }
        resolvePath(encodedPath, 0, encodedPath.length)
      }

    fun query(query: String?) =
      apply {
        this.encodedQueryNamesAndValues =

    // next line
    assertThat(parse("http://h/\u0085").encodedPath).isEqualTo("/%C2%85")
    // non-breaking space
    assertThat(parse("http://h/\u00a0").encodedPath).isEqualTo("/%C2%A0")
    // ogham space mark
    assertThat(parse("http://h/\u1680").encodedPath).isEqualTo("/%E1%9A%80")
    // mongolian vowel separator
    assertThat(parse("http://h/\u180e").encodedPath).isEqualTo("/%E1%A0%8E")

          |
          |
          """.trimMargin(),
        ).setHeader("content-type", "text/event-stream")
        .build(),
    )
    val source = newEventSource()
    assertThat(source.request().url.encodedPath).isEqualTo("/")
    listener.assertOpen()
    listener.assertEvent(null, null, "hey")
    listener.assertClose()
  }

  @RetryingTest(5)
  fun cancelInEventShortCircuits() {
    server.enqueue(

  assertEquals("/v1/chat/messages/", request1.getUrl().encodedPath());
  assertNotNull(request1.getHeaders().get("Authorization"));

  RecordedRequest request2 = server.takeRequest();
  assertEquals("/v1/chat/messages/2", request2.getUrl().encodedPath());

  RecordedRequest request3 = server.takeRequest();
  assertEquals("/v1/chat/messages/3", request3.getUrl().encodedPath());

  // Shut down the server. Instances cannot be reused.

      // '/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,

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

    val latch = CountDownLatch(1)
    val dispatcher: Dispatcher =
      object : Dispatcher() {
        override fun dispatch(request: RecordedRequest): MockResponse {
          if (request.url.encodedPath == firstRequest) {
            latch.await()
          }
          return MockResponse()
        }
      }
    mockWebServer.dispatcher = dispatcher

      }
    assertThat(url.scheme, "scheme").isEqualTo(testData.scheme)
    assertThat(effectiveHost, "host").isEqualTo(testData.host)
    assertThat(effectivePort, "port").isEqualTo(testData.port)
    assertThat(url.encodedPath, "path").isEqualTo(testData.path)
    assertThat(effectiveQuery, "query").isEqualTo(testData.query)
    assertThat(effectiveFragment, "fragment").isEqualTo(testData.fragment)
  }

  companion object {

    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

   * Returns the path to request, like the '/' in 'GET / HTTP/1.1'. Never empty, even if the request
   * URL is. Includes the query component if it exists.
   */
  fun requestPath(url: HttpUrl): String {
    val path = url.encodedPath
    val query = url.encodedQuery
    return if (query != null) "$path?$query" else path
  }