// Verify interactions
        verify(tree, times(1)).send(isA(Trans2FindFirst2.class), any(Trans2FindFirst2Response.class));
        // Verify that Trans2FindNext2 was sent twice for fetching more entries
        verify(tree, times(2)).send(isA(Trans2FindNext2.class), any(Trans2FindFirst2Response.class));

        // Close should have sent FindClose2 exactly once

    
    private void redistributePendingOperations(ChannelInfo failedChannel) {
        // Get pending operations from failed channel
        List<SMBMessage> pendingOps = failedChannel.getPendingOperations();
        
        if (pendingOps.isEmpty()) {
            return;
        }
        
        log.info("Redistributing {} pending operations from failed channel", 
            pendingOps.size());
        

    }

    /**
     * Force cleanup of all resources
     *
     * @return number of resources cleaned
     */
    public int forceCleanup() {
        log.info("Forcing cleanup of all resources");

        int cleaned = 0;
        for (ResourceHolder holder : activeResources.values()) {
            if (!holder.closed) {
                AutoCloseable resource = holder.resourceRef.get();

    private int bufDataOffset;

    static final int TRANSACTION_BUF_SIZE = 0xFFFF;

    /**
     * SMB TRANS2 subcommand for finding first matching files
     */
    public static final byte TRANS2_FIND_FIRST2 = (byte) 0x01;
    /**
     * SMB TRANS2 subcommand for finding next matching files
     */
    public static final byte TRANS2_FIND_NEXT2 = (byte) 0x02;
    /**

   */
  private static final SuccessorsFunction<Character> TWO_CYCLES_GRAPH =
      createDirectedGraph("ab", "ac", "bc", "cd", "da");

  /**
   * A tree-shaped graph that looks as follows (all edges are directed facing downwards):
   *
   * {@snippet :
   *        h
   *       /|\
   *      / | \
   *     /  |  \
   *    d   e   g
   *   /|\      |
   *  / | \     |
   * a  b  c    f
   * }
   */

        if (useFilter) {
            verify(filter, times(1)).accept(any());
        }
    }

    @Test
    @DisplayName("close() clears pending element and hasNext() becomes false")
    void closeClearsNext() throws Exception {
        SmbFile parent = newParent();
        List<FileEntry> entries = Collections.singletonList(entry("one", SmbConstants.TYPE_SHARE));

        }

        // Mock number of links (4 bytes)
        buffer[16] = 0x01;
        buffer[17] = 0x00;
        buffer[18] = 0x00;
        buffer[19] = 0x00;

        // Mock delete pending and directory flags
        buffer[20] = 0x00;
        buffer[21] = 0x00;

        return buffer;
    }

    private byte[] createMockFileInternalInfoBuffer() {

     *
     * @return whether DFS lookup is disabled
     */
    boolean isDfsDisabled();

    /**
     * Enable hack to make kerberos auth work with DFS sending short names
     *
     * This works by appending the domain name to the netbios short name and will fail horribly if this mapping is not
     * correct for your domain.
     *

     * @param command the command to send to the process
     * @throws JobNotFoundException if no process is found for the given session ID
     * @throws JobProcessingException if there's an error sending the command
     */
    public void sendCommand(final String sessionId, final String command) {
        final Process process;
        synchronized (this) {

            }
        }
        return target;
    }

    /**
     * Commits any remaining documents in the cache to the index.
     * This method ensures all pending documents are processed.
     */
    @Override
    public void commit() {
        synchronized (docList) {
            if (!docList.isEmpty()) {