@Mock
    private NameServiceClient nameServiceClient;

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

    @Test
    void testGetLocalHost() {
        // Arrange
        NetbiosAddress expectedAddress = mock(NetbiosAddress.class);
        when(nameServiceClient.getLocalHost()).thenReturn(expectedAddress);

        // Act

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

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

        // Assert
        assertEquals(0, result);
    }

    @Test
    @DisplayName("writeParametersWireFormat with offset should return 0")
    void testWriteParametersWireFormatWithOffset() {
        // Arrange

    @Mock
    SmbTreeHandleImpl tree;

    @Mock
    SmbNamedPipe pipe;

    @Mock
    SmbFileHandleImpl fileHandle;

    private SmbPipeOutputStream newStream() throws CIFSException {
        // Arrange common constructor collaborators to avoid touching network/state
        when(handle.getPipe()).thenReturn(pipe);
        when(tree.isSMB2()).thenReturn(true);
        when(tree.getSendBufferSize()).thenReturn(4096);

        configField.setAccessible(true);
        assertSame(mockConfig, configField.get(nodeStatusRequest));
    }

    @Test
    void writeBodyWireFormat_shouldTemporarilySetHexCodeToZero() {
        // Arrange
        nodeStatusRequest = new NodeStatusRequest(mockConfig, mockName);
        byte[] dst = new byte[100];
        int originalHexCode = 0x20;
        mockName.hexCode = originalHexCode;

    @BeforeEach
    void setUp() {
        // Setup is minimal - mocks are configured per test as needed
    }

    @Test
    void constructor_shouldInitializeWithValidParameters() {
        // Arrange
        jcifs.SID mockSid1 = mock(jcifs.SID.class);
        jcifs.SID mockSid2 = mock(jcifs.SID.class);
        when(mockSid1.unwrap(sid_t.class)).thenReturn(mockSidT);

        assertEquals("\\PIPE\\", trans.name);
    }

    @Test
    @DisplayName("Test writeSetupWireFormat writes correct data")
    void testWriteSetupWireFormat() {
        // Arrange
        TransTransactNamedPipe trans = new TransTransactNamedPipe(mockConfig, TEST_FID, TEST_DATA, TEST_OFFSET, TEST_LENGTH);
        byte[] dst = new byte[10];
        int dstIndex = 0;

        // Act

        // FID is written in writeSetupWireFormat, verify it there
    }

    @Test
    @DisplayName("writeSetupWireFormat should write correct bytes")
    void testWriteSetupWireFormat() {
        // Arrange
        transPeekNamedPipe = new TransPeekNamedPipe(mockConfig, TEST_PIPE_NAME, TEST_FID);
        byte[] buffer = new byte[10];
        int offset = 2;

        // Act

    void constructor_shouldSetHandleCorrectly() {
        // Arrange
        short level = 1;

        // Act
        queryPolicy = new MsrpcQueryInformationPolicy(mockPolicyHandle, level, mockNdrObject);

        // Assert
        assertSame(mockPolicyHandle, queryPolicy.handle);
    }

    @Test
    void constructor_shouldSetLevelCorrectly() {
        // Arrange
        short level = 7;

        // Act

            // Arrange
            SamrPolicyHandle ph = createMockPolicyHandle();

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

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

        verify(tree).connectLogon(null);
    }

    @Test
    @DisplayName("connectLogon propagates SmbException from implementation")
    void connectLogon_throws_propagates() throws Exception {
        // Arrange
        doThrow(new SmbException("login failed")).when(tree).connectLogon(context);

        // Act + Assert
        SmbException ex = assertThrows(SmbException.class, () -> tree.connectLogon(context));