24, 26, 23, 26, 27, 26, 26, 27, 27, 27, 27, 27, 28, 27, 27, 27, 27, 27, 26,
    )

  private val root = Node()

  init {
    for (i in CODE_BIT_COUNTS.indices) {
      addCode(i, CODES[i], CODE_BIT_COUNTS[i].toInt())
    }
  }

  @Throws(IOException::class)
  fun encode(
    source: ByteString,
    sink: BufferedSink,
  ) {
    var accumulator = 0L

  /** Confirm that the thread does not hold a lock on `lock` during the callback. */
  fun forbidLock(lock: Any) {
    forbiddenLocks.add(lock)
  }

  /**
   * Removes recorded events up to (and including) an event is found whose class equals [eventClass]
   * and returns it.
   */
  fun <T : ConnectionEvent> removeUpToEvent(eventClass: Class<T>): T {
    val fullEventSequence = eventSequence.toList()
    try {
      while (true) {

        testCase.headersList,
        hpackReader.getAndResetHeaderList(),
      )
    }
  }

  companion object {
    /**
     * Reads all stories in the folders provided, asserts if no story found.
     */
    @JvmStatic
    protected fun createStories(interopTests: Array<String>): List<Any> {
      if (interopTests.isEmpty()) return listOf<Any>(Story.MISSING)

      val result = mutableListOf<Any>()

    } catch (FileNotFoundException e) {
      return new MockResponse()
          .setStatus("HTTP/1.1 404")
          .addHeader("content-type: text/plain; charset=utf-8")
          .setBody("NOT FOUND: " + path);
    } catch (IOException e) {
      return new MockResponse()
          .setStatus("HTTP/1.1 500")
          .addHeader("content-type: text/plain; charset=utf-8")
          .setBody("SERVER ERROR: " + e);
    }

    are currently being read or written. On Windows the file system forbids this so we must be more
    careful when deleting and renaming files.

 *  Fix: Don't crash on Java 8u252 which introduces an API previously found only on Java 9 and
    above. See [Jetty's overview][jetty_8_252] of the API change and its consequences.

 *  New: `MultipartReader` is a streaming decoder for [MIME multipart (RFC 2045)][rfc_2045]

  }

  fun assertFailure(vararg allowedExceptionTypes: Class<*>) =
    apply {
      var found = false
      for (expectedClass in allowedExceptionTypes) {
        if (expectedClass.isInstance(failure)) {
          found = true
          break
        }
      }
      assertThat(
        found,
        "Expected exception type among ${allowedExceptionTypes.contentToString()}, got $failure",
      ).isTrue()

        val b0b1 = sections.read14BitInt(entryIndex)
        return@binarySearch target.compareTo(b0b1)
      }

    return when {
      offset >= 0 -> offset * 4 // This section was found by binary search.
      else -> (-offset - 2) * 4 // Not found? Use the preceding element.
    }
  }

  /**
   * Binary search [ranges] for [codePoint], looking at its bottom 7 bits.
   *

          message.startsWith("Consuming ") -> Type.Handshake
          message.startsWith("Produced ") -> Type.Handshake
          message.startsWith("Negotiated ") -> Type.Handshake
          message.startsWith("Found resumable session") -> Type.Handshake
          message.startsWith("Resuming session") -> Type.Handshake
          message.startsWith("Using PSK to derive early secret") -> Type.Handshake
          else -> Type.Unknown
        }

            }
          }
        }

        if (compareResult < 0) {
          high = mid - 1
        } else if (compareResult > 0) {
          low = mid + end + 1
        } else {
          // We found a match, but are the lengths equal?
          val publicSuffixBytesLeft = publicSuffixLength - publicSuffixByteIndex
          var labelBytesLeft = labels[currentLabelIndex].size - currentLabelByteIndex

 */
internal fun String.commonToMediaType(): MediaType {
  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