assertEquals(state, result, "isOpen should reflect handle state");
        verify(handle, times(1)).isOpen();
    }

    @Test
    @DisplayName("ensureTreeConnected delegates and returns the tree handle")
    void ensureTreeConnected_delegatesAndReturns() throws Exception {
        // Arrange
        SmbPipeOutputStream out = newStream();
        when(handle.ensureTreeConnected()).thenReturn(tree);

        // Act

    }

    @Test
    @DisplayName("Should handle null delimiter by inserting 'null' string")
    void testJoinWithNullDelimiter() {
        String result = StringUtil.join(null, "first", "second", "third");
        assertEquals("firstnullsecondnullthird", result);
    }

    @Test
    @DisplayName("Should handle null elements in array")
    void testJoinWithNullElements() {

        when(tree.hasCapability(anyInt())).thenReturn(false);
        return new SmbPipeInputStream(handle, tree);
    }

    private SmbPipeInputStream newStreamWithMinimalStubs(boolean smb2) throws CIFSException {
        when(handle.getPipe()).thenReturn(pipe);
        when(tree.isSMB2()).thenReturn(smb2);
        return new SmbPipeInputStream(handle, tree);
    }

    @Test

import jcifs.smb1.dcerpc.rpc;
import jcifs.smb1.smb1.SmbException;

/**
 * LSA policy handle for Local Security Authority operations.
 */
public class LsaPolicyHandle extends rpc.policy_handle {

    DcerpcHandle handle;

    /**
     * Constructs an LSA policy handle.
     *
     * @param handle the DCERPC handle
     * @param server the server name
     * @param access the access rights

        assertNotNull(capturedRpc);
        assertEquals(mockPolicyHandle, capturedRpc.handle);
        assertEquals(access, capturedRpc.access_mask);
        assertEquals(mockSid, capturedRpc.sid);
        assertEquals(handle, capturedRpc.domain_handle); // Ensure the handle itself is passed for output
    }

    @Test
    void constructor_shouldThrowSmbExceptionOnRpcError() throws IOException {

        lenient().when(handle.getServerWithDfs()).thenCallRealMethod();
        lenient().when(handle.getSessionKey()).thenCallRealMethod();
        lenient().when(handle.getBinding()).thenReturn(mockDcerpcBinding);
        lenient().doCallRealMethod().when(handle).doSendReceiveFragment(any(byte[].class), anyInt(), anyInt(), any(byte[].class));

     * @param timeout the timeout in milliseconds
     * @param leaseKey the associated lease key (can be null)
     * @return the handle GUID
     */
    public HandleGuid requestDurableHandle(String path, HandleType type, long timeout, Smb2LeaseKey leaseKey) {
        HandleGuid guid = new HandleGuid();

        // Create handle info with empty file ID (will be populated after successful create response)

/**
 * MSRPC implementation for opening an alias handle.
 * This class provides functionality to open a handle to a SAM alias
 * (local group) using the SAMR RPC interface.
 */
public class MsrpcSamrOpenAlias extends samr.SamrOpenAlias {

    /**
     * Creates a new request to open an alias handle.
     *
     * @param handle the domain handle
     * @param access the desired access rights

    private final SmbFileHandleImpl handle;
    private final int filter;
    private final boolean recursive;

    /**
     * @param fh
     * @param filter
     * @param recursive
     *
     */
    public SmbWatchHandleImpl(final SmbFileHandleImpl fh, final int filter, final boolean recursive) {
        this.handle = fh;
        this.filter = filter;
        this.recursive = recursive;

            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));