MsrpcLsarOpenPolicy2 rpc = invocation.getArgument(0);
            rpc.retval = 0; // Simulate success
            return null;
        }).when(mockDcerpcHandle).sendrecv(any(MsrpcLsarOpenPolicy2.class));

        // Act
        LsaPolicyHandle handle = new LsaPolicyHandle(mockDcerpcHandle, server, access);

        // Assert
        assertNotNull(handle);
        verify(mockDcerpcHandle, times(1)).sendrecv(any(MsrpcLsarOpenPolicy2.class));

        // Act
        transWaitNamedPipe = new TransWaitNamedPipe(mockConfig, null);

        // Assert
        assertNotNull(transWaitNamedPipe);
        assertNull(transWaitNamedPipe.name);
    }

    @Test
    @DisplayName("Constructor with empty pipe name should handle gracefully")
    void testConstructorWithEmptyPipeName() {
        // Act

    @Test
    @DisplayName("release(): verifies it is invoked exactly once")
    void release_invokedOnce() throws Exception {
        // Arrange: no setup needed; we verify interaction only

        // Act: call release
        handle.release();

        // Assert: verify one invocation and no more
        verify(handle, times(1)).release();
        verifyNoMoreInteractions(handle);
    }

    @Test

        int dstIndex = 50;

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

        // Assert
        assertEquals(0, result);
    }

    @Test
    @DisplayName("writeParametersWireFormat should return 0")
    void testWriteParametersWireFormat() {
        // Arrange
        byte[] dst = new byte[100];
        int dstIndex = 0;

        // Act

        }

        @Test
        @DisplayName("Should create context with constructor parameters")
        void testConstructorWithParameters() {
            // Act
            context = new PreauthIntegrityNegotiateContext(mockConfig, testHashAlgos, testSalt);

            // Assert
            assertEquals(PreauthIntegrityNegotiateContext.NEGO_CTX_PREAUTH_TYPE, context.getContextType());

        // Act
        long actual = getter.apply(e);
        // Assert
        assertEquals(value, actual, label);
    }

    @Test
    @DisplayName("Calling a method on null reference throws NPE")
    void nullReference_throwsNPE() {
        // Arrange
        FileEntry e = null;
        // Act & Assert: demonstrate invalid usage results in NPE

    }

    @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
        verify(signingDigest, times(1)).sign(testData, offset, length, request, response);
    }

    @Test

            rpcUuid.clock_seq_hi_and_reserved = CLOCK_SEQ_HI_AND_RESERVED;
            rpcUuid.clock_seq_low = CLOCK_SEQ_LOW;
            rpcUuid.node = NODE;

            // Act
            UUID uuid = new UUID(rpcUuid);

            // Assert
            assertEquals(TIME_LOW, uuid.time_low, "time_low should match");
            assertEquals(TIME_MID, uuid.time_mid, "time_mid should match");

        // Arrange: filter that accepts directories only
        SmbFileFilter filter = f -> f.isDirectory();
        when(smbFile.isDirectory()).thenReturn(true);

        // Act
        boolean result = filter.accept(smbFile);

        // Assert
        assertTrue(result, "Directory should be accepted");
        verify(smbFile, times(1)).isDirectory();
        verify(smbFile, never()).getName();

        // Known NT hash for "password" (UTF-16LE MD4)
        // This is a well-known test vector: password -> 8846F7EAEE8FB117AD06BDD830B7586C
        byte[] expected = hex("8846F7EAEE8FB117AD06BDD830B7586C");

        // Act
        byte[] actual = NtlmUtil.getNTHash(password);

        // Assert
        assertArrayEquals(expected, actual, "NT hash must match known test vector");
    }

    @Test