*/
  private fun assertWildcardRule(rule: String) {
    check(rule.startsWith(WILDCARD_CHAR)) {
      """Wildcard Assertion Failure: '$rule'
A wildcard rule was added with a wildcard that is not in leftmost position! We'll need to change the ${PublicSuffixDatabase::class.java.name} to handle this."""
    }
    check(rule.indexOf(WILDCARD_CHAR, 1) == -1) {
      """Wildcard Assertion Failure: '$rule'

      assertThat(expected.message)
        .isEqualTo("Unexpected char 0xe9 at 1 in header name: héader1")
    }
  }

  @Test fun builderRejectsUnicodeInHeaderValue() {
    assertFailsWith<IllegalArgumentException> {
      Headers.Builder().add("header1", "valué1")
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("Unexpected char 0xe9 at 4 in header1 value: valué1")
    }
  }

          a: String,
          b: String,
        ): Int {
          var i = 4
          val limit = minOf(a.length, b.length)
          while (i < limit) {
            val charA = a[i]
            val charB = b[i]
            if (charA != charB) return if (charA < charB) -1 else 1
            i++
          }
          val lengthA = a.length
          val lengthB = b.length

      verifyHostname(hostname, it)
    }
  }

  /**
   * This is like [toLowerCase] except that it does nothing if this contains any non-ASCII
   * characters. We want to avoid lower casing special chars like U+212A (Kelvin symbol) because
   * they can return ASCII characters that match real hostnames.
   */
  private fun String.asciiToLowercase(): String {
    return when {

      assertThat(expected.message).isEqualTo("Unexpected char 0x20 at 1 in header name: a b")
    }
  }

  @Test
  fun requestHeaderNameWithTabForbidden() {
    assertFailsWith<IllegalArgumentException> {
      Request.Builder().addHeader("a\tb", "c")
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Unexpected char 0x09 at 1 in header name: a\tb")
    }
  }

  @Test

    val c = name[i]
    require(c in '\u0021'..'\u007e') {
      "Unexpected char 0x${c.charCode()} at $i in header name: $name"
    }
  }
}

internal fun headersCheckValue(
  value: String,
  name: String,
) {
  for (i in value.indices) {
    val c = value[i]
    require(c == '\t' || c in '\u0020'..'\u007e') {
      "Unexpected char 0x${c.charCode()} at $i in $name value" +

  return endIndex
}

/**
 * Returns the index of the first character in this string that is [delimiter]. Returns [endIndex]
 * if there is no such character.
 */
fun String.delimiterOffset(
  delimiter: Char,
  startIndex: Int = 0,
  endIndex: Int = length,
): Int {
  for (i in startIndex until endIndex) {
    if (this[i] == delimiter) return i
  }
  return endIndex
}

/**

Logger implements Appendable { public final boolean quiet; public void Logger(boolean); public final void log(String); public final Appendable append(CharSequence); public final Appendable append(CharSequence, int, int); public final Appendable append(char); } org/gradle/wrapper/PathAssembler.class package org.gradle.wrapper; public final synchronized class PathAssembler { public void PathAssembler(java.io.File, java.io.File); } org/gradle/wrapper/SystemPropertiesHand.class package org.gradle.wrapper;...

  integrity sha512-NZBql38Pzd+rAu5SPXv+qmTWGQuFsRiemHCJCAPvkoDxWV19/xqL2YHF32fDJ9SDLdLqfax8+S0CO3ncDCp9Iw==

chalk@^4.1.0:
  version "4.1.2"
  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01"
  integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
  dependencies:

HSPLkotlin/sequences/SequencesKt___SequencesJvmKt;->asSequence(Ljava/util/Iterator;)Lkotlin/sequences/Sequence;
HSPLkotlin/text/CharsKt__CharKt;->checkRadix(I)I
HSPLkotlin/text/CharsKt__CharKt;->equals(CCZ)Z
HSPLkotlin/text/CharsKt__CharKt;->isWhitespace(C)Z
HSPLkotlin/text/Charsets;-><clinit>()V
HSPLkotlin/text/MatcherMatchResult$groupValues$1;-><init>(Lkotlin/text/MatcherMatchResult;)V