if err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}
	if res, err := json.Marshal(metrics); err != nil {
		writeCustomErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(ErrInternalError), err.Error(), r.URL)
	} else {
		writeSuccessResponseJSON(w, res)
	}
}

// KMSAPIsHandler - GET /minio/kms/v1/apis

		RequestURI string      `json:"reqURI"`
		Header     http.Header `json:"header"`
	}
	res := jsonResult{}
	if err = json.Unmarshal([]byte(strings.ReplaceAll(jsonReq, "%%", "%")), &res); err != nil {
		t.Fatal(err)
	}

	// Look for expected method.
	if res.Method != http.MethodGet {
		t.Fatalf("Unexpected method %s, expected 'GET'", res.Method)
	}

	// Look for expected query values
	expectedQuery := url.Values{}

        String response = checkGetMethod(searchBody, "").asString();
        final Map<String, Object> res = JsonPath.from(response).getMap("response.setting");
        assertTrue(res.containsKey("total_words_num"));
        assertTrue(res.containsKey("document_words_num"));
        assertTrue(res.containsKey("query_words_num"));
        assertEquals(Integer.valueOf(0), JsonPath.from(response).get("response.status"));
    }

        FilterChain chain = new FilterChain() {
            @Override
            public void doFilter(ServletRequest req, ServletResponse res) throws IOException, ServletException {
                chainCalled.set(true);
                assertSame(request, req);
                assertSame(response, res);
            }
        };

        // Setup WebApiManagerFactory that returns null

    @Test
    void testDefaultPolicy() throws Exception {
        MetadataGraphEdge res;

        res = policy.apply(e1, e2);
        assertEquals("1.1", res.getVersion(), "Wrong depth edge selected");

        res = policy.apply(e1, e3);
        assertEquals("1.2", res.getVersion(), "Wrong version edge selected");
    }

			if len(fivs.FreeVersions) > 0 {
				res["free-versions"] = strconv.Itoa(len(fivs.FreeVersions))
			}

			if sizeS.versions > 0 {
				res["versions"] = strconv.FormatUint(sizeS.versions, 10)
			}
			res["size"] = strconv.FormatInt(sizeS.totalSize, 10)
			for name, tier := range sizeS.tiers {
				res["tier-size-"+name] = strconv.FormatUint(tier.TotalSize, 10)
				res["tier-versions-"+name] = strconv.Itoa(tier.NumVersions)

	res := DB.FirstOrCreate(&user, "name = ?", user.Name)
	if res.Error != nil || res.RowsAffected != 1 {
		t.Fatalf("first or create rows affect err:%v rows:%d", res.Error, res.RowsAffected)
	}

	res = DB.FirstOrCreate(&user, "name = ?", user.Name)
	if res.Error != nil || res.RowsAffected != 0 {
		t.Fatalf("first or create rows affect err:%v rows:%d", res.Error, res.RowsAffected)
	}
}

	}

	mkTest := func(N, parity, agree int) (res struct {
		metaArr  []FileInfo
		errs     []error
		parities []int
		parity   int
	},
	) {
		res.metaArr = mkMetaArr(N, parity, agree)
		res.parities = mkParities(N, N-(N/2+1), parity, agree)
		res.errs = make([]error, N)
		if agree >= N/2+1 { // simple majority consensus
			res.parity = N - (N/2 + 1)
		} else {
			res.parity = -1
		}
		return res
	}

        String response = checkGetMethod(searchBody, "").asString();
        final Map<String, Object> res = JsonPath.from(response).getMap("response");
        assertTrue(res.containsKey("env_props"));
        assertTrue(res.containsKey("system_props"));
        assertTrue(res.containsKey("fess_props"));
        assertTrue(res.containsKey("bug_report_props"));
        assertEquals(Integer.valueOf(0), JsonPath.from(response).get("response.status"));

        ShareEnumIterator it = new ShareEnumIterator(parent, entries.iterator(), filter);

        assertTrue(it.hasNext());
        SmbResource res = it.next();
        assertNotNull(res);
        assertEquals("good/", res.getName());
        assertFalse(it.hasNext());

        verify(filter, times(2)).accept(any());
    }

    static Stream<Arguments> invalidNamesAndFilterFlag() {