public SmbNamedPipe getPipe() {
        return this.pipe;
    }

    @Override
    public SmbTreeHandleImpl ensureTreeConnected() throws CIFSException {
        if (this.treeHandle == null) {
            // extra acquire to keep the tree alive
            this.treeHandle = this.pipe.ensureTreeConnected();
        }
        return this.treeHandle.acquire();
    }

    public String getUncPath() {

     */
    @Override
    public boolean isOpen() {
        return this.handle.isOpen();
    }

    @Override
    protected synchronized SmbTreeHandleImpl ensureTreeConnected() throws CIFSException {
        return this.handle.ensureTreeConnected();
    }

    @Override
    protected synchronized SmbFileHandleImpl ensureOpen() throws CIFSException {
        return this.handle.ensureOpen();
    }

    /**

    }

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

        // Act
        SmbTreeHandleImpl result = out.ensureTreeConnected();

        // Assert

        try (SmbTreeHandleImpl t1 = target.ensureTreeConnected(); SmbTreeHandleImpl t2 = target.ensureTreeConnected()) {
            assertSame(tree, t1);
            assertSame(tree, t2);
        }

        // Assert: pipe.ensureTreeConnected invoked once, acquire twice
        verify(pipe, times(1)).ensureTreeConnected();
        verify(tree, times(2)).acquire();
    }

    @Test

        SmbTreeHandleInternal t2 = handle.ensureTreeConnected();

        // Assert
        assertSame(tree, t1, "First acquire returns provided tree");
        assertSame(tree, t2, "Subsequent acquire returns same tree instance");
        verify(pipe, times(1)).ensureTreeConnected();
        verify(tree, times(2)).acquire();
    }

    @Test

    }

    @Test
    @DisplayName("ensureTreeConnected delegates to handle")
    void ensureTreeConnected_delegates() throws Exception {
        // Verify ensureTreeConnected() delegates to SmbPipeHandleImpl
        SmbPipeInputStream stream = newStreamWithMinimalStubs(true);
        when(handle.ensureTreeConnected()).thenReturn(tree);

        SmbTreeHandleImpl result = stream.ensureTreeConnected();
        assertSame(tree, result);

        @Mock
        private SmbTreeHandleImpl mockTreeHandle;

        @BeforeEach
        void setUp() throws CIFSException {
            doReturn(mockTreeHandle).when(smbFile).ensureTreeConnected();
            when(mockTreeHandle.getConfig()).thenReturn(mockConfig);
        }

        @Test
        void testExists() throws SmbException, CIFSException {
            // Arrange

        if (!smbFile.isDirectory()) {
            throw new SmbException("Not a directory: " + smbFile.getPath());
        }

        try (SmbTreeHandleImpl th = smbFile.ensureTreeConnected()) {
            // Check if we can use directory leasing
            DirectoryLeaseManager dirManager = getDirectoryLeaseManager(th);

        try (SmbTreeHandle th = ensureTreeConnected()) {}
    }

    /**
     * Retrieves the tree handle for this SMB resource
     *
     * @return a tree handle
     * @throws CIFSException if the tree connection cannot be established
     */
    public SmbTreeHandle getTreeHandle() throws CIFSException {
        return ensureTreeConnected();
    }

    /**
     * {@inheritDoc}

     *
     * @return the tree handle implementation
     * @throws CIFSException if a connection error occurs
     */
    protected synchronized SmbTreeHandleImpl ensureTreeConnected() throws CIFSException {
        return this.handle.ensureTreeConnected();
    }

    @Override
    protected synchronized SmbFileHandleImpl ensureOpen() throws CIFSException {
        return this.handle.ensureOpen();
    }

    /**