"description": "current contains the current value for the given metric"
          },
          "metric": {
            "allOf": [
              {
                "$ref": "#/components/schemas/io.k8s.api.autoscaling.v2.MetricIdentifier"
              }
            ],
            "default": {},
            "description": "metric identifies the target metric by name and selector"
          }
        },

		if err := testutil.GatherAndCompare(legacyregistry.DefaultGatherer, strings.NewReader(expectedValue), metrics...); err != nil {
			t.Fatal(err)
		}
		authorizationDecisionsTotal.Reset()
	}

	// no-opinion emits no metric
	{
		dummyAuthorizer.decision = authorizer.DecisionNoOpinion
		_, _, _ = a.Authorize(context.Background(), nil)
		_, _, _ = a.Authorize(context.Background(), nil)
		expectedValue := prefix + `
		`

		}),
	)
)

var (
	envoyFilterStatusMap = map[string]map[string]bool{} // Map of Envoy filter name, patch and status.
	envoyFilterMutex     sync.RWMutex
)

// IncrementEnvoyFilterMetric increments filter metric.
func IncrementEnvoyFilterMetric(name string, pt PatchType, applied bool) {
	if !features.EnableEnvoyFilterMetrics {
		return
	}
	envoyFilterMutex.Lock()
	defer envoyFilterMutex.Unlock()

					matchedTarget = &tc.metricsTarget[i]
				}
			}
		}
		assert.NotNil(t, matchedTarget, "this request should have matched one of the metric specs")
		assert.Equal(t, "qps", getForAction.GetMetricName(), "the metric name requested should have been qps, as specified in the metric spec")

		metrics.Items = []cmapi.MetricValue{
			{
				DescribedObject: v1.ObjectReference{

					// Next, get all matches.
					// This is a bit funky because the matches are oneof of ENUM and customer metric. We normalize
					// these to strings, so we may end up with a list like [REQUEST_COUNT, my-customer-metric].
					// TODO: we always flatten ALL_METRICS into each metric mode. For some stats providers (prometheus),
					// we are able to apply overrides to all metrics directly rather than duplicating the config.

 *
 * Promoting the stability level of the metric is a responsibility of the component owner, since it
 * involves explicitly acknowledging support for the metric across multiple releases, in accordance with
 * the metric stability policy.
 */
var (
	listCacheCount = compbasemetrics.NewCounterVec(
		&compbasemetrics.CounterOpts{

func TestPanicEvent(t *testing.T) {
	// Use a sync event for this because it doesn't have any extra metadata.
	ev := syncEvent(nil, 0)

	mustPanic(t, func() {
		_ = ev.Range()
	})
	mustPanic(t, func() {
		_ = ev.Metric()
	})
	mustPanic(t, func() {
		_ = ev.Log()
	})
	mustPanic(t, func() {
		_ = ev.Task()
	})
	mustPanic(t, func() {
		_ = ev.Region()
	})
	mustPanic(t, func() {
		_ = ev.Label()
	})

	if n.client != nil {
		counter, err := n.client.Get(n.counter)
		if err != nil {
			klog.ErrorS(err, "failed to collect nfacct counter", "counter", n.counter)
		} else {
			metric, err := metrics.NewConstMetric(n.description, metrics.CounterValue, float64(counter.Packets))
			if err != nil {
				klog.ErrorS(err, "failed to create constant metric")
			} else {
				ch <- metric

	for _, forwarder := range c.forwarder {
		forwarder.Close()
	}
	return nil
}

type Query struct {
	Metric      string
	Aggregation string
	Labels      map[string]string
}

func (q Query) String() string {
	query := q.Metric + `{`

	keys := []string{}
	for k := range q.Labels {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	for _, k := range keys {

	Succeeded = "succeeded"
	Failed    = "failed"

	// Possible values for "event"  label in the terminated_pods_tracking_finalizer
	// metric.
	Add    = "add"
	Delete = "delete"

	// Possible values for "reason" label in the job_pods_creation_total metric.

	PodCreateNew                   = "new"
	PodRecreateTerminatingOrFailed = "recreate_terminating_or_failed"