* to be locked or unlocked, including the process ID, offset, and length.
 *
 * @author mbechler
 */
public class LockingAndXRange implements Encodable, Decodable {

    private final boolean largeFile;
    private int pid;
    private long byteOffset;
    private long lengthInBytes;

    /**
     * Constructs a LockingAndXRange with large file support.
     *
     * @param largeFile whether to use large file support (64-bit offsets)

        decodedSmb.decode(buffer, 0);

        assertEquals(smb.command, decodedSmb.command);
        assertEquals(smb.mid, decodedSmb.mid);
        assertEquals(smb.pid, decodedSmb.pid);
        assertEquals(smb.tid, decodedSmb.tid);
        assertEquals(smb.uid, decodedSmb.uid);
        assertEquals(smb.flags2, decodedSmb.flags2);
        assertEquals(smb.wordCount, decodedSmb.wordCount);

        lock.encode(new byte[20], 0); // initialise fields by encoding to set pid etc (though not needed)
        setField(lock, "pid", 123);
        setField(lock, "byteOffset", 100L);
        setField(lock, "lengthInBytes", 200L);
        LockingAndXRange unlock = new LockingAndXRange(false);
        setField(unlock, "pid", 456);
        setField(unlock, "byteOffset", 300L);
        setField(unlock, "lengthInBytes", 400L);

    SigningDigest digest = null;
    ServerMessageBlock response;

    ServerMessageBlock() {
        flags = (byte) (FLAGS_PATH_NAMES_CASELESS | FLAGS_PATH_NAMES_CANONICALIZED);
        pid = PID;
        batchLevel = 0;
    }

    void reset() {
        flags = (byte) (FLAGS_PATH_NAMES_CASELESS | FLAGS_PATH_NAMES_CANONICALIZED);
        flags2 = 0;
        errorCode = 0;
        received = false;

    }

    /**
     * Gets the process identifier
     * @return the pid
     */
    public final int getPid() {
        return this.pid;
    }

    /**
     * Sets the process identifier
     * @param pid
     *            the pid to set
     */
    public final void setPid(final int pid) {
        this.pid = pid;
    }

    /**
     * Gets the user identifier
     * @return the uid

| `minio_system_process_io_rchar_bytes`              | Total bytes read by the process from the underlying storage system including cache, /proc/[pid]/io rchar. <br><br>Type: counter       | `server` |
| `minio_system_process_io_read_bytes`               | Total bytes read by the process from the underlying storage system, /proc/[pid]/io read_bytes. <br><br>Type: counter                  | `server` |

| `minio_node_io_read_bytes`                 | Total bytes read by the process from the underlying storage system, /proc/[pid]/io read_bytes.                  |
| `minio_node_io_wchar_bytes`                | Total bytes written by the process to the underlying storage system including page cache, /proc/[pid]/io wchar. |

            andx.command = andxCommand;
            andx.errorCode = errorCode;
            andx.flags = flags;
            andx.flags2 = flags2;
            andx.tid = tid;
            andx.pid = pid;
            andx.uid = uid;
            andx.mid = mid;
            andx.useUnicode = useUnicode;

            if (andx instanceof AndXServerMessageBlock) {

            assertEquals(0xFFFF, testBlock.getTid());
            testBlock.setTid(0x1234);
            assertEquals(0x1234, testBlock.getTid());
        }

        @Test
        @DisplayName("Test PID property")
        void testPidProperty() {
            testBlock.setPid(0x5678);
            assertEquals(0x5678, testBlock.getPid());
        }

        @Test
        @DisplayName("Test UID property")

     * Test constructor with mock configuration
     */
    @Test
    @DisplayName("Test constructor with mock configuration")
    public void testConstructorWithMockConfig() {
        // Setup mock to return a valid PID
        when(mockConfig.getPid()).thenReturn(1234);

        // When
        smbComTreeDisconnect = new SmbComTreeDisconnect(mockConfig);

        // Then
        assertNotNull(smbComTreeDisconnect);