.readUtf8()
}

/**
 * If this is an IP address, this returns the IP address in canonical form.
 *
 * Otherwise, this performs IDN ToASCII encoding and canonicalize the result to lowercase. For
 * example this converts `☃.net` to `xn--n3h.net`, and `WwW.GoOgLe.cOm` to `www.google.com`.
 * `null` will be returned if the host cannot be ToASCII encoded or if the result contains
 * unsupported ASCII characters.

    assertThat(call).contains("type=" + java.net.Authenticator.RequestorType.SERVER)
    assertThat(call).contains("prompt=Bar")
    assertThat(call).contains("protocol=http")
    assertThat(call.lowercase(Locale.US))
      .contains("scheme=basic") // lowercase for the RI.
  }

  @Test
  fun allAttributesSetInProxyAuthenticationCallbacks() {
    val calls = authCallsForHeader("Proxy-Authenticate: Basic realm=\"Bar\"")

  @get:JvmName("scheme") val scheme: String,
  authParams: Map<String?, String>,
) {
  /**
   * Returns the auth params, including [realm] and [charset] if present, but as
   * strings. The map's keys are lowercase and should be treated case-insensitively.
   */
  @get:JvmName("authParams")
  val authParams: Map<String?, String>

  /** Returns the protection space. */
  @get:JvmName("realm")
  val realm: String?

      }
      result.add(Header(TARGET_SCHEME, request.url.scheme))

      for (i in 0 until headers.size) {
        // header names must be lowercase.
        val name = headers.name(i).lowercase(Locale.US)
        if (name !in HTTP_2_SKIPPED_REQUEST_HEADERS ||
          name == TE && headers.value(i) == "trailers"
        ) {
          result.add(Header(name, headers.value(i)))

   * they can return ASCII characters that match real hostnames.
   */
  private fun String.asciiToLowercase(): String {
    return when {
      isAscii() -> lowercase(Locale.US) // This is an ASCII string.
      else -> this
    }
  }

  /** Returns true if the [String] is ASCII encoded (0-127). */
  private fun String.isAscii() = length == utf8Size().toInt()

  /**

  fun toMultimap(): Map<String, List<String>> {
    val result = TreeMap<String, MutableList<String>>(String.CASE_INSENSITIVE_ORDER)
    for (i in 0 until size) {
      val name = name(i).lowercase(Locale.US)
      var values: MutableList<String>? = result[name]
      if (values == null) {
        values = ArrayList(2)
        result[name] = values
      }
      values.add(value(i))
    }

data:text/html,test#test  s:data p:text/html,test f:#test

# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/file.html

# Basic canonicalization, uppercase should be converted to lowercase
file:c:\\foo\\bar.html file:///tmp/mock/path s:file p:/c:/foo/bar.html

# Spaces should fail
\s\sFile:c|////foo\\bar.html  s:file p:/c:////foo/bar.html

# This should fail
C|/foo/bar  s:file p:/C:/foo/bar

            dayOfMonth = matcher.group(1).toInt()
          }
          month == -1 && matcher.usePattern(MONTH_PATTERN).matches() -> {
            val monthString = matcher.group(1).lowercase(Locale.US)
            month = MONTH_PATTERN.pattern().indexOf(monthString) / 4 // Sneaky! jan=1, dec=12.
          }
          year == -1 && matcher.usePattern(YEAR_PATTERN).matches() -> {

  val typeSubtype: MatchResult =
    TYPE_SUBTYPE.matchAtPolyfill(this, 0)
      ?: throw IllegalArgumentException("No subtype found for: \"$this\"")
  val type = typeSubtype.groupValues[1].lowercase()
  val subtype = typeSubtype.groupValues[2].lowercase()

  val parameterNamesAndValues = mutableListOf<String>()
  var s = typeSubtype.range.last + 1
  while (s < length) {
    val parameter = PARAMETER.matchAtPolyfill(this, s)

      }

      override operator fun get(url: HttpUrl): String {
        val host = url.host
        return host.substring(1, host.length - 5).lowercase()
      }

      override fun canonicalize(s: String): String = s.lowercase()
    },

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

      override fun encodedValue(url: HttpUrl): String {