*
 * ```java
 * client.connectionPool().evictAll();
 * ```
 *
 * If your client has a cache, call [close()][Cache.close]. Note that it is an error to create calls
 * against a cache that is closed, and doing so will cause the call to crash.
 *
 * ```java
 * client.cache().close();
 * ```
 *
 * OkHttp also uses daemon threads for HTTP/2 connections. These will exit automatically if they
 * remain idle.

        .build()
    val callA = client.newCall(request)
    assertThat(callA.tag(String::class) { "a" }).isEqualTo("a")
    assertThat(callA.tag(String::class) { "b" }).isEqualTo("a")

    val callB = callA.clone()
    assertThat(callB.tag(String::class) { "c" }).isEqualTo("c")
    assertThat(callB.tag(String::class) { "d" }).isEqualTo("c")
  }

        void testWriteOperationsDoNotModifyArray() throws Exception {
            // Given
            byte[] originalDst = new byte[100];
            byte[] dst = originalDst.clone();

            // When
            Method writeParams = SmbComNtCancel.class.getDeclaredMethod("writeParameterWordsWireFormat", byte[].class, int.class);
            writeParams.setAccessible(true);

          }
        }
      }

      assertThat(call.canceled).isTrue()
      assertThat(call.responseClosed).isTrue()
    }
  }

  /** A call that keeps track of whether its response body is closed. */
  private class ClosableCall : FailingCall() {
    private val response =
      Response
        .Builder()
        .request(Request("https://example.com/".toHttpUrl()))
        .protocol(Protocol.HTTP_1_1)

	unset MINIO_KMS_AUTO_ENCRYPTION # do not auto-encrypt objects
	export MINIO_CI_CD=1

	mkdir ${WORK_DIR}
	C_PWD=${PWD}
	if [ ! -x "$PWD/mc" ]; then
		MC_BUILD_DIR="mc-$RANDOM"
		if ! git clone --quiet https://github.com/minio/mc "$MC_BUILD_DIR"; then
			echo "failed to download https://github.com/minio/mc"
			purge "${MC_BUILD_DIR}"
			exit 1
		fi

		(cd "${MC_BUILD_DIR}" && go build -o "$C_PWD/mc")

        synchronized(this) {
          queueSize -= message.data.size.toLong()
        }
      } else if (messageOrClose is Close) {
        val close = messageOrClose
        writer!!.writeClose(close.code, close.reason)

        // We closed the writer: now both reader and writer are closed.
        if (sendOnClosed) {
          listener.onClosed(this, receivedCloseCode, receivedCloseReason!!)
        }
      } else {

Use [`mc admin policy`](https://docs.min.io/community/minio-object-store/reference/minio-mc-admin/mc-admin-policy.html#command-mc.admin.policy) to create custom admin policies.

Create new canned policy file `adminManageUser.json`. This policy enables admin user to
manage other users.

```json
cat > adminManageUser.json << EOF
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": [

 * ProjectBuildList.getByTaskSegments). Or maybe they should be introduced in the calculation
 * of the execution plan instead, which seems much nicer.
 * </p>
 * <p>
 * Additionally this class contains a clone of the MavenSession, which is *only* needed
 * because it has as notion of a "current" project.
 * </p>
 * <strong>NOTE:</strong> This class is not part of any public api and can be changed or deleted without prior notice.
 *

                for (PluginExecution element : src) {
                    Object key = getPluginExecutionKey(element);
                    merged.put(key, element.clone());
                }

                for (PluginExecution element : tgt) {
                    Object key = getPluginExecutionKey(element);
                    PluginExecution existing = merged.get(key);

    private final String fileName;
    private int closeFlags;

    /**
     * Constructs a close request with file ID and name
     *
     * @param config
     *            The configuration to use
     * @param fileId
     *            The file ID to close
     * @param fileName
     *            The name of the file being closed
     */