},
		})
	}
	// Marshal delete request.
	deleteReqBytes, err := xml.Marshal(delObjReq)
	c.Assert(err, nil)

	// Delete list of objects.
	request, err = newTestSignedRequest(http.MethodPost, getMultiDeleteObjectURL(s.endPoint, bucketName),
		int64(len(deleteReqBytes)), bytes.NewReader(deleteReqBytes), s.accessKey, s.secretKey, s.signer)
	c.Assert(err, nil)
	response, err = s.client.Do(request)

			// Register PostPolicy handler.
			bucket.Methods(http.MethodPost).HeadersRegexp("Content-Type", "multipart/form-data*").HandlerFunc(api.PostPolicyBucketHandler)
		case "HeadObject":
			// Register HeadObject handler.
			bucket.Methods("Head").Path("/{object:.+}").HandlerFunc(api.HeadObjectHandler)
		case "GetObject":
			// Register GetObject handler.
			bucket.Methods(http.MethodGet).Path("/{object:.+}").HandlerFunc(api.GetObjectHandler)

pkg net/http, const MethodGet = "GET"
pkg net/http, const MethodGet ideal-string
pkg net/http, const MethodHead = "HEAD"
pkg net/http, const MethodHead ideal-string
pkg net/http, const MethodOptions = "OPTIONS"
pkg net/http, const MethodOptions ideal-string
pkg net/http, const MethodPatch = "PATCH"
pkg net/http, const MethodPatch ideal-string
pkg net/http, const MethodPost = "POST"

		}
	}

	testObject := "testobject"

	// Initiate Multipart upload for testing CopyObjectPartHandler.
	rec := httptest.NewRecorder()
	req, err := newTestSignedRequestV4(http.MethodPost, getNewMultipartURL("", bucketName, testObject),
		0, nil, credentials.AccessKey, credentials.SecretKey, nil)
	if err != nil {
		t.Fatalf("Failed to create HTTP request for NewMultipart Request: <ERROR> %v", err)
	}

func guessIsRPCReq(req *http.Request) bool {
	if req == nil {
		return false
	}
	if req.Method == http.MethodGet && req.URL != nil {
		switch req.URL.Path {
		case grid.RoutePath, grid.RouteLockPath:
			return true
		}
	}

	return (req.Method == http.MethodPost || req.Method == http.MethodGet) &&
		strings.HasPrefix(req.URL.Path, minioReservedBucketPath+SlashSeparator)
}

 *     constructorDesc.newInstance(...); // Create an instance of Foo
 * }
 *
 * for (String methodName : beanDesc.getMethodNames()) {
 *     for (MethodDesc methodDesc : beanDesc.getMethodDescs(methodName)) {
 *         methodDesc.invoke(foo, ...); // Invoke Foo's method
 *     }
 * }
 * </pre>
 *
 * @author higa
 * @see BeanDescFactory
 */
public interface BeanDesc {

    /**

        final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);
        MethodDesc methodDesc = beanDesc.getMethodDescNoException("getAaa");
        assertThat(methodDesc, is(notNullValue()));
        assertThat(methodDesc.getMethodName(), is("getAaa"));
        methodDesc = beanDesc.getMethodDescNoException("getaaa");
        assertThat(methodDesc, is(nullValue()));
    }

    /**
     * @throws Exception
     */

     * @return a {@link MethodDesc} that matches the arguments, or {@literal null} if none exists
     */
    protected MethodDesc findSuitableMethodDescAdjustNumber(final MethodDesc[] methodDescs, final Object[] args) {
        for (final MethodDesc methodDesc : methodDescs) {
            if (isSuitable(methodDesc.getParameterTypes(), args, true)) {
                return methodDesc;
            }
        }

	// Cluster check handler to verify cluster is active
	healthRouter.Methods(http.MethodGet).Path(healthCheckClusterPath).HandlerFunc(httpTraceAll(ClusterCheckHandler))
	healthRouter.Methods(http.MethodHead).Path(healthCheckClusterPath).HandlerFunc(httpTraceAll(ClusterCheckHandler))
	healthRouter.Methods(http.MethodGet).Path(healthCheckClusterReadPath).HandlerFunc(httpTraceAll(ClusterReadCheckHandler))

		apiErr := getAPIError(ErrBusy)
		switch r.Method {
		case http.MethodHead:
			writeResponse(w, apiErr.HTTPStatusCode, nil, mimeNone)
		case http.MethodGet:
			writeErrorResponse(r.Context(), w, apiErr, r.URL)
		}
		return
	}

	// Verify if KMS is reachable if its configured
	if GlobalKMS != nil {