writeLittleEndianInt(baos, 8); // minimal size
            writeLittleEndianLong(baos, 72); // offset (aligned)

            // Buffer 2: SERVER_CHECKSUM
            writeLittleEndianInt(baos, PacConstants.SERVER_CHECKSUM);
            writeLittleEndianInt(baos, 20); // signature size
            writeLittleEndianLong(baos, 80); // offset (aligned)

            // Buffer 3: PRIVSVR_CHECKSUM

    @Test
    @DisplayName("Test decode with offset")
    void testDecodeWithOffset() {
        // Prepare test data with offset
        testBuffer = new byte[150];
        int offset = 50;

        testBuffer[offset] = 0x00; // Allow ACE
        testBuffer[offset + 1] = 0x08; // FLAGS_INHERIT_ONLY
        testBuffer[offset + 2] = 0x20; // Size low byte
        testBuffer[offset + 3] = 0x00; // Size high byte

        buffer.putShort((short) 0x8004); // Control flags (SE_DACL_PRESENT | SE_SELF_RELATIVE)
        buffer.putInt(20); // Owner offset
        buffer.putInt(40); // Group offset
        buffer.putInt(0); // SACL offset (null)
        buffer.putInt(60); // DACL offset

        // Owner SID at offset 20
        buffer.position(20);
        buffer.put((byte) 0x01); // Revision
        buffer.put((byte) 0x01); // SubAuthorityCount

func (cr *s3UnsignedChunkedReader) Read(buf []byte) (n int, err error) {
	// First, if there is any unread data, copy it to the client
	// provided buffer.
	if cr.offset > 0 {
		n = copy(buf, cr.buffer[cr.offset:])
		if n == len(buf) {
			cr.offset += n
			return n, nil
		}
		cr.offset = 0
		buf = buf[n:]
	}
	// mustRead reads from input and compares against provided slice.
	mustRead := func(b ...byte) error {
		for _, want := range b {

        byte[] buffer = new byte[256];
        int offset = 10;

        // When
        int bytesWritten = request.writeBytesWireFormat(buffer, offset);

        // Then
        assertEquals(4, bytesWritten);

        // Verify structure size (4) is written at offset
        assertEquals(4, SMBUtil.readInt2(buffer, offset));

        // Verify reserved field (0) is written at offset + 2

    }

    @Override
    public byte[] compress(byte[] data, int offset, int length, int algorithm) throws CIFSException {
        if (data == null) {
            throw new CIFSException("Data cannot be null");
        }
        if (offset < 0 || length < 0 || offset + length > data.length) {
            throw new CIFSException("Invalid offset or length");
        }
        if (!isAlgorithmSupported(algorithm)) {

    @Override
    public void encode(byte[] buffer, int offset) {
        // Context header
        int nameLen = getName().length();
        writeInt4(buffer, offset, 16);  // Next
        writeInt2(buffer, offset + 4, nameLen);  // NameOffset
        writeInt2(buffer, offset + 6, nameLen);  // NameLength
        writeInt2(buffer, offset + 8, 0);  // Reserved
        writeInt2(buffer, offset + 10, STRUCTURE_SIZE);  // DataOffset

            + "\u19d0\u1b50\u1bb0\u1c40\u1c50\ua620\ua8d0\ua900\uaa50\uff10";
    for (char base : zeros.toCharArray()) {
      for (int offset = 0; offset < 10; offset++) {
        sb.append((char) (base + offset));
      }
    }
    ALL_DIGITS = sb.toString();
  }

  /** Sample CharMatcher instances for benchmarking. */
  public enum SampleMatcherConfig {

            SMBUtil.writeInt4(0, buffer, offset + 4); // sin6_flowinfo
            System.arraycopy(address.getAddress(), 0, buffer, offset + 8, 16); // sin6_addr
            SMBUtil.writeInt4(0, buffer, offset + 24); // sin6_scope_id
        } else {
            // IPv4 sockaddr_in structure (Windows AF_INET = 2)
            SMBUtil.writeInt2(2, buffer, offset); // sa_family: AF_INET

    }

    @Test
    @DisplayName("readParameterWordsWireFormat with offset beyond buffer - throws exception")
    void testReadParameterWordsWithOffsetBeyondBuffer() {
        byte[] buffer = new byte[] { 0x00, 0x01, 0x02, 0x03, 0x04 };
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> response.readParameterWordsWireFormat(buffer, 2) // Only 3 bytes available from offset 2
        );
    }

    @Test