if strings.Contains(objInfo.ETag, "-") && len(objInfo.Parts) > 0 {
		w.Header()[xhttp.AmzMpPartsCount] = []string{strconv.Itoa(len(objInfo.Parts))}
	}
}

// Write object header
func setObjectHeaders(ctx context.Context, w http.ResponseWriter, objInfo ObjectInfo, rs *HTTPRangeSpec, opts ObjectOptions) (err error) {
	// set common headers
	setCommonHeaders(w)

	// Set last modified time.

)

func b2f(v bool) float64 {
	if v {
		return 1
	}
	return 0
}

// loadClusterErasureSetMetrics - `MetricsLoaderFn` for cluster storage erasure
// set metrics.
func loadClusterErasureSetMetrics(ctx context.Context, m MetricValues, c *metricsCache) error {
	result, _ := c.esetHealthResult.Get()

	m.Set(erasureSetOverallWriteQuorum, float64(result.WriteQuorum))
	m.Set(erasureSetOverallHealth, b2f(result.Healthy))

            {
                "type": "string_too_short",
                "loc": ["query", "q"],
                "msg": "String should have at least 3 characters",
                "input": "fa",
                "ctx": {"min_length": 3},
            }
        ]
    }


def test_openapi_schema(client: TestClient):
    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text

                    "loc": ["query", "id"],
                    "msg": 'Value error, Invalid ID format, it must start with "isbn-" or "imdb-"',
                    "input": "wtf-yes",
                    "ctx": {"error": {}},
                }
            ]
        }
    )


def test_openapi_schema(client: TestClient):
    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text

                "input": "not a valid url",
                "msg": "Input should be a valid URL, relative URL without a base",
                "type": "url_parsing",
                "ctx": {"error": "relative URL without a base"},
            },
        ]
    }


def test_openapi_schema(client: TestClient):
    response = client.get("/openapi.json")

        "detail": [
            {
                "type": "greater_than",
                "loc": ["body", 0, "age"],
                "msg": "Input should be greater than 0",
                "input": -1.0,
                "ctx": {"gt": 0},
            }
        ]
    }


def test_put_incorrect_body_multiple():
    response = client.post("/items/", json=[{"age": "five"}, {"age": "six"}])

            {
                "type": "greater_than",
                "loc": ["body", "item", "price"],
                "msg": "Input should be greater than 0",
                "input": -3.0,
                "ctx": {"gt": 0.0},
            }
        ]
    }


def test_openapi_schema(client: TestClient):
    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text

		}
	}
}

func TestDoesPresignedSignatureMatch(t *testing.T) {
	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()

	obj, fsDir, err := prepareFS(ctx)
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(fsDir)
	if err = newTestConfig(globalMinioDefaultRegion, obj); err != nil {
		t.Fatal(err)
	}

	} else {
		cfg.inlineBlock = 128 * humanize.KiByte
	}

	cfg.initialized = true

	return cfg, nil
}

func configLogOnceIf(ctx context.Context, err error, id string, errKind ...any) {
	logger.LogOnceIf(ctx, "config", err, id, errKind...)

	// create xlStorage test setup
	xl, _, err := newXLStorageTestSetup(t)
	if err != nil {
		t.Fatalf("Unable to create xlStorage test setup, %s", err)
	}
	ctx := t.Context()

	volume := "myvol-vol"
	object := "my-object"
	if err := xl.MakeVol(ctx, volume); err != nil {
		t.Fatalf("Unable to create volume, %s", err)
	}
	var versions [50]string
	for i := range versions {
		versions[i] = uuid.New().String()