assertEquals(SmbComTransaction.SMB_COM_TRANSACTION, resp1.getCommand());

        // Test with NT_TRANSACT command
        TestSmbComTransactionResponse resp2 =
                new TestSmbComTransactionResponse(mockConfig, SmbComTransaction.SMB_COM_NT_TRANSACT, (byte) 0x02);
        assertEquals(SmbComTransaction.SMB_COM_NT_TRANSACT, resp2.getCommand());
    }

    @Test

        super(config, command, name);
        this.andx = andx;
        if (andx != null) {
            this.andxCommand = (byte) andx.getCommand();
        }
    }

    /**
     * Constructs an AndX message block with configuration and command
     * @param config the configuration
     * @param command the SMB command
     */

            Smb2EchoRequest request2 = new Smb2EchoRequest(mockConfig);

            // Both should have same properties
            assertEquals(request1.getCommand(), request2.getCommand());
            assertEquals(request1.size(), request2.size());

            // But be different objects
            assertNotSame(request1, request2);

            // Both should create valid responses

        }

        @Override
        public void setMid(long mid) {
            this.mid = mid;
        }

        @Override
        public int getCommand() {
            return command;
        }

        @Override
        public void setCommand(int command) {
            this.command = command;
        }

        @Override
        public void setUid(int uid) {
            // No-op for test

        assertNotNull(response);
        assertEquals(FileSystemInformation.SMB_INFO_ALLOCATION, response.getInformationLevel());
        assertEquals(ServerMessageBlock.SMB_COM_TRANSACTION2, response.getCommand());
        assertEquals(SmbComTransaction.TRANS2_QUERY_FS_INFORMATION, response.getSubCommand());
    }

    @ParameterizedTest

        String directoryName = "testDir";
        SmbComCreateDirectory smbCom = new SmbComCreateDirectory(mockConfig, directoryName);

        assertEquals(ServerMessageBlock.SMB_COM_CREATE_DIRECTORY, smbCom.getCommand());
        assertEquals(directoryName, smbCom.getPath());
    }

    @Test
    void testWriteParameterWordsWireFormat() {
        // This method is empty, so it should return 0

        response = new SmbComQueryInformationResponse(mockConfig, serverTimeZoneOffset);

        assertNotNull(response);
        assertEquals(ServerMessageBlock.SMB_COM_QUERY_INFORMATION, getCommand(response));
    }

    @Test
    void testConstructorWithNegativeTimezone() {
        // Test constructor with negative timezone offset
        long serverTimeZoneOffset = -7200000L; // -2 hours in milliseconds

    void testSignNormalRequest() {
        SMB1SigningDigest digest = new SMB1SigningDigest(testMacSigningKey, false, 10);
        byte[] data = new byte[100];

        when(mockRequest.getCommand()).thenReturn((int) ServerMessageBlock.SMB_COM_WRITE);

        digest.sign(data, 0, data.length, mockRequest, mockResponse);

        verify(mockRequest).setSignSeq(10);
        verify(mockResponse).setSignSeq(11);

        @Test
        @DisplayName("Should get and set command")
        void testCommandProperty() {
            assertEquals(0, testMessage.getCommand());
            testMessage.setCommand(ServerMessageBlock2.SMB2_CREATE);
            assertEquals(ServerMessageBlock2.SMB2_CREATE, testMessage.getCommand());
        }

        @Test
        @DisplayName("Should get and set tree ID")
        void testTreeIdProperty() {

        long asyncId = 67890L;

        // When
        Smb2CancelRequest request = new Smb2CancelRequest(mockConfig, mid, asyncId);

        // Then
        assertEquals(SMB2_CANCEL, request.getCommand());
        assertEquals(mid, request.getMid());
        assertEquals(asyncId, request.getAsyncId());
        assertTrue((request.getFlags() & SMB2_FLAGS_ASYNC_COMMAND) != 0, "Async flag should be set when asyncId is non-zero");