Mapping(0x40100, 0x4017f, TYPE_DISALLOWED, ByteString.EMPTY),
      Mapping(0x40180, 0x40180, TYPE_DISALLOWED, ByteString.EMPTY),
    )
  }

  @Test fun withSectionStartAlreadySplit() {
    assertThat(
      withoutSectionSpans(
        listOf(
          Mapping(0x40000, 0x4007f, TYPE_DISALLOWED, ByteString.EMPTY),
          Mapping(0x40080, 0x400ff, TYPE_DISALLOWED, ByteString.EMPTY),
        ),
      ),

    @JvmField val RESPONSE_STATUS: ByteString = RESPONSE_STATUS_UTF8.encodeUtf8()

    @JvmField val TARGET_METHOD: ByteString = TARGET_METHOD_UTF8.encodeUtf8()

    @JvmField val TARGET_PATH: ByteString = TARGET_PATH_UTF8.encodeUtf8()

    @JvmField val TARGET_SCHEME: ByteString = TARGET_SCHEME_UTF8.encodeUtf8()

    @JvmField val TARGET_AUTHORITY: ByteString = TARGET_AUTHORITY_UTF8.encodeUtf8()
  }

    ByteString state = randomToken();
    synchronized (this) {
      listeners.put(state, listener);
    }

    return slackApi.authorizeUrl(scopes, redirectUrl(), state, team);
  }

  private ByteString randomToken() {
    byte[] bytes = new byte[16];
    secureRandom.nextBytes(bytes);
    return ByteString.of(bytes);
  }

  private HttpUrl redirectUrl() {

    withContext(Dispatchers.IO) {
      val sortedRules: SortedSet<ByteString> = TreeSet()
      val sortedExceptionRules: SortedSet<ByteString> = TreeSet()
      var totalRuleBytes = 0
      var totalExceptionRuleBytes = 0

      fileSystem.source(publicSuffixListDotDat).buffer().use { source ->
        while (!source.exhausted()) {
          var rule: ByteString = source.readUtf8LineStrict().toRule() ?: continue

  @Suppress("unused")
  private val MOSHI =
    Moshi.Builder()
      .add(
        object : Any() {
          @ToJson fun byteStringToJson(byteString: ByteString) = byteString.hex()

          @FromJson fun byteStringFromJson(json: String) = json.decodeHex()
        },
      )
      .add(KotlinJsonAdapterFactory())
      .build()
  private val STORY_JSON_ADAPTER = MOSHI.adapter(Story::class.java)

  }

  private fun MessageDeflater.deflate(byteString: ByteString): ByteString {
    val buffer = Buffer()
    buffer.write(byteString)
    deflate(buffer)
    return buffer.readByteString()
  }

  private fun MessageInflater.inflate(byteString: ByteString): ByteString {
    val buffer = Buffer()
    buffer.write(byteString)
    inflate(buffer)
    return buffer.readByteString()
  }

  /** Send a ping with the supplied [payload]. */
  @Throws(IOException::class)
  fun writePing(payload: ByteString) {
    writeControlFrame(OPCODE_CONTROL_PING, payload)
  }

  /** Send a pong with the supplied [payload]. */
  @Throws(IOException::class)
  fun writePong(payload: ByteString) {
    writeControlFrame(OPCODE_CONTROL_PONG, payload)
  }

  /**
   * Send a close frame with optional code and reason.

    assertThat(nextEvent()).isEqualTo(Message(string = payload))
  }

  fun assertBinaryMessage(payload: ByteString?) {
    assertThat(nextEvent()).isEqualTo(Message(payload))
  }

  fun assertPing(payload: ByteString) {
    assertThat(nextEvent()).isEqualTo(Ping(payload))
  }

  fun assertPong(payload: ByteString) {
    assertThat(nextEvent()).isEqualTo(Pong(payload))
  }

  fun assertClosing(
    code: Int,

 * limitations under the License.
 */
package okhttp3.tls.internal.der

import okio.ByteString

/**
 * Like a [ByteString], but whose bits are not necessarily a strict multiple of 8.
 */
internal data class BitString(
  val byteString: ByteString,
  /** 0-7 unused bits in the last byte. */
  val unusedBitsCount: Int,
) {

      writeShort(1) // CLASS_IN
    }.readByteString()

  @Throws(Exception::class)
  fun decodeAnswers(
    hostname: String,
    byteString: ByteString,
  ): List<InetAddress> {
    val result = mutableListOf<InetAddress>()

    val buf = Buffer()
    buf.write(byteString)
    buf.readShort() // query id

    val flags = buf.readShort().toInt() and 0xffff
    require(flags shr 15 != 0) { "not a response" }