expectedFields: map[string]struct{}{},
		},
	}
	for _, test := range tests {
		t.Run("", func(t *testing.T) {
			gotFields := kvFields(test.input, test.keys)
			if len(gotFields) != len(test.expectedFields) {
				t.Errorf("Expected keys %d, found %d", len(test.expectedFields), len(gotFields))
			}
			found := true
			for _, field := range gotFields {
				_, ok := test.expectedFields[field]
				found = found && ok
			}

		predCount++
	}
	if a.ObjectSizeLessThan > 0 {
		predCount++
	}

	if predCount < 2 {
		return errXMLNotWellFormed
	}

	if a.ContainsDuplicateTag() {
		return errDuplicateTagKey
	}
	for _, t := range a.Tags {
		if err := t.Validate(); err != nil {
			return err
		}
	}

	if a.ObjectSizeGreaterThan < 0 || a.ObjectSizeLessThan < 0 {
		return errXMLNotWellFormed
	}
	return nil
}

		wg.Wait()
		xioutil.SafeClose(ch)
		for range ch {
		}
	}()

	noQuorum := lockNotFound > len(restClnts)-quorum
	return noQuorum, nil
}

// lock tries to acquire the distributed lock, returning true or false.
func lock(ctx context.Context, ds *Dsync, locks *[]string, id, source string, isReadLock bool, tolerance, quorum int, names ...string) bool {
	for i := range *locks {
		(*locks)[i] = ""
	}

			"dir/",
			[]string{"object0"},
		},
	}

	for i, testCase := range testCases {
		err := obj.MakeBucket(context.Background(), testCase.bucketName, MakeBucketOptions{})
		if err != nil {
			t.Fatalf("%s : %s", instanceType, err.Error())
		}

		for _, object := range testCase.objectToUploads {
			md5Bytes := md5.Sum([]byte(object.content))

	orderChangePools := []*erasureSets{
		pools[1],
		pools[0],
	}

	var nmeta1 poolMeta
	nmeta1.Version = poolMetaVersion
	nmeta1.Pools = append(nmeta1.Pools, meta.Pools...)
	for i, pool := range nmeta1.Pools {
		if i == 0 {
			nmeta1.Pools[i] = PoolStatus{
				CmdLine:    pool.CmdLine,
				ID:         i,
				LastUpdate: UTCNow(),
				Decommission: &PoolDecommissionInfo{
					Complete: true,
				},
			}

	if err != nil {
		return
	}
	err = en.WriteMapHeader(uint32(len(z.Tiers)))
	if err != nil {
		err = msgp.WrapError(err, "Tiers")
		return
	}
	for za0001, za0002 := range z.Tiers {
		err = en.WriteString(za0001)
		if err != nil {
			err = msgp.WrapError(err, "Tiers")
			return
		}
		err = za0002.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "Tiers", za0001)

            assertTrue(ACE.GENERIC_EXECUTE >= 0x10000000, "GENERIC_EXECUTE should be in generic rights range");
            assertTrue(ACE.GENERIC_WRITE >= 0x10000000, "GENERIC_WRITE should be in generic rights range");
            // GENERIC_READ is 0x80000000 which is in the range when treated as unsigned

					PartNumber: 2,
					Algorithm:  HighwayHash256S,
					Hash:       nil,
				},
			},
		},
	}
	for _, size := range []int{1, 10, 1000, 100_000} {
		b.Run(fmt.Sprint(size, "-versions"), func(b *testing.B) {
			var xl xlMetaV2
			ids := make([]string, size)
			for i := range size {
				fi.VersionID = mustGetUUID()
				fi.DataDir = mustGetUUID()
				ids[i] = fi.VersionID

		return nil, nil, err
	}

	// Wait up to 10 seconds for disks to come online.
	pools := obj.(*erasureServerPools)
	t := time.Now()
	for _, pool := range pools.serverPools {
		for _, sets := range pool.erasureDisks {
			for _, s := range sets {
				if !s.IsLocal() {
					for !s.IsOnline() {
						time.Sleep(100 * time.Millisecond)
						if time.Since(t) > 10*time.Second {

{{- if .Values.consoleIngress.ingressClassName }} ingressClassName: {{ .Values.consoleIngress.ingressClassName }} {{- end }} {{- if .Values.consoleIngress.tls }} tls: {{- range .Values.consoleIngress.tls }} - hosts: {{- range .hosts }} - {{ . | quote }} {{- end }} secretName: {{ .secretName }} {{- end }} {{- end }} rules: {{- range .Values.consoleIngress.hosts }} - http: paths: - path: {{ $ingressPath }} {{- if semverCompare ">=1.19-0" $.Capabilities.KubeVersion.GitVersion }} pathType: Prefix backend:...