// Encode test data at offset
        int offset = bufferIndex;
        SMBUtil.writeInt4(idFileSystem, buffer, offset);
        offset += 4;
        SMBUtil.writeInt4(sectPerAlloc, buffer, offset);
        offset += 4;
        SMBUtil.writeInt4((int) alloc, buffer, offset);
        offset += 4;
        SMBUtil.writeInt4((int) free, buffer, offset);
        offset += 4;

        byte[] dst = new byte[100];

        int bytesWritten = notifyChange.writeSetupWireFormat(dst, 10);

        // Verify structure:
        // Offset 0-3: Completion Filter (4 bytes)
        // Offset 4-5: FID (2 bytes)
        // Offset 6: Watch Tree (1 byte)
        // Offset 7: Reserved (1 byte)
        assertEquals(8, bytesWritten);

        // Check completion filter

            largeData[i] = (byte) i;
        }

        // Test with different offsets
        int[] offsets = { 0, 10, 50, 90 };

        for (int offset : offsets) {
            // Act
            signingDigest.sign(largeData, offset, 10, request, response);

            // Assert
            verify(signingDigest).sign(largeData, offset, 10, request, response);
        }

		buffer := make([]byte, len(tt.b)+numShifts)
		// vary the input alignment of tt.b
		for offset := 0; offset <= numShifts; offset++ {
			shiftedB := buffer[offset : len(tt.b)+offset]
			copy(shiftedB, tt.b)
			cmp := Compare(tt.a, shiftedB)
			if cmp != tt.i {
				t.Errorf(`Compare(%q, %q), offset %d = %v; want %v`, tt.a, tt.b, offset, cmp, tt.i)
			}
		}
	}
}

func TestCompareIdenticalSlice(t *testing.T) {

            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

                    int offset = threadIndex * 10;
                    smbComTreeDisconnect.writeParameterWordsWireFormat(buffer, offset);
                    smbComTreeDisconnect.writeBytesWireFormat(buffer, offset);
                    smbComTreeDisconnect.readParameterWordsWireFormat(buffer, offset);
                    smbComTreeDisconnect.readBytesWireFormat(buffer, offset);
                    smbComTreeDisconnect.toString();

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 {

        @DisplayName("Should handle buffer with offset correctly")
        void testReadWithBufferOffset() throws Exception {
            int offset = 10;
            byte[] buffer = new byte[64];
            byte[] fileId = createTestData(16);
            byte oplockLevel = 0x02;

            // Fill some random data before offset
            Arrays.fill(buffer, 0, offset, (byte) 0xAB);

            + "\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 {