)
  fun fragment(): String? = fragment

  class Builder {
    internal var scheme: String? = null
    internal var encodedUsername = ""
    internal var encodedPassword = ""
    internal var host: String? = null
    internal var port = -1
    internal val encodedPathSegments = mutableListOf<String>("")
    internal var encodedQueryNamesAndValues: MutableList<String?>? = null

message GroupResource {
  optional string group = 1;

  optional string resource = 2;
}

// GroupVersion contains the "group" and the "version", which uniquely identifies the API.
//
// +protobuf.options.(gogoproto.goproto_stringer)=false
message GroupVersion {
  optional string group = 1;

  optional string version = 2;
}

    val response2 = call2.execute()
    val call3 = client.newCall(Request(server.url("/")))
    val response3 = call3.execute()
    assertThat(response1.body.string()).isEqualTo("ABC")
    assertThat(response2.body.string()).isEqualTo("DEF")
    assertThat(response3.body.string()).isEqualTo("GHI")
    // Settings connection.
    assertThat(server.takeRequest().sequenceNumber).isEqualTo(0)
    // Reuse settings connection.

> port         (port)               MySQL server port (used only if `dsn_string` is empty)
> username     (string)             database username (used only if `dsn_string` is empty)
> password     (string)             database password (used only if `dsn_string` is empty)
> database     (string)             database name (used only if `dsn_string` is empty)
> ```
>

            chain!!.proceed(chain.request())
              .use { a -> assertThat(a.body.string()).isEqualTo("a") }
            chain.proceed(chain.request())
          },
        )
        .build()
    val call = client.newCall(Request.Builder().url(server.url("/")).build())
    val response = call.execute()
    assertThat(response.body.string()).isEqualTo("b")
    assertThat(listener.recordedEventTypes()).containsExactly(

      "2",
      "",
      *bodyLines,
    )
  }

  private fun createJournalWithHeader(
    magic: String,
    version: String,
    appVersion: String,
    valueCount: String,
    blank: String,
    vararg bodyLines: String,
  ) {
    filesystem.write(journalFile) {
      writeUtf8(
        """
        |$magic
        |$version
        |$appVersion
        |$valueCount

  dependencies:
    date-format "^4.0.14"
    debug "^4.3.4"
    fs-extra "^8.1.0"

string-width@^4.1.0, string-width@^4.2.0:
  version "4.2.3"
  resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010"
  integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==

	public static final fun basic (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
	public static final fun basic (Ljava/lang/String;Ljava/lang/String;Ljava/nio/charset/Charset;)Ljava/lang/String;
	public static synthetic fun basic$default (Ljava/lang/String;Ljava/lang/String;Ljava/nio/charset/Charset;ILjava/lang/Object;)Ljava/lang/String;
}

public final class okhttp3/Dispatcher {

    /**
     * Retrieves the corresponding [KtUserType] PSI the given [FirResolvedTypeRef].
     *
     * This code handles some quirks of FIR sources and PSI:
     * - in `vararg args: String` declaration, `String` type reference has fake source, but `Array<String>` has real source
     * (see [KtFakeSourceElementKind.ArrayTypeFromVarargParameter]).

@Suppress("HttpUrlsUsage") // Don't warn if we should be using https://.
open class HttpUrlTest {
  protected open fun parse(url: String): HttpUrl {
    return url.toHttpUrl()
  }

  protected open fun assertInvalid(
    string: String,
    exceptionMessage: String?,
  ) {
    try {
      val result = string.toHttpUrl()
      if (exceptionMessage != null) {
        fail("Expected failure with $exceptionMessage but got $result")