if (rpc.retval != 0) {
            throw new SmbException(rpc.retval, false);
        }
    }

    /**
     * Closes this SAM domain handle.
     *
     * @throws IOException if an I/O error occurs during handle closure
     */
    public void close() throws IOException {
        final MsrpcSamrCloseHandle rpc = new MsrpcSamrCloseHandle(this);
        handle.sendrecv(rpc);
        if (rpc.retval != 0) {

            handle.sendrecv(rpc2);
        }
    }

    /**
     * Closes this SAM policy handle.
     *
     * @throws IOException if an I/O error occurs during handle closure
     */
    public void close() throws IOException {
        final MsrpcSamrCloseHandle rpc = new MsrpcSamrCloseHandle(this);
        handle.sendrecv(rpc);
        if (rpc.retval != 0) {

   * should return immediately. Responses returned after shutdown will not be transmitted: their
   * socket connections have already been closed.
   */
  public open override fun close() {}

   *
   * To avoid leaking resources callers should close the [Response] which in turn will close the
   * underlying [ResponseBody].
   *
   * ```java
   * // ensure the response (and underlying response body) is closed
   * try (Response response = client.newCall(request).execute()) {
   *   ...
   * }
   * ```
   *

        return this.open && this.tree_num == this.tree.getTreeId() && this.tree.isConnected();
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbFileHandle#close(long)
     */
    @Override
    public synchronized void close(final long lastWriteTime) throws CIFSException {
        closeInternal(lastWriteTime, true);
    }

    /**
     * @param lastWriteTime
     * @throws SmbException
     */

        }
    }

    /**
     * Close the encryption context and securely wipe keys
     */
    @Override
    public void close() {
        if (closed) {
            return;
        }

        try {
            secureWipeKeys();

            // Clear session ID
            sessionId = null;

            log.debug("Encryption context closed and keys wiped");
        } finally {

          latch.countDown()
        }

        @Throws(IOException::class)
        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          response.close()
          latch.countDown()
        }
      },
    )
    latch.await()
    assertThat(call.isCanceled()).isTrue()
    assertThat(exceptionRef.get()).isNotNull()
  }

  @Test

                            return new FileInputStream(testFile);
                        }

                        @Override
                        public void close() throws IOException {
                            // Nothing to close
                        }
                    };
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }

	if err != nil {
		return err
	}
	defer xhttp.DrainBody(respBody)
	_, err = waitForHTTPResponse(respBody)
	return toStorageErr(err)
}

// Close - marks the client as closed.
func (client *storageRESTClient) Close() error {
	client.restClient.Close()
	return nil
}

var emptyDiskID = ""

// Returns a storage rest client.

        @Throws(IOException::class)
        override fun close() {
          if (!cacheRequestClosed &&
            !discard(ExchangeCodec.DISCARD_STREAM_TIMEOUT_MILLIS, MILLISECONDS)
          ) {
            cacheRequestClosed = true
            cacheRequest.abort()
          }
          source.close()
        }
      }

    val contentType = response.header("Content-Type")