defer cleanup(t, m)
	featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.SidecarContainers, true)
	if err := expectProbes(m, nil); err != nil {
		t.Error(err)
	}

	testCases := []struct {
		desc                    string
		probePaths              []probeKey
		enableSidecarContainers bool
	}{
		{
			desc:                    "pod with sidecar (no sidecar containers feature enabled)",

	emptyv1beta1Patch := admissionv1beta1.PatchType("")
	emptyv1Patch := admissionv1.PatchType("")

	invalidv1beta1Patch := admissionv1beta1.PatchType("Foo")
	invalidv1Patch := admissionv1.PatchType("Foo")

	testcases := []struct {
		name     string
		uid      types.UID
		mutating bool
		review   runtime.Object

		expectAuditAnnotations map[string]string
		expectAllowed          bool
		expectPatch            []byte

				localErr := &bytes.Buffer{}

				requestReceived := make(chan struct{})
				server := httptest.NewServer(fakeServer(t, requestReceived, name, exec, testCase.Stdin, testCase.Stdout, testCase.Stderr, testCase.Error, testCase.Tty, testCase.MessageCount, testCase.ServerProtocols))
				defer server.Close()

				url, _ := url.ParseRequestURI(server.URL)
				config := restclient.ClientContentConfig{

			t.Fatalf("error: expected = <nil>, got = %v", err)
		}
		if testCase.expectedErr && err == nil {
			t.Fatal("error: expected err, got = <nil>")
		}
		if len(certs) != testCase.expectedResultLen {
			t.Fatalf("certs: expected = %v, got = %v", testCase.expectedResultLen, len(certs))
		}
	}
}

func TestLoadX509KeyPair(t *testing.T) {
	t.Cleanup(func() {
		os.Unsetenv(EnvCertPassword)

	validation.Metrics = testMetrics
	defer func() {
		validation.Metrics = testMetrics.original
	}()

	metricNames := []string{
		"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

	"sigs.k8s.io/yaml"
)

// TestCodecsDecodePluginConfig tests that embedded plugin args get decoded
// into their appropriate internal types and defaults are applied.
func TestCodecsDecodePluginConfig(t *testing.T) {
	testCases := []struct {
		name         string
		data         []byte
		wantErr      string
		wantProfiles []config.KubeSchedulerProfile
	}{
		// v1 tests
		{
			name: "v1 all plugin args in default profile",

	}

	taintNew := v1.Taint{
		Key:    "foo_1",
		Value:  "bar_1",
		Effect: v1.TaintEffectNoSchedule,
	}

	taintUpdateValue := taint
	taintUpdateValue.Value = "bar_1"

	testcases := []struct {
		name           string
		node           *v1.Node
		taint          *v1.Taint
		expectedUpdate bool
		expectedTaints []v1.Taint
	}{
		{
			name:           "add a new taint",

)

func Test_InsertGetDelete(t *testing.T) {
	testCases := []struct {
		name   string
		prefix netip.Prefix
	}{
		{
			name:   "ipv4",
			prefix: netip.MustParsePrefix("192.168.0.0/24"),
		},
		{
			name:   "ipv6",
			prefix: netip.MustParsePrefix("fd00:1:2:3::/124"),
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			tree := New[int]()

							},
						},
					},
				},
			},
			expectedResult: true,
		},
	}

	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			pod := &v1.Pod{}
			pod.Spec = *testCase.podSpec
			result := HasWindowsHostProcessContainer(pod)
			assert.Equal(t, result, testCase.expectedResult)
		})
	}
}

func TestHashContainerWithoutResources(t *testing.T) {

			watchKey:         "/pods/",
			watcherMaxLimit:  1,
			expectEventCount: 2,
			expectGetCount:   2,
		},
	}

	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			defaultWatcherMaxLimit = testCase.watcherMaxLimit

			origCtx, store, _ := testSetup(t)
			initList, err := initStoreData(origCtx, store)
			if err != nil {
				t.Fatal(err)
			}