return w.WriteCloser.Write(buf)
	})
	w.err = err
	return n, err
}

// Close closer interface to close the underlying closer
func (w *DeadlineWriter) Close() error {
	err := w.WriteCloser.Close()
	w.err = err
	if err == nil {
		w.err = errors.New("we are closed") // Avoids any reuse on the Write() side.
	}
	return err
}

    }

    /**
     * Closes the {@link Statement}.
     * <p>
     * If {@link Statement#close()} throws an exception, an error message is logged. The exception is not rethrown.
     * </p>
     *
     * @param statement
     *            {@link Statement}
     * @see Statement#close()
     */
    public static void close(final Statement statement) {
        if (statement == null) {
            return;
        }

                resumeKey = rkresp.getResumeKey();

                // start with some reasonably safe defaults, the server will till us if it does not like it
                // can we resume this if we loose the file descriptor?

                int maxChunks = 256;
                int maxChunkSize = 1024 * 1024;
                int byteLimit = 16 * 1024 * 1024;
                boolean retry = false;
                do {

      MockResponse
        .Builder()
        .body("Hello!")
        .setHeader("Content-Type", PLAIN)
        .build(),
    )
    val response = client.newCall(request().build()).execute()
    response.body.close()
    applicationLogs
      .assertLogEqual("--> GET $url")
      .assertLogMatch(Regex("""<-- 200 OK $url \(\d+ms, 6-byte body\)"""))
      .assertNoMoreLogs()
    networkLogs

    return 0;
  }

  @Override
  public boolean ready() throws IOException {
    return (current != null) && current.ready();
  }

  @Override
  public void close() throws IOException {
    if (current != null) {
      try {
        current.close();
      } finally {
        current = null;
      }
    }
  }

    }

    @Test
    @DisplayName("unwrap and close are available via SmbTree")
    void unwrap_and_close_interactions() {
        // Arrange
        when(tree.unwrap(SmbTreeInternal.class)).thenReturn(tree);

        // Act
        SmbTree unwrapped = tree.unwrap(SmbTreeInternal.class);
        tree.close();

        // Assert
        assertNotNull(unwrapped);

    @Override
    public void close() throws InvokerException {
        List<Exception> causes = null;
        List<AutoCloseable> cs = new ArrayList<>(closeables);
        Collections.reverse(cs);
        for (AutoCloseable c : cs) {
            if (c != null) {
                try {
                    c.close();
                } catch (Exception e) {

		u:    u,
		rest: rest.NewClient(u, tr, nil),
	}
}

// Close closes the underlying socket file descriptor.
func (restClient *ReconnectRESTClient) IsOnline() bool {
	// If rest client has not connected yet there is nothing to close.
	return restClient.rest != nil
}

func (restClient *ReconnectRESTClient) IsLocal() bool {
	return false
}

// Close closes the underlying socket file descriptor.

		CertAuthority: path.Join("testdata", "contrib", "certs", "root_ca_cert.pem"),
	}

	con, err := clientConfig.connectNats()
	if err != nil {
		t.Errorf("Could not connect to nats: %v", err)
	}
	defer con.Close()
}

func TestNatsConnTLSCustomCAHandshakeFirst(t *testing.T) {
	s, opts := natsserver.RunServerWithConfig(filepath.Join("testdata", "contrib", "nats_tls_handshake_first.conf"))
	defer s.Shutdown()

   */
  private val routePlanner = FakeRoutePlanner(taskFaker = taskFaker)
  private val finder = FastFallbackExchangeFinder(routePlanner, taskRunner)

  @AfterEach
  fun tearDown() {
    taskFaker.close()
    routePlanner.close()
  }

  @Test
  fun takeConnectedConnection() {
    val plan0 = routePlanner.addPlan()
    plan0.connectState = TLS_CONNECTED

    taskRunner.newQueue().execute("connect") {