/**
   * Regression test for an edge case where closing response body in the HTTP engine doesn't release
   * the corresponding stream allocation. This test keeps those response bodies alive and reads
   * them after the redirect has completed. This forces a connection to not be reused where it would
   * be otherwise.
   *
   *
   * This test leaks a response body by not closing it.
   *

-rwxrwxrwx 1 nobody nobody           45 Apr  1 06:13 chunkdocs/metadata
226 Closing data connection, sent 75 bytes
ftp> get
(remote-file) runner/chunkdocs/metadata
(local-file) test
local: test remote: runner/chunkdocs/metadata
229 Entering Extended Passive Mode (|||37785|)
150 Data transfer starting 45 bytes
	45        3.58 KiB/s
226 Closing data connection, sent 45 bytes
45 bytes received in 00:00 (3.55 KiB/s)
...
```

     * opened if it is not and should be closed with {@link #close()} when no longer
     * needed.
     *
     * Closing the context should cancel a pending notify request, but that does not seem to work reliable in all
     * implementations.
     *

 *  6. Read from and close that source.
 *
 * Exchanges that do not have a request body may skip creating and closing the request body.
 * Exchanges that do not have a response body can call
 * [newFixedLengthSource(0)][newFixedLengthSource] and may skip reading and closing that source.
 */
class Http1ExchangeCodec(
  /** The client that configures this stream. May be null for HTTPS proxy tunnels. */

     *
     * <p>The default implementation does nothing. Subclasses should override this method
     * if they need to perform cleanup operations.</p>
     *
     * @throws InvokerException if an error occurs while closing the {@link Invoker}
     */
    @Override
    default void close() throws InvokerException {}

 *   <li><b>Convenience methods:</b> These are implementations of common operations that are
 *       typically implemented by opening a stream using one of the methods in the first category,
 *       doing something and finally closing the stream or channel that was opened.
 * </ul>
 *
 * @since 14.0
 * @author Colin Decker
 */
@J2ktIncompatible
@GwtIncompatible
public abstract class ByteSink {

 *   <li><b>Convenience methods:</b> These are implementations of common operations that are
 *       typically implemented by opening a stream using one of the methods in the first category,
 *       doing something and finally closing the stream or channel that was opened.
 * </ul>
 *
 * @since 14.0
 * @author Colin Decker
 */
@J2ktIncompatible
@GwtIncompatible
public abstract class ByteSink {

    public void close() {
        if (connected && rpcHandle != null) {
            try {
                log.debug("Closing witness RPC client");
                rpcHandle.close();
                connected = false;
                rpcHandle = null;
            } catch (Exception e) {
                log.error("Error closing witness RPC client", e);
            }
        }
    }

     * @throws CIFSException if an error occurs getting the output stream
     */
    OutputStream getOutput() throws CIFSException;

    /**
     * {@inheritDoc}
     *
     * @throws CIFSException if an error occurs closing the handle
     *
     * @see java.lang.AutoCloseable#close()
     */
    @Override
    void close() throws CIFSException;

    /**
     * Tests whether this file descriptor is open and valid.
     *

    taskFaker.runTasks()
    assertThat(client.closed).isFalse()
    server.processNextFrame() // Read client closing, send server close.
    server.listener.assertClosing(1000, "Hello!")
    server.webSocket!!.finishReader()
    server.webSocket!!.close(1000, "Goodbye!")
    client.processNextFrame() // Read server closing, close connection.
    taskFaker.runTasks()
    client.listener.assertClosing(1000, "Goodbye!")