}

        @Test
        @DisplayName("Should decode at different buffer offset")
        void testDecodeWithOffset() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[256];
            int offset = 100;
            byte[] responseData = createValidCopyChunkResponse(10, 131072, 1310720);
            System.arraycopy(responseData, 0, buffer, offset, responseData.length);

	return
}

// MarshalMsg implements msgp.Marshaler
func (z MetricName) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendString(o, string(z))
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *MetricName) UnmarshalMsg(bts []byte) (o []byte, err error) {
	{
		var zb0001 string
		zb0001, bts, err = msgp.ReadStringBytes(bts)
		if err != nil {

    /**
     * The create GUID used to uniquely identify this handle for reconnection
     */
    private final HandleGuid createGuid;

    /**
     * The 16-byte file ID returned by the server for this handle
     */
    private final byte[] fileId;

    /**
     * The type of handle (DURABLE_V1, DURABLE_V2, or PERSISTENT)
     */
    private final HandleType type;

    /**

| --------------------|-----------------------------|----------------------------------------
| xlMetaInlineDataVer | byte                        | version identifier
| id -> data          | msgp `map[string][]byte`      | Map of string id -> byte content

Currently only xlMetaInlineDataVer == 1 exists.

    }

    @Test
    void testReadInt4() {
        byte[] src = new byte[] { (byte) 0x78, (byte) 0x56, (byte) 0x34, (byte) 0x12, // 0x12345678
                (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, // 0xFFFFFFFF
                (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, // 0x00000000
                (byte) 0xEF, (byte) 0xCD, (byte) 0xAB, (byte) 0x89 // 0x89ABCDEF
        };

        assertEquals(0, emptyRead);
        assertEquals(0, fullRead);
    }

    /**
     * Create a test byte array with specified size and pattern
     */
    private byte[] createTestData(int size) {
        byte[] data = new byte[size];
        for (int i = 0; i < size; i++) {
            data[i] = (byte) (i % 256);
        }
        return data;
    }

  /** Converts a string, which should contain only ascii-representable characters, to a byte[]. */
  static byte[] ascii(String string) {
    byte[] bytes = new byte[string.length()];
    for (int i = 0; i < string.length(); i++) {
      bytes[i] = (byte) string.charAt(i);
    }
    return bytes;
  }

  interface HashFn {
    byte[] hash(byte[] input, int seed);
  }

        setField(cmd, "fid", 1);
        setField(cmd, "typeOfLock", (byte) type);
        setField(cmd, "newOpLockLevel", (byte) 0);
        setField(cmd, "timeout", 0L);
        setField(cmd, "locks", new LockingAndXRange[0]);
        setField(cmd, "unlocks", new LockingAndXRange[0]);
        setField(cmd, "largeFile", false);
        byte[] buf = new byte[12]; // Buffer needs to be at least 12 bytes for the parameter words

        // This is a simplified test and does not use real encrypted data from Kerberos
        // It mainly tests the decryption logic path
        Key key = new KerberosKey(null, new byte[16], KerberosConstants.RC4_ENC_TYPE, 0);
        byte[] data = new byte[32]; // Dummy data
        // The test will likely fail with "Checksum failed" as the data is not properly encrypted
        // but it proves the decryption path is taken.

        byte[] src = new byte[10];
        int srcIndex = 0;

        // Simulate groupName = false, nodeType = 0
        src[srcIndex] = (byte) 0x00;
        src[srcIndex + 1] = (byte) 0x00;

        // Simulate address = 0.0.0.0
        src[srcIndex + 2] = (byte) 0x00;
        src[srcIndex + 3] = (byte) 0x00;
        src[srcIndex + 4] = (byte) 0x00;
        src[srcIndex + 5] = (byte) 0x00;