// 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));
        when(handle.getFileId()).thenReturn(fileId);

    }

    @Test
    @DisplayName("getTree() acquires and returns same tree instance")
    void getTree_acquiresAndReturnsTree() {
        when(cfg.isTraceResourceUsage()).thenReturn(false);
        stubValidTree(7L, true, true);

        SmbFileHandleImpl h = new SmbFileHandleImpl(cfg, 123, tree, "//server/share", 0, 0, 0, 0, 0L);

        SmbTreeHandleImpl t1 = h.getTree();
        SmbTreeHandleImpl t2 = h.getTree();

        when(fileHandle.acquire()).thenReturn(fileHandle);
        when(fileHandle.isValid()).thenReturn(true);
        when(fileHandle.getTree()).thenReturn(tree);

        // Initially not open (isStale returns false when handle is null, not true)
        assertFalse(target.isOpen());
        assertFalse(target.isStale());

 *
 */
public interface SmbFileHandle extends AutoCloseable {

    /**
     * Returns the tree handle associated with this file handle
     *
     * @return the tree
     */
    SmbTreeHandle getTree();

    /**
     * Checks if this file handle is still valid
     *
     * @return whether the file descriptor is valid
     */
    boolean isValid();

    /**

        when(shared.acquire(false)).thenReturn(shared);

        setTree(c1, shared);
        setTree(c2, shared);
        assertTrue(c1.isSame(c2));

        SmbTreeImpl other = mock(SmbTreeImpl.class);
        when(other.acquire(false)).thenReturn(other);
        setTree(c2, other);
        assertFalse(c1.isSame(c2));
    }

    @Test

        when(fh.acquire()).thenReturn(fh);
        lenient().when(fh.isValid()).thenReturn(true);
        lenient().when(fh.getTree()).thenReturn(tree);
        when(fh.getFileId()).thenReturn(new byte[16]);

        // Setup for ioctl request
        when(tree.send(any(Smb2IoctlRequest.class), eq(RequestParam.NO_RETRY))).thenReturn(ioctlResp);

        when(file.openUnshared(anyInt(), anyInt(), anyInt(), anyInt(), anyInt())).thenReturn(fh);
        when(fh.acquire()).thenReturn(fh);
        when(fh.isValid()).thenReturn(true);
        when(fh.getTree()).thenReturn(tree);
        when(fh.getFileId()).thenReturn(new byte[16]);
        when(fh.getFid()).thenReturn(1);

        // build via package-private constructor to control unshared flag

            .sorted(comparing(ChangelogEntry.Breaking::getTitle))
            .collect(
                groupingBy(
                    ChangelogEntry.Breaking::isNotable,
                    groupingBy(ChangelogEntry.Breaking::getArea, TreeMap::new, Collectors.toList())
                )
            );

        final Map<String, List<ChangelogEntry.Deprecation>> deprecationsByArea = entries.stream()
            .map(ChangelogEntry::getDeprecation)

* Ensuite, il transmet la **requête** pour qu’elle soit traitée par le reste de l’application (par un *chemin d'accès*).
* Puis il récupère la **réponse** générée par l’application (par un *chemin d'accès*).
* Il peut faire quelque chose avec cette **réponse** ou exécuter tout code nécessaire.
* Enfin, il renvoie la **réponse**.

/// note | Détails techniques

    @Override
    public long getInitialSize() {
        return this.initialSize;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbFileHandle#getTree()
     */
    @Override
    public SmbTreeHandleImpl getTree() {
        return this.tree.acquire();
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbFileHandle#isValid()
     */
    @Override