if chksm.Type.FullObjectRequested() {
				m[xhttp.AmzChecksumType] = xhttp.AmzChecksumTypeFullObject
			} else {
				m[xhttp.AmzChecksumType] = xhttp.AmzChecksumTypeComposite
			}

			w := httptest.NewRecorder()
			AddChecksumHeader(w, m)
			gotChksm, err := GetContentChecksum(w.Result().Header)
			if tt.wantErr {
				if err == nil {
					t.Fatalf("Expected error for %s, got none", tt.name)
				}
				return
			}

	var okHandler http.HandlerFunc = func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	}
	for i, test := range sseTLSHandlerTests {
		globalIsTLS = test.IsTLS

		w := httptest.NewRecorder()
		r := new(http.Request)
		r.Header = test.Header
		r.URL = test.URL

		h := setRequestValidityMiddleware(okHandler)
		h.ServeHTTP(w, r)

		switch {

		return fmt.Sprintf("MinIO %s: %s fail for \"%s\": \n<Error> %s", instanceType, testType, testName, failMsg)
	}

	// httptest Recorder to capture all the response by the http handler.
	rec := httptest.NewRecorder()
	// reading the body to preserve it so that it can be used again for second attempt of sending unsigned HTTP request.
	// If the body is read in the handler the same request cannot be made use of.

		t.Fatalf("Initializing config.json failed")
	}

	objectName := `\../.minio.sys/config/hello.txt`

	// initialize HTTP NewRecorder, this records any mutations to response writer inside the handler.
	rec := httptest.NewRecorder()
	// construct HTTP request for Get Object end point.
	req, err := newTestSignedRequestV4(http.MethodPut, getPutObjectURL("", bucketName, objectName),

		shouldPass         bool
	},
) {
	for i, testCase := range testCases {
		// initialize httptest Recorder, this records any mutations to response writer inside the handler.
		rec := httptest.NewRecorder()
		// construct HTTP request
		req, err := newTestSignedRequestV4(testCase.method, getBucketLifecycleURL("", testCase.bucketName),

			obj:         obj1,
			expRuleID:   0,
			transRuleID: 1,
		},
		{
			obj:         obj2,
			expRuleID:   0,
			transRuleID: 2,
		},
	}
	for i, tc := range tests {
		w := httptest.NewRecorder()
		lc.SetPredictionHeaders(w, tc.obj)
		if expHdrs, ok := w.Header()[xhttp.AmzExpiration]; ok && !strings.Contains(expHdrs[0], lc.Rules[tc.expRuleID].ID) {
			t.Fatalf("Test %d: Expected %s header", i+1, xhttp.AmzExpiration)

					})
					writeResponse(w, serr.HTTPStatusCode(), encodedErrorResponse, mimeXML)
				} else {
					writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
				}
				return
			}
			nr := httptest.NewRecorder()
			rw := xhttp.NewResponseRecorder(nr)
			rw.LogErrBody = true
			rw.LogAllBody = true
			rreq.SelectParameters.Evaluate(rw)
			rreq.SelectParameters.Close()
			return
		}

pkg net/http/cgi, type Handler struct, Root string
pkg net/http/fcgi, func Serve(net.Listener, http.Handler) error
pkg net/http/httptest, const DefaultRemoteAddr ideal-string
pkg net/http/httptest, func NewRecorder() *ResponseRecorder
pkg net/http/httptest, func NewServer(http.Handler) *Server
pkg net/http/httptest, func NewTLSServer(http.Handler) *Server
pkg net/http/httptest, func NewUnstartedServer(http.Handler) *Server