@Test
    @DisplayName("Test decode method integration")
    void testDecodeMethodIntegration() throws Exception {
        byte[] buffer = new byte[1024];
        int bufferIndex = 0;

        // Prepare SMB2 header (64 bytes)
        // Protocol ID
        System.arraycopy(new byte[] { (byte) 0xFE, 'S', 'M', 'B' }, 0, buffer, bufferIndex, 4);
        // Header length
        SMBUtil.writeInt2(64, buffer, bufferIndex + 4);

/**
 * SMB1 COM_LOCKING_ANDX command implementation.
 *
 * This command locks or unlocks byte ranges within a file. It can also
 * be used to break oplocks and change oplock levels.
 *
 * @author mbechler
 */
public class SmbComLockingAndX extends AndXServerMessageBlock {

    private int fid;
    private byte typeOfLock;
    private byte newOpLockLevel;
    private long timeout;
    private LockingAndXRange[] locks;

     */
    public HandleGuid(UUID uuid) {
        this.guid = uuid;
    }

    /**
     * Convert the GUID to byte array for wire format (little-endian as per MS-SMB2)
     * @return 16-byte array representing the GUID in SMB wire format
     */
    public byte[] toBytes() {
        byte[] result = new byte[16];
        ByteBuffer bb = ByteBuffer.wrap(result).order(java.nio.ByteOrder.LITTLE_ENDIAN);

     * This tests the underlying SMBUtil.readInt8 behavior.
     */
    @Test
    public void testGetTimestampNegative() {
        long expectedTimestamp = -1L; // Represents all bits set to 1 for an 8-byte long
        byte[] rawBytes = new byte[8];
        SMBUtil.writeInt8(expectedTimestamp, rawBytes, 0);
        AvTimestamp avTimestamp = new AvTimestamp(rawBytes);

        assertEquals(expectedTimestamp, avTimestamp.getTimestamp());
    }

        void testReadParametersWireFormat() {
            byte[] buffer = new byte[10];
            int result = response.readParametersWireFormat(buffer, 0, 2);
            assertEquals(2, result);
        }

        @Test
        @DisplayName("Should write setup wire format")
        void testWriteSetupWireFormat() {
            byte[] buffer = new byte[100];
            int result = response.writeSetupWireFormat(buffer, 0);

        byte[] dst = new byte[42];

        // When
        int result = trans2SetFileInformation.writeDataWireFormat(dst, 0);

        // Then
        assertEquals(40, result); // Returns 40 bytes written
    }

    @Test
    void testReadSetupWireFormat() {
        // When
        int result = trans2SetFileInformation.readSetupWireFormat(new byte[0], 0, 0);

        // Then

	}
	return
}

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

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

    }

    // Test constructor with external hashes
    @Test
    void testConstructorWithExternalHashes() {
        byte[] challenge = new byte[8];
        byte[] ansiHash = new byte[24];
        byte[] unicodeHash = new byte[24];
        NtlmPasswordAuthentication auth = new NtlmPasswordAuthentication("DOMAIN", "user", challenge, ansiHash, unicodeHash);
        assertEquals("DOMAIN", auth.getDomain());

    checkNotNull(factory);
    return new ByteSourceFactory() {
      @Override
      public ByteSource createSource(byte[] bytes) throws IOException {
        return factory.createSource(bytes).slice(off, len);
      }

      @Override
      public byte[] getExpected(byte[] bytes) {
        byte[] baseExpected = factory.getExpected(bytes);
        int startOffset = (int) min(off, baseExpected.length);

                byte[] testData = new byte[] { 10, 20, 30, 40, 50 };
                System.arraycopy(testData, 0, response.b, response.off, testData.length);
                return null;
            }
        }).when(smbFile).send(any(SmbComReadAndX.class), any(SmbComReadAndXResponse.class));

        smbRandomAccessFile.readFully(buffer);
        assertArrayEquals(new byte[] { 10, 20, 30, 40, 50 }, buffer);