logger.log(Level.WARNING, "IOException thrown while closing Closeable.", e);
      } else {
        throw e;
      }
    }
  }

  /**
   * Closes the given {@link InputStream}, logging any {@code IOException} that's thrown rather than
   * propagating it.
   *
   * <p>While it's not safe in the general case to ignore exceptions that are thrown when closing an

     * @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
     *

            // 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

 * 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>
 *

    val delegate = delegate
    if (delegate != null) {
      this.delegate = null
      delegate.onClosing(webSocket, code, reason)
    } else {
      events.add(Closing(code, reason))
    }
  }

  override fun onClosed(
    webSocket: WebSocket,
    code: Int,
    reason: String,
  ) {
    Platform.get().log("[WS $name] onClosed $code", Platform.INFO, null)

 *
 *  * **Open:** the web socket has been accepted by the remote peer and is fully operational.
 *    Messages in either direction are enqueued for immediate transmission.
 *
 *  * **Closing:** one of the peers on the web socket has initiated a graceful shutdown. The web
 *    socket will continue to transmit already-enqueued messages but will refuse to enqueue new
 *    ones.
 *

                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