for metricName, mv := range m.values {
		desc := m.descriptors[metricName]
		promDesc := desc.toPromDesc(namePrefix, extraLabels)
		for _, v := range mv {
			// labelValues is in the same order as the variable labels in the
			// descriptor.
			labelValues := make([]string, 0, len(v.Labels))
			for _, k := range desc.VariableLabels {
				labelValues = append(labelValues, v.Labels[k])
			}

	podStats, err := collector.statsProvider.ListPodStats(ctx)
	if err != nil {
		return
	}
	addGauge := func(desc *metrics.Desc, pvcRef *stats.PVCReference, v float64, lv ...string) {
		lv = append([]string{pvcRef.Namespace, pvcRef.Name}, lv...)
		ch <- metrics.NewLazyConstMetric(desc, metrics.GaugeValue, v, lv...)
	}
	allPVCs := sets.Set[string]{}
	for _, podStat := range podStats {
		if podStat.VolumeStats == nil {

				t.Errorf("%s: error reading record: %v", test.desc, err)
				continue outer
			}
			content = append(content, rec.content()...)
		}
		if rec.h.Type != test.recType {
			t.Errorf("%s: got type %d expected %d", test.desc, rec.h.Type, test.recType)
			continue
		}
		if rec.h.Id != test.reqId {
			t.Errorf("%s: got request ID %d expected %d", test.desc, rec.h.Id, test.reqId)
			continue
		}

func TestToAPIVersionAndKind(t *testing.T) {
	tests := []struct {
		desc         string
		input        GroupVersionKind
		GroupVersion string
		Kind         string
	}{
		{
			desc:         "gvk object is not empty",
			input:        GroupVersionKind{Version: "V1", Kind: "pod"},
			GroupVersion: "V1",
			Kind:         "pod",
		},
		{
			desc:         "gvk object is empty",
			input:        GroupVersionKind{},

		"apiextensions_apiserver_validation_ratcheting_seconds",
	}

	testCases := []struct {
		desc   string
		obj    *unstructured.Unstructured
		old    *unstructured.Unstructured
		schema apiextensions.JSONSchemaProps
		iters  int // how many times to validate the same update before checking metric
		want   string
	}{
		{
			desc: "valid noop update",
			obj: &unstructured.Unstructured{
				Object: map[string]interface{}{

	for _, f := range fixes {
		if f.disabled {
			fmt.Fprintf(os.Stderr, "\n%s (disabled)\n", f.name)
		} else {
			fmt.Fprintf(os.Stderr, "\n%s\n", f.name)
		}
		desc := strings.TrimSpace(f.desc)
		desc = strings.ReplaceAll(desc, "\n", "\n\t")
		fmt.Fprintf(os.Stderr, "\t%s\n", desc)
	}
	os.Exit(2)
}

func main() {
	telemetry.Start()
	flag.Usage = usage
	flag.Parse()
	telemetry.Inc("fix/invocations")

			wantErr:     "rpc error: code = DeadlineExceeded desc = context deadline exceeded",
		},
		{
			desc:               "timeout zero but kms-plugin already up - still failure - zero timeout is an invalid value",
			callTimeout:        0 * time.Second,
			pluginDelay:        0 * time.Second,
			kubeAPIServerDelay: 2 * time.Second,
			wantErr:            "rpc error: code = DeadlineExceeded desc = context deadline exceeded",
		},
		{

		pkey = parent.key
	} else {
		pcert = tmpl
		pkey = key
	}

	var pub interface{}
	var desc string
	switch k := key.(type) {
	case *rsa.PrivateKey:
		pub = &k.PublicKey
		desc = fmt.Sprintf("RSA-%d", k.N.BitLen())
	case *ecdsa.PrivateKey:
		pub = &k.PublicKey
		desc = "ECDSA-" + k.Curve.Params().Name
	default:
		t.Fatalf("invalid key %T", key)
	}

func TestStat(t *testing.T) {
	check := func(desc string, info FileInfo, err error) {
		t.Helper()
		if err != nil || info == nil || info.Mode() != 0456 {
			infoStr := "<nil>"
			if info != nil {
				infoStr = fmt.Sprintf("FileInfo(Mode: %#o)", info.Mode())
			}
			t.Fatalf("Stat(%s) = %v, %v, want Mode:0456, nil", desc, infoStr, err)
		}
	}

	// Test that Stat uses the method when present.

func TestMonitorShutdown(t *testing.T) {
	var tests = []struct {
		desc           string
		shutdownActive bool
	}{
		{
			desc:           "shutdown is active",
			shutdownActive: true,
		},
		{
			desc:           "shutdown is not active",
			shutdownActive: false,
		},
	}

	for _, tc := range tests {
		tc := tc
		t.Run(tc.desc, func(t *testing.T) {
			fakeSystemBus := &fakeSystemDBus{}