fi
  fi

  # Give this cluster of those IPs
  RANGE="["
  for i in {0..19}; do
    RANGE+="${METALLB_IPS4[1]},"
    METALLB_IPS4=("${METALLB_IPS4[@]:1}")
    if [[ "${#METALLB_IPS6[@]}" != 0 ]]; then
      RANGE+="${METALLB_IPS6[1]},"
      METALLB_IPS6=("${METALLB_IPS6[@]:1}")
    fi
  done
  RANGE="${RANGE%?}]"

  echo '
apiVersion: metallb.io/v1beta1
kind: IPAddressPool

				"Action": ["kms:CreateKey"],
				"Resource": ["arn:minio:kms:::non-matching-key-name"] }`,

			wantStatusCode: http.StatusForbidden,
			wantResp:       []string{"AccessDenied"},
		},
	}
	for testNum, test := range tests {
		t.Run(fmt.Sprintf("%d %s", testNum+1, test.name), func(t *testing.T) {
			execKMSTest(t, test, adminTestBed)
		})
	}
}

func TestKMSHandlersKeyStatus(t *testing.T) {

			for _, field := range schema.PrimaryFields {
				if field.AutoIncrement {
					schema.PrioritizedPrimaryField = field
					break
				}
			}
		}
	}

	for _, field := range schema.PrimaryFields {
		schema.PrimaryFieldDBNames = append(schema.PrimaryFieldDBNames, field.DBName)
	}

	for _, field := range schema.Fields {

			fmt.Println("Healstatus on items ===")
			for _, item := range status.Items {
				if err = enc.Encode(&item); err != nil {
					log.Fatalln(err)
				}
			}
			break
		}
		if status.Summary == "stopped" {
			fmt.Println("Healstatus on items ===")
			fmt.Println("Heal failed with", status.FailureDetail)
			break
		}

		for _, item := range status.Items {
			if err = enc.Encode(&item); err != nil {

				err = msgp.WrapError(err, "BucketStatuses")
				return
			}
			if z.BucketStatuses == nil {
				z.BucketStatuses = make(map[string]ResyncStatusType, zb0002)
			} else if len(z.BucketStatuses) > 0 {
				for key := range z.BucketStatuses {
					delete(z.BucketStatuses, key)
				}
			}
			for zb0002 > 0 {
				zb0002--
				var za0001 string
				var za0002 ResyncStatusType
				za0001, err = dc.ReadString()
				if err != nil {

		resourceMetricsMapMu.RLock()
		defer resourceMetricsMapMu.RUnlock()
		for _, subSys := range subSystems {
			stats, found := resourceMetricsMap[subSys]
			if found {
				requireAvgMax := true
				if subSys == driveSubsystem {
					requireAvgMax = false
				}
				for _, m := range stats {
					metrics = append(metrics, prepareResourceMetrics(m, subSys, requireAvgMax)...)
				}
			}
		}

	if l.LastSec > o.LastSec {
		o.forwardTo(l.LastSec)
		merged.LastSec = l.LastSec
	} else {
		l.forwardTo(o.LastSec)
		merged.LastSec = o.LastSec
	}

	for i := range merged.Totals {
		merged.Totals[i] = AccElem{
			Total: l.Totals[i].Total + o.Totals[i].Total,
			N:     l.Totals[i].N + o.Totals[i].N,
			Size:  l.Totals[i].Size + o.Totals[i].Size,
		}
	}
	return merged
}

		{
			bufio.NewReader(readers[3]),
			nil,
			[]byte("1000"),
			[]byte("111123333333333333334444211"),
		},
	}
	// Valid test cases for each chunk line.
	for i, tt := range testCases {
		chunkSize, chunkSignature, err := readChunkLine(tt.reader)
		if err != tt.expectedErr {
			t.Errorf("Test %d: Expected %s, got %s", i+1, tt.expectedErr, err)
		}
		if !bytes.Equal(chunkSize, tt.chunkSize) {

		wantErr bool
	}{
		{
			name:    "Fail when logs scope-level pair don't match pattern",
			args:    args{validationPattern: validationPattern, slp: "invalid:pattern"},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := newScopeLevelPair(tt.args.slp, tt.args.validationPattern)
			if (err != nil) != tt.wantErr {
				t.Errorf("newScopeLevelPair() error = %v, wantErr %v", err, tt.wantErr)

		LabelSelector: fmt.Sprintf("%s=%s,!%s", label.IoIstioRev.Name, client.Revision(), label.IoIstioTag.Name),
	})
	if err != nil {
		return nil, err
	}
	for _, whc := range webhooks.Items {
		for _, wh := range whc.Webhooks {
			if wh.ClientConfig.URL != nil {
				u, err := url.Parse(*wh.ClientConfig.URL)
				if err != nil {
					return nil, fmt.Errorf("parsing webhook URL: %w", err)
				}