// Byte xor is experimental in Kotlin so we coerce bytes to int, xor them
          // and convert back to byte.
          val bufferInt: Int = buffer[i].toInt()
          val keyInt: Int = key[keyIndex].toInt()
          buffer[i] = (bufferInt xor keyInt).toByte()

          i++
          keyIndex++
        }
      }
    } while (cursor.next() != -1)
  }

            'r'.code -> append('\r')
            's'.code -> append(' ')
            't'.code -> append('\t')
            'f'.code -> append('\u000c')
            'u'.code -> append(buffer.readUtf8(4).toInt(16).toChar())
            else -> throw IllegalArgumentException("unexpected escape character in $s")
          }
        }
      }
    }
  }

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

    val responseCode = flags and 0xf

    if (responseCode == NXDOMAIN) {
      throw UnknownHostException("$hostname: NXDOMAIN")
    } else if (responseCode == SERVFAIL) {
      throw UnknownHostException("$hostname: SERVFAIL")
    }

    val questionCount = buf.readShort().toInt() and 0xffff

  override fun hashCode(): Int {
    var result = 0
    result = 31 * result + tagClass
    result = 31 * result + tag.toInt()
    result = 31 * result + (if (constructed) 0 else 1)
    result = 31 * result + length.toInt()
    return result
  }

  override fun toString(): String = "$tagClass/$tag"

  companion object {
    const val TAG_CLASS_UNIVERSAL = 0b0000_0000

  @Suppress("ktlint:standard:max-line-length")
  val knownFailures =
    setOf(
      // OkHttp rejects empty labels.
      "x..xn--zca",
      "x..ß",
      // OkHttp rejects labels longer than 63 code points, the web platform tests don't.
      "x01234567890123456789012345678901234567890123456789012345678901x.xn--zca",
      "x01234567890123456789012345678901234567890123456789012345678901x.ß",

  private val uriStrippedCodePoints = StringBuilder()

  /**
   * Configure code points to be escaped for conversion to `java.net.URI`. That class is more
   * strict than the others.
   */
  fun escapeForUri(vararg codePoints: Int) =
    apply {
      uriEscapedCodePoints.append(String(*codePoints))
    }

  /**
   * Configure code points to be stripped in conversion to `java.net.URI`. That class is more

    reason: String,
  ) {
    printStatus("-")
  }

  private fun printStatus(s: String) {
    if (++testCount % 80 == 0) {
      printStatus("\n")
    }
    originalSystemErr?.print(s)
  }

  override fun executionFinished(
    testIdentifier: TestIdentifier,
    testExecutionResult: TestExecutionResult,
  ) {
    if (!testIdentifier.isContainer) {
      when (testExecutionResult.status!!) {

      } else {
        encodedCharBuffer.writeString(input, i, i + Character.charCount(codePoint), charset)
      }

      while (!encodedCharBuffer.exhausted()) {
        val b = encodedCharBuffer.readByte().toInt() and 0xff
        writeByte('%'.code)
        writeByte(HEX_DIGITS[b shr 4 and 0xf].code)
        writeByte(HEX_DIGITS[b and 0xf].code)
      }
    } else {

      val byte0 = tagClass or constructedBit or tag.toInt()
      sink.writeByte(byte0)
    } else {
      val byte0 = tagClass or constructedBit or 0b0001_1111
      sink.writeByte(byte0)
      writeVariableLengthLong(tag)
    }

    // Write the length. This takes 1 byte if length is less than 128.
    val length = content.size
    if (length < 128) {
      sink.writeByte(length.toInt())
    } else {

      b1 = b1 or B1_FLAG_MASK
    }
    when {
      dataSize <= PAYLOAD_BYTE_MAX -> {
        b1 = b1 or dataSize.toInt()
        sinkBuffer.writeByte(b1)
      }
      dataSize <= PAYLOAD_SHORT_MAX -> {
        b1 = b1 or PAYLOAD_SHORT
        sinkBuffer.writeByte(b1)
        sinkBuffer.writeShort(dataSize.toInt())
      }
      else -> {
        b1 = b1 or PAYLOAD_LONG
        sinkBuffer.writeByte(b1)