* successfully cancelled step will immediately start closing all objects captured for later closing
 * by it and by its input steps.
 *
 * <h3>Ending a pipeline</h3>
 *
 * Each {@code ClosingFuture} pipeline must be ended. To end a pipeline, decide whether you want to
 * close the captured objects automatically or manually.
 *
 * <h4>Automatically closing</h4>
 *

            // Verify that the XML formatting is correct - no malformed closing tags
            assertFalse(result.contains("</plugin></plugins>"), "Should not have malformed closing tags");
            assertFalse(result.contains("</plugins></pluginManagement>"), "Should not have malformed closing tags");

            // Check that proper indentation is maintained

     * @throws CIFSException if an error occurs while closing the file
     */
    void close(long lastWriteTime) throws CIFSException;

    /**
     * {@inheritDoc}
     *
     * @see java.lang.AutoCloseable#close()
     */
    @Override
    void close() throws CIFSException;

    /**
     * Releases this file handle without closing it
     *

                this.next = null;
                this.treeHandle.release();
            }
        }
    }

    /**
     * Performs the internal closing operations specific to the implementation.
     *
     * @throws CIFSException if an error occurs during internal closing
     */
    protected abstract void doCloseInternal() throws CIFSException;

    /**
     * {@inheritDoc}
     *

If there are compelling use cases for early closing in dependencies with `yield`, I would consider adding a new way to opt in to early closing.

### Dependencies with `yield` and `except`, Technical Details { #dependencies-with-yield-and-except-technical-details }

        this.processDestroyTimeout = processDestroyTimeout;
    }

    /**
     * Sets the timeout for stream closing operations.
     *
     * @param streamCloseTimeout timeout in seconds for stream closing operations
     */
    public void setStreamCloseTimeout(final int streamCloseTimeout) {
        this.streamCloseTimeout = streamCloseTimeout;
    }

    /**

        assertThrows(CIFSException.class, () -> smbFileHandle.close(lastWriteTime),
                "close(long) should throw CIFSException when closing fails.");
        verify(smbFileHandle, times(1)).close(lastWriteTime);
    }

    /**
     * Test close() successfully.
     *
     * @throws CIFSException
     */
    @Test

            } catch (Exception e) {
                log.debug("Error closing connection: {}", e.getMessage());
            }
        });
        connections.clear();

        nonPooledConnections.forEach(conn -> {
            try {
                conn.disconnect(true, true);
            } catch (Exception e) {
                log.debug("Error closing non-pooled connection: {}", e.getMessage());
            }
        });

    @Timeout(value = 5, unit = TimeUnit.SECONDS)
    void testLeakDetection() throws InterruptedException {
        // Create resource that will be garbage collected without closing
        createLeakyResource();

        // Force garbage collection
        System.gc();
        Thread.sleep(200);

        // Check for leaks
        resourceManager.checkForLeaks();

     */
    @Override
    protected boolean isDone() {
        return false;
    }

    /**
     * Performs internal closing operations for SMB2 enumeration.
     *
     * @throws CIFSException if an error occurs during closing
     */
    @Override
    protected void doCloseInternal() throws CIFSException {
        try {
            @SuppressWarnings("resource")