expectedMetric = `
# HELP kubelet_running_pods [ALPHA] Number of pods that have a running pod sandbox
# TYPE kubelet_running_pods gauge
kubelet_running_pods 3
`
	testMetric(t, expectedMetric, metrics.RunningPodCount.FQName())
}

func testMetric(t *testing.T, expectedMetric string, metricName string) {
	err := testutil.GatherAndCompare(metrics.GetGather(), strings.NewReader(expectedMetric), metricName)
	if err != nil {

				}
				drainAllWorkers(podWorkers)
				tt.wantWorkerAfterRetry(t, podWorkers, processed)

				for k, v := range tt.expectMetricsAfterRetry {
					testMetric(t, k, v)
				}
			}
		})
	}
}

func testMetric(t *testing.T, metricName string, expectedMetric string) {
	t.Helper()
	err := testutil.GatherAndCompare(metrics.GetGather(), strings.NewReader(expectedMetric), metricName)

	clusterIPAvailable.Reset()
	clusterIPAllocations.Reset()
	clusterIPAllocationErrors.Reset()
}

type testMetrics struct {
	free      float64
	used      float64
	allocated float64
	errors    float64
}

func expectMetrics(t *testing.T, label string, em testMetrics) {
	var m testMetrics
	var err error
	m.free, err = testutil.GetGaugeMetricValue(clusterIPAvailable.WithLabelValues(label))
	if err != nil {

	Reset() []metrics.Registerable
}

func TestMetrics(t *testing.T) {
	featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, apiextensionsfeatures.CRDValidationRatcheting, true)

	// Wrap metric to keep time constant
	testMetrics := &fakeMetrics{original: validation.Metrics}
	validation.Metrics = testMetrics
	defer func() {
		validation.Metrics = testMetrics.original
	}()

	metricNames := []string{

	nodePortAvailable.Set(0)
	nodePortAllocations.Reset()
	nodePortAllocationErrors.Reset()
}

type testMetrics struct {
	free      float64
	used      float64
	allocated float64
	errors    float64
}

func expectMetrics(t *testing.T, em testMetrics) {
	var m testMetrics
	var err error
	m.free, err = testutil.GetGaugeMetricValue(nodePortAvailable)
	if err != nil {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package auth

import (
	"reflect"
	"testing"
)

var testNetrc = `
machine incomplete
password none

machine api.github.com
  login user
  password pwd

machine incomlete.host
  login justlogin

machine test.host
login user2
password pwd2

	requestsSameRegion  uint64
	requestsOtherRegion uint64
}

func (tm testMetrics) totalRequests() uint64 {
	return tm.requestsSameZone + tm.requestsSameRegion + tm.requestsOtherRegion
}

func (tm testMetrics) sameZonePercent() float64 {
	return (float64(tm.requestsSameZone) / float64(tm.totalRequests())) * 100
}

func (tm testMetrics) sameRegionPercent() float64 {

	cidrSetAllocationTriesPerRequest.Delete(labels)
	cidrSetMaxCidrs.Delete(labels)
}

type testMetrics struct {
	usage      float64
	allocs     float64
	releases   float64
	allocTries float64
	max        float64
}

func expectMetrics(t *testing.T, label string, em testMetrics) {
	var m testMetrics
	var err error
	m.usage, err = testutil.GetGaugeMetricValue(cidrSetUsage.WithLabelValues(label))

	nodePortRepairPortErrors.Reset()
	nodePortRepairReconcileErrors.Reset()
}

type testMetrics struct {
	leak       float64
	repair     float64
	outOfRange float64
	duplicate  float64
	unknown    float64
	full       float64
}

func expectMetrics(t *testing.T, em testMetrics) {
	var m testMetrics
	var err error

	}
	em := testMetrics{
		leak:       0,
		repair:     5,
		outOfRange: 6,
		duplicate:  3,
		unknown:    0,
		invalid:    0,
		full:       0,
	}
	expectMetrics(t, em)
}

// Metrics helpers
func clearMetrics() {
	clusterIPRepairIPErrors.Reset()
	clusterIPRepairReconcileErrors.Reset()
}

type testMetrics struct {
	leak       float64