try {
            return new SID(textual);
        } catch (SmbException e) {
            throw new RuntimeException(e);
        }
    }

    @Test
    @DisplayName("resolveSids(DcerpcHandle,...) populates acct, domain and type for known types")
    void resolveSids_populatesFields_happyPath() throws Exception {
        SIDCacheImpl cache = new SIDCacheImpl(mock(CIFSContext.class));
        DcerpcHandle handle = mock(DcerpcHandle.class);

        void testGetTypeAndText(int type, String text) {
            byte[] ident = new byte[] { 0, 0, 0, 0, 0, 5 };
            SID sid = new SID(buildSidT((byte) 1, ident, 42), type, "DOM", "acct", false);
            assertEquals(type, sid.getType());
            assertEquals(text, sid.getTypeText());
        }

        @Test

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

        // Act
        NetbiosAddress actualAddress = nameServiceClient.getLocalHost();

        // Assert
        assertNotNull(actualAddress);
        assertEquals(expectedAddress, actualAddress);

        SmbFileHandleImpl handle = mock(SmbFileHandleImpl.class);
        when(dest.openUnshared(anyInt(), anyInt(), anyInt(), anyInt(), anyInt())).thenReturn(handle);

        int attrs = SmbConstants.ATTR_NORMAL;

        // Act
        SmbFileHandleImpl result = SmbCopyUtil.openCopyTargetFile(dest, attrs, alsoRead);

        // Assert
        assertSame(handle, result, "Should return handle from dest.openUnshared");

        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

        boolean guest = flags[1];

        // Arrange
        Subject subject = new Subject();
        TestCredentials creds = new TestCredentials("DOMAIN", anonymous, guest, subject, false);

        // Act & Assert
        // unwrap to interface itself should return same instance
        CredentialsInternal unwrapped = creds.unwrap(CredentialsInternal.class);

        // Act & Assert
        assertEquals(0, nodeStatusRequest.readRDataWireFormat(src, 0));
        assertEquals(0, nodeStatusRequest.readRDataWireFormat(src, 50));
        assertEquals(0, nodeStatusRequest.readRDataWireFormat(src, 99));
    }

    @Test
    void toString_shouldReturnFormattedString() {
        // Arrange
        nodeStatusRequest = new NodeStatusRequest(mockConfig, mockName);

        // Act

        testSids = new jcifs.SID[] { mockSid };

        // Act & Assert - Constructor accepts null, no exception thrown
        assertDoesNotThrow(() -> {
            new MsrpcLookupSids(null, testSids);
        });
    }

    @Test
    void constructor_shouldThrowExceptionWithNullSids() {
        // Act & Assert - Null SID array causes NPE when accessing length

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

    @Test
    @DisplayName("Constructor should initialize with correct values")
    void testConstructor() {
        // Act
        transPeekNamedPipe = new TransPeekNamedPipe(mockConfig, TEST_PIPE_NAME, TEST_FID);

        // Assert
        assertNotNull(transPeekNamedPipe);
        assertEquals(TEST_PIPE_NAME, transPeekNamedPipe.name);

        // 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