.cache(cache)
        .build()
    val request1 = Request(server.url("/"))
    client.newCall(request1).enqueue(callback)
    callback.await(request1.url).assertCode(200).assertBody("A")
    assertThat(server.takeRequest().headers["If-None-Match"]).isNull()
    val request2 = Request(server.url("/"))
    client.newCall(request2).enqueue(callback)
    callback.await(request2.url).assertCode(200).assertBody("A")

    // No authorization header for the first request...
    var request = server.takeRequest()
    assertThat(request.headers["Authorization"]).isNull()

    // ...but the three requests that follow requests include an authorization header.
    for (i in 0..2) {
      request = server.takeRequest()
      assertThat(request.requestLine).isEqualTo("GET / HTTP/1.1")
      assertThat(request.headers["Authorization"])

     *
     * @param request the multi-search request
     * @return a future for the multi-search response
     */
    @Override
    public ActionFuture<MultiSearchResponse> multiSearch(final MultiSearchRequest request) {
        return client.multiSearch(request);
    }

    /**
     * Executes a multi-search request asynchronously with a callback.
     *

        "c6",
      ),
    )
  }

  @Test
  fun getHasCorrectResponse() {
    val request = Request(server.url("/abc"))

    val response = testBasicCachingRules(request)

    assertThat(response.request.url).isEqualTo(request.url)
    assertThat(response.cacheResponse!!.request.url).isEqualTo(request.url)
  }

  @Test
  fun postWithOverrideResponse() {

                    // If request failed and we added advanced features, retry with a basic request
                    if ((leasesAdded || persistentHandlesAdded) && shouldRetryWithBasicRequest(e)) {
                        if (log.isDebugEnabled()) {
                            log.debug("CREATE request with advanced features failed ({}), retrying with basic request",

	// execute the HTTP request for object upload.
	response, err = s.client.Do(request)
	c.Assert(err, nil)
	c.Assert(response.StatusCode, http.StatusOK)

	objectName2 := "testObject2"
	// Unlike the actual PUT object request, the request to Copy Object doesn't contain request body,
	// empty body with the "X-Amz-Copy-Source" header pointing to the object to copies it in the backend.

		hip.forceStart = true
	}
	if _, ok := qParams[mgmtForceStop]; ok {
		hip.forceStop = true
	}

	// Invalid request conditions:
	//
	//   Cannot have both forceStart and forceStop in the same
	//   request; If clientToken is provided, request can only be
	//   to continue receiving logs, so it cannot be start or
	//   stop;
	if (hip.forceStart && hip.forceStop) ||

		},
	}

	// string to represent V2 signed HTTP request.
	reqV2Str := "V2 Signed HTTP request"
	// string to represent V4 signed HTTP request.
	reqV4Str := "V4 Signed HTTP request"
	// Collection of HTTP request and ResponseRecorder and request type string.
	type inputReqRec struct {
		req     *http.Request
		rec     *httptest.ResponseRecorder
		reqType string
	}

            unc = dunc;
            if (request != null && request.path != null && request.path.endsWith("\\") && !dunc.endsWith("\\")) {
                dunc += "\\";
            }
            if (request != null) {
                request.path = dunc;
                request.flags2 |= SmbConstants.FLAGS2_RESOLVE_PATHS_IN_DFS;
            }

	"github.com/minio/minio/internal/logger"
	"github.com/minio/minio/internal/s3select"
	"github.com/minio/mux"
	"github.com/minio/pkg/v3/policy"
)

// supportedHeadGetReqParams - supported request parameters for GET and HEAD presigned request.
var supportedHeadGetReqParams = map[string]string{
	"response-expires":             xhttp.Expires,
	"response-content-type":        xhttp.ContentType,
	"response-cache-control":       xhttp.CacheControl,