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

    }

    private synchronized SmbTreeImpl getTree() {
        final SmbTreeImpl t = this.tree;
        if (t != null) {
            return t.acquire(false);
        }
        if (this.delegate != null) {
            this.tree = this.delegate.getTree();
            return this.tree;
        }
        return t;
    }

    /**
     * @return
     */

    void setup() throws MalformedURLException, CIFSException {
        // Common happy-path defaults
        // Use lenient() to avoid strict stubbing issues with Mockito
        lenient().when(tree.acquire()).thenReturn(tree);
        lenient().when(tree.getConfig()).thenReturn(config);
        lenient().when(config.getListCount()).thenReturn(10);
        lenient().when(config.getListSize()).thenReturn(4096);

    /**
     * Gets the name of the share this tree is connected to
     * @return the share we are connected to
     */
    String getConnectedShare();

    /**
     * Checks if this tree handle refers to the same tree as another
     * @param th the tree handle to compare with
     * @return whether the handles refer to the same tree
     */
    boolean isSameTree(SmbTreeHandle th);

    /**

    SmbFileHandleImpl handle;

    @Mock
    SmbTreeHandleImpl tree;

    // Prepare SMB2 flow with a given response
    private void setupSmb2(NotifyResponse resp, byte[] fileId) throws Exception {
        when(handle.isValid()).thenReturn(true);
        when(handle.getTree()).thenReturn(tree);
        when(tree.isSMB2()).thenReturn(true);
        when(tree.getConfig()).thenReturn(mock(Configuration.class));

        this.options = options;
        this.tree = tree.acquire();
        this.tree_num = tree.getTreeId();

        if (cfg.isTraceResourceUsage()) {
            this.creationBacktrace = Thread.currentThread().getStackTrace();
        } else {
            this.creationBacktrace = null;
        }
    }

    /**
     * @param cfg
     * @param fid
     * @param tree
     * @param unc
     * @param options

    @Mock
    private SmbTreeHandleImpl tree;

    @Mock
    private SmbResource parent;

    @Mock
    private SmbResourceLocator locator;

    @Mock
    private Configuration config;

    @Mock
    private CIFSContext cifsContext;

    @BeforeEach
    void setup() {
        // Tree handle lifecycle and config
        lenient().when(tree.acquire()).thenReturn(tree);

            try {
                if (this.treeConnection != null) {
                    // Release the tree connection if possible
                    log.debug("Releasing tree connection during emergency cleanup");
                }
            } catch (Exception e) {
                log.debug("Error releasing tree connection during emergency cleanup", e);
            }

    /**
     * construct graph from a "dirty" tree
     */
    public MetadataGraph(MetadataTreeNode tree) throws MetadataResolutionException {
        this(tree, false, false);
    }
    // ------------------------------------------------------------------------
    /**
     * construct graph from a "dirty" tree
     *
     * @param tree "dirty" tree root

### Build tree state

"Build tree" is another name for the build definition.
The "build tree state" holds the state for the entire build definition for a single build execution within a session.

The build tree state is managed by the `BuildTreeState` class.