func (z BackendType) Msgsize() (s int) {
	s = msgp.IntSize
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *BucketInfo) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 5
	// string "Name"
	o = append(o, 0x85, 0xa4, 0x4e, 0x61, 0x6d, 0x65)
	o = msgp.AppendString(o, z.Name)
	// string "Created"
	o = append(o, 0xa7, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64)

    return clientTestRule
  }

  fun setUp(
    protocol: Protocol,
    server: MockWebServer,
  ) {
    this.server = server
    this.protocol = protocol
    platform.assumeNotOpenJSSE()
    if (protocol === Protocol.HTTP_2) {
      platform.assumeHttp2Support()
      server.useHttps(handshakeCertificates.sslSocketFactory())
      client =
        clientTestRule.newClientBuilder()

	public fun close ()V
	public final fun code ()I
	public final fun handshake ()Lokhttp3/Handshake;
	public final fun header (Ljava/lang/String;)Ljava/lang/String;
	public final fun header (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
	public static synthetic fun header$default (Lokhttp3/Response;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Ljava/lang/String;
	public final fun headers ()Lokhttp3/Headers;

		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)
		}
		if transHdrs, ok := w.Header()[xhttp.MinIOTransition]; ok {
			if !strings.Contains(transHdrs[0], lc.Rules[tc.transRuleID].ID) {
				t.Fatalf("Test %d: Expected %s header", i+1, xhttp.MinIOTransition)
			}

    String CORS_ALLOW_ORIGIN = "CorsAllowOrigin";

    String API_DASHBOARD_RESPONSE_HEADER_LIST = "apiDashboardResponseHeaderList";

    String API_JSON_RESPONSE_HEADER_LIST = "apiJsonResponseHeaderList";

    String API_GSA_RESPONSE_HEADER_LIST = "apiGsaResponseHeaderList";

    String SMB_AVAILABLE_SID_TYPES = "smbAvailableSidTypes";

kind: ConfigMap
metadata:
  name: metallb-excludel2
  namespace: metallb-system
---
apiVersion: v1
kind: Secret
metadata:
  name: webhook-server-cert
  namespace: metallb-system
---
apiVersion: v1
kind: Service
metadata:
  name: webhook-service
  namespace: metallb-system
spec:
  ports:
  - port: 443
    targetPort: 9443

                "lb_endpoints": [
                  {
                    "endpoint": {
                      "address": {
                        "envoy_internal_address": {
                          "server_listener_name": "connect_originate",
                          "endpoint_id": "192.168.195.248:800"
                        }
                      },
                      "health_check_config": {}

const (
	EnvTestOpenIDServer  = "_MINIO_OPENID_TEST_SERVER"
	EnvTestOpenIDServer2 = "_MINIO_OPENID_TEST_SERVER_2"
)

// SetUpOpenIDs - sets up one or more OpenID test servers using the test OpenID
// container and canned data from https://github.com/minio/minio-ldap-testing
//
// Each set of client app params corresponds to a separate openid server, and
// the i-th server in this will be applied the i-th policy in `rolePolicies`. If

  @Test
  fun multipleDnsLookupsForSingleCall() {
    server.enqueue(
      MockResponse.Builder()
        .code(301)
        .setHeader("Location", "http://www.fakeurl:" + server.port)
        .build(),
    )
    server.enqueue(MockResponse())
    val dns = FakeDns()
    dns["fakeurl"] = client.dns.lookup(server.hostName)
    dns["www.fakeurl"] = client.dns.lookup(server.hostName)
    client =
      client.newBuilder()

        Doc(
            """
            Automatically convert underscores to hyphens in the parameter field name.

            Read more about it in the
            [FastAPI docs for Header Parameters](https://fastapi.tiangolo.com/tutorial/header-params/#automatic-conversion)
            """
        ),
    ] = True,
    title: Annotated[
        Optional[str],
        Doc(
            """