}

    @Test
    @DisplayName("Should handle output buffer with offset")
    void testReadBytesWireFormatWithOutputOffset() throws Exception {
        // Given
        int offset = 100;
        byte[] largeOutputBuffer = new byte[1024];
        Smb2ReadResponse offsetResponse = new Smb2ReadResponse(mockConfig, largeOutputBuffer, offset);

        byte[] buffer = new byte[256];
        int bodyStart = 0;

  private final class SlicedByteSource extends ByteSource {

    final long offset;
    final long length;

    SlicedByteSource(long offset, long length) {
      checkArgument(offset >= 0, "offset (%s) may not be negative", offset);
      checkArgument(length >= 0, "length (%s) may not be negative", length);
      this.offset = offset;
      this.length = length;
    }

    @Override

        message[8] = 0x03;

        // LM Response (24 bytes at offset 64)
        message[12] = 24; // Length
        message[13] = 0;
        message[14] = 24; // Max Length
        message[15] = 0;
        message[16] = 64; // Offset
        message[17] = 0;
        message[18] = 0;
        message[19] = 0;

        // NT Response (24 bytes at offset 88)
        message[20] = 24; // Length
        message[21] = 0;

	if offset < 0 || length < 0 {
		return -1, errInvalidArgument
	}
	if offset+length > totalLength {
		return -1, errInvalidArgument
	}

	if length == 0 {
		return 0, nil
	}

	reader := newParallelReader(readers, e, offset, totalLength)
	if len(prefer) == len(readers) {

		body    = `[{"bio":"bada bing bada boom","id":1,"name":"Charles","falseVal":false}]`
	)

	decoder := NewDecoder(mkReader(body), 1)

	for mv = range decoder.Stream() {
		counter++
		t.Logf("depth=%d offset=%d len=%d (%v)", mv.Depth, mv.Offset, mv.Length, mv.Value)
	}

	if err := decoder.Err(); err != nil {
		t.Fatalf("decoder error: %s", err)
	}
}

func TestDecoderNested(t *testing.T) {
	var (
		counter int

        byte[] dst = new byte[200];

        int offset = 50;
        int length = name.writeWireFormat(dst, offset);

        // Check first byte at offset
        assertEquals(0x20, dst[offset]);

        // Check type encoding at correct offset
        assertEquals('C', dst[offset + 31]);
        assertEquals('A', dst[offset + 32]);

        assertTrue(length > 33);
    }

    @Test

	closed      bool
	compressors map[uint16]Compressor
	comment     string

	// testHookCloseSizeOffset if non-nil is called with the size
	// of offset of the central directory at Close.
	testHookCloseSizeOffset func(size, offset uint64)
}

type header struct {
	*FileHeader
	offset uint64
	raw    bool
}

// NewWriter returns a new [Writer] writing a zip file to w.
func NewWriter(w io.Writer) *Writer {

        SMBUtil.writeInt2(shareType, buffer, bufferIndex);
        bufferIndex += 2;

        // Write remark offset (4 bytes)
        int remarkOffset = shareNameSize + typeSize + offsetSize;
        SMBUtil.writeInt4(remarkOffset, buffer, bufferIndex);
        bufferIndex += 4;

        // Write remark at the calculated offset
        byte[] remarkBytes = remark.getBytes(StandardCharsets.US_ASCII);

    response = client.get(
        "/items/",
        params={
            "limit": 10,
            "offset": 5,
            "order_by": "updated_at",
            "tags": ["tag1", "tag2"],
        },
    )
    assert response.status_code == 200
    assert response.json() == {
        "limit": 10,
        "offset": 5,
        "order_by": "updated_at",
        "tags": ["tag1", "tag2"],
    }

        <match value="0x4" type="big32" offset="4"/>
        <match value="0x5" type="big32" offset="4"/>
        <match value="0x6" type="big32" offset="4"/>
        <match value="0x7" type="big32" offset="4"/>
        <match value="0x8" type="big32" offset="4"/>
        <match value="0x9" type="big32" offset="4"/>
        <match value="0xA" type="big32" offset="4"/>
        <match value="0xB" type="big32" offset="4"/>