// Arrange
        byte[] dst = new byte[100];
        int dstIndex = 0;

        // Act
        int result = response.writeParametersWireFormat(dst, dstIndex);

        // Assert
        assertEquals(0, result);
    }

    @Test
    @DisplayName("writeDataWireFormat should return 0")
    void testWriteDataWireFormat() {
        // Arrange
        byte[] dst = new byte[100];

    @DisplayName("openCopyTargetFile sets correct access flags depending on alsoRead")
    void openCopyTargetFile_accessMask_respectsAlsoRead(boolean alsoRead) throws Exception {
        // Arrange
        SmbFile dest = mock(SmbFile.class);
        SmbFileHandleImpl handle = mock(SmbFileHandleImpl.class);
        when(dest.openUnshared(anyInt(), anyInt(), anyInt(), anyInt(), anyInt())).thenReturn(handle);

            // Arrange
            Smb2LogoffRequest req = newRequest();

            // Act/Assert
            assertThrows(NullPointerException.class, () -> req.createResponse(null, req));
        }

        @Test
        @DisplayName("createResponse tolerates null request parameter")
        void createResponse_nullRequest_ok() {
            // Arrange

        testData = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
    }

    @Test
    @DisplayName("Test sign method with valid parameters")
    void testSignWithValidParameters() {
        // Arrange
        int offset = 0;
        int length = testData.length;

        // Act
        signingDigest.sign(testData, offset, length, request, response);

        // Assert

            assertNull(context.getHashAlgos());
            assertNull(context.getSalt());
        }

        @Test
        @DisplayName("Should encode context correctly")
        void testEncode() {
            // Arrange
            context = new PreauthIntegrityNegotiateContext(mockConfig, testHashAlgos, testSalt);
            byte[] buffer = new byte[100];

            // Act
            int encodedSize = context.encode(buffer, 0);

    @BeforeEach
    void setUp() {
        // Setup is handled by MockitoExtension
    }

    @Test
    void constructor_shouldOpenPolicySuccessfully() throws IOException {
        // Arrange
        String server = "testServer";
        int access = 123;

        // Mock the behavior of sendrecv for MsrpcLsarOpenPolicy2
        doAnswer(invocation -> {

        return new Smb2LogoffResponse(cfg);
    }

    @Test
    @DisplayName("Constructor accepts a Configuration and creates instance")
    void constructor_happyPath() {
        // Arrange
        Configuration cfg = Mockito.mock(Configuration.class);

        // Act
        Smb2LogoffResponse resp = new Smb2LogoffResponse(cfg);

        // Assert

            // Arrange
            SamrPolicyHandle ph = createMockPolicyHandle();

            // Act & Assert
            assertDoesNotThrow(() -> new MsrpcSamrConnect2(null, 0, ph));
        }

        @Test
        @DisplayName("should accept negative access mask values")
        void testNegativeAccessMaskAccepted() {
            // Arrange

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    void constructor_shouldOpenAliasSuccessfully() throws IOException {
        // Arrange
        int access = 1;
        int rid = 100;

        // Mock the behavior of sendrecv for MsrpcSamrOpenAlias
        doAnswer(invocation -> {
            MsrpcSamrOpenAlias rpc = invocation.getArgument(0);

    class ConstructorTests {

        @Test
        @DisplayName("Constructor with rpc.uuid_t should copy all fields correctly")
        void testConstructorWithRpcUuidT() {
            // Arrange
            rpc.uuid_t rpcUuid = new rpc.uuid_t();
            rpcUuid.time_low = TIME_LOW;
            rpcUuid.time_mid = TIME_MID;
            rpcUuid.time_hi_and_version = TIME_HI_AND_VERSION;