for (shift in (lengthByteCount - 1) * 8 downTo 0 step 8) {
      sink.writeByte((v shr shift).toInt())
    }
  }

  fun writeBitString(bitString: BitString) {
    val sink = sink()
    sink.writeByte(bitString.unusedBitsCount)
    sink.write(bitString.byteString)
  }

  fun writeOctetString(byteString: ByteString) {
    sink().write(byteString)
  }

  fun writeUtf8(value: String) {

                  AlgorithmIdentifier(
                    algorithm = RSA_ENCRYPTION,
                    parameters = null,
                  ),
                subjectPublicKey =
                  BitString(
                    byteString = publicKeyBytes,
                    unusedBitsCount = 0,
                  ),
              ),
            issuerUniqueID = null,
            subjectUniqueID = null,

                    throw new PACDecodingException("Invalid kerberos request");
                }
                break;
            case 2:
                DERBitString bitString = ASN1Util.as(DERBitString.class, tagged);
                this.apOptions = bitString.getBytes()[0];
                break;
            case 3:
                ASN1TaggedObject derTicket = ASN1Util.as(ASN1TaggedObject.class, tagged);

      .isEqualTo(bytes)
  }

  @Test fun `bit string`() {
    val bytes = "0304066e5dc0".decodeHex()
    val bitString = BitString("6e5dc0".decodeHex(), 6)

    assertThat(Adapters.BIT_STRING.fromDer(bytes)).isEqualTo(bitString)
    assertThat(Adapters.BIT_STRING.toDer(bitString)).isEqualTo(bytes)
  }

  @Test fun `cannot decode empty bit string`() {
    val bytes = "0300".decodeHex()

          subject = (it[5] as Pair<*, *>).second as List<List<AttributeTypeAndValue>>,
          subjectPublicKeyInfo = it[6] as SubjectPublicKeyInfo,
          issuerUniqueID = it[7] as BitString?,
          subjectUniqueID = it[8] as BitString?,
          extensions = it[9] as List<Extension>,
        )
      },
    )

  /**
   * ```
   * Certificate ::= SEQUENCE  {
   *   tbsCertificate       TBSCertificate,

    while (byteCount < limit) {
      result = result shl 8
      result += source.readByte().toInt() and 0xff
    }
    return result
  }

  fun readBitString(): BitString {
    if (bytesLeft == -1L || constructed) {
      throw ProtocolException("constructed bit strings not supported for DER")
    }
    if (bytesLeft < 1) {
      throw ProtocolException("malformed bit string")
    }

import okhttp3.internal.canParseAsIpAddress
import okhttp3.tls.internal.der.AlgorithmIdentifier
import okhttp3.tls.internal.der.AttributeTypeAndValue
import okhttp3.tls.internal.der.BasicConstraints
import okhttp3.tls.internal.der.BitString
import okhttp3.tls.internal.der.Certificate
import okhttp3.tls.internal.der.CertificateAdapters
import okhttp3.tls.internal.der.CertificateAdapters.generalNameDnsName

    @Test
    @DisplayName("Tag [3] MIC with non-OctetString is ignored (no crash)")
    void testMicTag3NonOctetIgnored() throws Exception {
        // Manually craft a token where field [3] is not an OctetString (e.g., BitString)
        ASN1EncodableVector fields = new ASN1EncodableVector();
        // Add a dummy [3] BIT STRING which should be ignored by implementation
        fields.add(new DERTaggedObject(true, 3, new DERBitString(0xA5)));