targetPortFunc:  func(nw string) int { return 0 },
					networkNameFunc: func(nw string) string { return nw + "-manual-discovery" },
				},
			}

			for _, tc := range testCases {
				tc := tc
				t.NewSubTest(tc.name).Run(func(t framework.TestContext) {
					for network, networkClusters := range t.Clusters().ByNetwork() {
						weClusters := t.Clusters().Configs(networkClusters...)

			accessor.liveLookupCache = liveLookupCache

			for _, q := range tc.cacheInput {
				quota := q
				liveLookupCache.Add(quota.Namespace, liveLookupEntry{expiry: time.Now().Add(tc.ttl), items: []*corev1.ResourceQuota{quota}})
			}

			quotas, err := accessor.GetQuotas(tc.namespace)
			if err != nil {
				t.Errorf("Unexpected error: %v", err)
			}

			if tc.expectedQuota != nil {
				if count := len(quotas); count != 1 {

		},
	}

	for _, tc := range testcases {
		t.Run(tc.name, func(t *testing.T) {
			config, err := LoadFromData(tc.data)
			if err != nil {
				if len(tc.expectErr) == 0 {
					t.Fatalf("unexpected error: %v", err)
				}
				if !strings.Contains(err.Error(), tc.expectErr) {
					t.Fatalf("unexpected error: %v", err)
				}
				return
			}
			if len(tc.expectErr) > 0 {

					},
				},
			},
			path: "/metrics",
			port: 15020,
		},
	}

	for _, tc := range cases {
		t.Run(tc.pod.Name, func(t *testing.T) {
			path, port, err := PrometheusPathAndPort(tc.pod)
			assert.NoError(t, err)
			assert.Equal(t, tc.path, path)
			assert.Equal(t, tc.port, port)
		})
	}

			{path: "\\var\\.\\lib\\something", expected: false},
			{path: "C:\\var\\.\\lib\\something", expected: false},
		}...)
	}

	for _, tc := range cases {
		actual := IsPathClean(tc.path)
		if actual != tc.expected {
			t.Errorf("actual: %t, expected: %t, for path: %s\n", actual, tc.expected, tc.path)
		}
	}

					to:         apps.NS[0].B,
				},
			}

			for _, tc := range testCases {
				t.NewSubTest(tc.name).Run(func(t framework.TestContext) {
					tc.from[0].CallOrFail(t, echo.CallOptions{
						To: tc.to,
						Port: echo.Port{
							Protocol:    protocol.HTTP,
							ServicePort: 80,
						},
						Check: check.And(
							check.ErrorOrStatus(tc.statusCode),
						),
					})
				})
			}
		})
}

						to     echo.Instances
						expect bool
					}{
						{
							from:   client,
							to:     serverNakedFooAlt,
							expect: true,
						},
					}

					for _, tc := range cases {
						verify(t, tc.from, tc.to, scheme.HTTP, tc.expect)
					}
				})
			}
		})

			expectedValue: true,
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			_, option := mutation.NewTypeProviderAndEnvOption(&TypeResolver{})
			env := mustCreateEnv(t, option)
			ast, issues := env.Compile(tc.expression)
			if issues != nil {
				t.Fatalf("unexpected issues during compilation: %v", issues)
			}

	}
	RegisterMetrics()

	for _, tc := range testCases {
		authenticationConfigAutomaticReloadLastTimestampSeconds.Reset()
		authenticationConfigAutomaticReloadLastTimestampSeconds.WithLabelValues(tc.resultLabel, testAPIServerIDHash).Set(float64(tc.timestamp))

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

			tc.percentage, actualPercent, tc.threshold, testID)
		log.Infof("%v", err)
		merr = multierror.Append(merr, err)
	} else {
		log.Infof("Got expected mirror traffic. Expected %g%%, got %.1f%% (threshold: %g%%, , testID: %s)",
			tc.percentage, actualPercent, tc.threshold, testID)
	}

	return merr.ErrorOrNil()
}