}

  fun readOctetString(): ByteString {
    if (bytesLeft == -1L || constructed) {
      throw ProtocolException("constructed octet strings not supported for DER")
    }
    return source.readByteString(bytesLeft)
  }

  fun readUtf8String(): String {
    if (bytesLeft == -1L || constructed) {
      throw ProtocolException("constructed strings not supported for DER")
    }
    return source.readUtf8(bytesLeft)
  }

   * also relies on object identity of funnels.
   *
   * @param funnel the funnel of T's that the constructed {@code BloomFilter} will use
   * @param expectedInsertions the number of expected insertions to the constructed {@code
   *     BloomFilter}; must be positive
   * @return a {@code Collector} generating a {@code BloomFilter} of the received elements

  var tag: Long,
  /**
   * If the constructed bit is set it indicates that the value is composed of other values that have
   * their own headers.
   *
   * This value is encoded in bit 6 of the first byte of each value.
   *
   * ```
   * 0bxx0xxxxx Primitive
   * 0bxx1xxxxx Constructed
   * ```
   */
  var constructed: Boolean,

    try {
      block(content)
      constructedBit = if (constructed) 0b0010_0000 else 0
      constructed = true // The enclosing object is constructed.
    } finally {
      stack.removeAt(stack.size - 1)
      path.removeAt(path.size - 1)
    }

    val sink = sink()

    // Write the tagClass, tag, and constructed bit. This takes 1 byte if tag is less than 31.
    if (tag < 31) {

            ASN1TaggedObject constructed = (ASN1TaggedObject) is.readObject();
            if ( constructed == null || constructed.getTagClass() != BERTags.APPLICATION ||
                    !(constructed.getBaseObject() instanceof  ASN1Sequence) )
                throw new IOException("Malformed SPNEGO token " + constructed);

            ASN1Sequence vec = (ASN1Sequence) constructed.getBaseObject();

  }

  @Test fun `cannot decode constructed octet string`() {
    assertFailsWith<ProtocolException> {
      Adapters.OCTET_STRING.fromDer(
        "2410040668656c6c6f200406776f726c6421".decodeHex(),
      )
    }.also { expected ->
      assertThat(expected).hasMessage("constructed octet strings not supported for DER")
    }
  }

  @Test fun `cannot decode constructed bit string`() {

  var tagClass: Int,
  var tag: Long,
  var constructed: Boolean = false,
  var length: Long = -1L,
  val bytes: ByteString,
) {
  // Avoid Long.hashCode(long) which isn't available on Android 5.
  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()

   *
   * ```
   * [5] EXPLICIT UTF8String
   * ```
   *
   * @param forceConstructed non-null to set the constructed bit to the specified value, even if the
   *     writing process sets something else. This is used to encode SEQUENCES in values that are
   *     declared to have non-constructed values, like OCTET STRING values.
   */
  @Suppress("UNCHECKED_CAST") // read() produces a single element of the expected type.

  }

  /**
   * Returns, as an immutable list, the row keys provided when the table was constructed, including
   * those that are mapped to null values only.
   */
  public ImmutableList<R> rowKeyList() {
    return rowList;
  }

  /**
   * Returns, as an immutable list, the column keys provided when the table was constructed,
   * including those that are mapped to null values only.
   */

        reader.read("ANY") { header ->
          val bytes = reader.readUnknown()
          return AnyValue(
            tagClass = header.tagClass,
            tag = header.tag,
            constructed = header.constructed,
            length = header.length,
            bytes = bytes,
          )
        }
      }

      override fun toDer(
        writer: DerWriter,
        value: AnyValue,
      ) {