// request and proceed further. This is a work-around to address
	// an important problem for ListBuckets() getting signed with
	// different regions.
	if region == "" {
		region = sRegion
	}
	// Should validate region, only if region is set.
	if !isValidRegion(sRegion, region) {
		return ch, ErrAuthorizationHeaderMalformed
	}
	if credElements[2] != string(stype) {
		if stype == serviceSTS {

     * @return ActionResponse containing the cached document content or error redirect
     */
    @Execute
    public ActionResponse index(final CacheForm form) {
        validate(form, messages -> {}, () -> asHtml(virtualHost(path_Error_ErrorJsp)));
        if (isLoginRequired()) {
            return redirectToLogin();
        }

        Map<String, Object> doc = null;
        try {

        byte[] buffer = new byte[20];
        int len = cmd.writeParameterWordsWireFormat(buffer, 0);
        assertEquals(-12, len, "writeParameterWordsWireFormat should write 12 Bytes");
        // Validate parameter bytes using reflection since fields are private
        assertEquals(getField(cmd, "fid"), SMBUtil.readInt2(buffer, 0));
        assertEquals(getField(cmd, "typeOfLock"), buffer[2]);

     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse create(final CreateForm form) {
        verifyCrudMode(form.crudMode, CrudMode.CREATE);
        validate(form, messages -> {}, this::asEditHtml);
        verifyToken(this::asEditHtml);
        getRole(form).ifPresent(entity -> {
            try {
                roleService.store(entity);

     * @return action response with the search results or error page
     */
    @Execute
    @Secured({ ROLE })
    public ActionResponse upload(final UploadForm form) {
        validate(form, messages -> {}, () -> asListHtml(null));
        verifyTokenKeep(() -> asListHtml(this::saveToken));

        String header = null;
        final StringBuilder buf = new StringBuilder(1000);

		return
	}

	if r.Header.Get(xhttp.Range) != "" {
		writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidRange), r.URL)
		return
	}

	// Validate pre-conditions if any.
	opts.CheckPrecondFn = func(oi ObjectInfo) bool {
		if _, err := DecryptObjectInfo(&oi, r); err != nil {
			writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
			return true
		}

			bucket: "bucket",
			object: "///object////",
		},
		// Test case 8 url path is empty.
		{
			path:   "",
			bucket: "",
			object: "",
		},
	}

	// Validate all test cases.
	for _, testCase := range testCases {
		t.Run("", func(t *testing.T) {
			bucketName, objectName := path2BucketObject(testCase.path)
			if bucketName != testCase.bucket {

Once the **patch** is successfully applied, developer must run tests to validate the fix that was backported by running following tests, locally.

Unit tests

```
λ make test
```

Verify different type of MinIO deployments work

```
λ make verify
```

     * @return The HTML response.
     */
    @Execute
    public HtmlResponse advance(final SearchForm form) {
        if (isLoginRequired()) {
            return redirectToLogin();
        }
        validate(form, messages -> {}, () -> asHtml(virtualHost(path_IndexJsp)).renderWith(data -> {
            buildInitParams();
            RenderDataUtil.register(data, "notification", fessConfig.getNotificationSearchTop());
        }));

	loader MetricsLoaderFn,
) *MetricsGroup {
	mg := &MetricsGroup{
		CollectorPath: path,
		Descriptors:   descriptors,
		loader:        loader,
	}
	mg.validate()
	return mg
}

// NewBucketMetricsGroup creates a new MetricsGroup for metrics with a `bucket`
// dimension (label).
//
// The `loader` function loads metrics from the cache and the system for a given