// Skip 8 bytes for RootDirectory (8-15)
        SMBUtil.writeInt4(nameBytes.length, buffer, 16);
        System.arraycopy(nameBytes, 0, buffer, 20, nameBytes.length);

        FileRenameInformation2 info = new FileRenameInformation2();
        int bytesRead = info.decode(buffer, 0, buffer.length);

        assertEquals(20 + nameBytes.length, bytesRead);
    }

    @Test

            buffer[SmbConstants.SMB1_HEADER_LENGTH] = 0;
            SMBUtil.writeInt2(0, buffer, SmbConstants.SMB1_HEADER_LENGTH + 1);

            int length = testBlock.decode(buffer, 0);

            assertNotNull(testBlock.getRawPayload());
            assertEquals(length, testBlock.getRawPayload().length);
        }
    }

    @Nested

	return ct.AutoIncrementValue.Bool, ct.AutoIncrementValue.Valid
}

// Length returns the column type length for variable length column types
func (ct ColumnType) Length() (length int64, ok bool) {
	if ct.LengthValue.Valid {
		return ct.LengthValue.Int64, true
	}
	return ct.SQLColumnType.Length()
}

// DecimalSize returns the scale and precision of a decimal type.

        if (buf[0] != 5 || buf[1] != 0) {
            throw new IOException("Unexpected DCERPC PDU header");
        }

        final int length = Encdec.dec_uint16le(buf, 8);
        if (length > getMaxRecv()) {
            throw new IOException("Unexpected fragment length: " + length);
        }

        while (off < length) {
            final int r = this.handle.recv(buf, off, length - off);

        // Validate input parameters
        if (data == null) {
            log.error("Data buffer is null in verify");
            return false;
        }
        if (offset < 0 || length < 0) {
            log.error("Invalid offset or length in verify: offset={}, length={}", offset, length);
            return false;
        }

    this.elementSet = elementSet;
    this.cumulativeCounts = cumulativeCounts;
    this.offset = offset;
    this.length = length;
  }

  private int getCount(int index) {
    return (int) (cumulativeCounts[offset + index + 1] - cumulativeCounts[offset + index]);
  }

  @Override
  Entry<E> getEntry(int index) {
    return Multisets.immutableEntry(elementSet.asList().get(index), getCount(index));
  }

      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 {
      // count how many bytes we'll need to express the length.
      val lengthBitCount = 64 - java.lang.Long.numberOfLeadingZeros(length)
      val lengthByteCount = (lengthBitCount + 7) / 8

    @Override
    public Entry<K, V>[] createArray(int length) {
      return generator.createArray(length);
    }

    @Override
    public Iterable<Entry<K, V>> order(List<Entry<K, V>> insertionOrder) {
      return generator.order(insertionOrder);
    }

    @SuppressWarnings("unchecked")
    @Override
    public K[] createKeyArray(int length) {
      return (K[]) new Object[length];
    }

    @SuppressWarnings("unchecked")

        // Definite-length short form (length 10)
        InputStream s = new ByteArrayInputStream(new byte[] { 0x0A });
        int length = ASN1Util.readLength(s, 100, false);
        assertEquals(10, length);
    }

    @Test
    void testReadLength_LongForm() throws IOException {
        // Definite-length long form (length 256)

    // 0 - 63 bytes
    var length = source.readByte().toInt()

    if (length < 0) {
      // compressed name pointer, first two bits are 1
      // drop second byte of compression offset
      source.skip(1)
    } else {
      while (length > 0) {
        // skip each part of the domain name
        source.skip(length.toLong())
        length = source.readByte().toInt()
      }
    }
  }