APIVersion: version,
			Operation:  "Update",
			FieldsType: "FieldsV1",
			FieldsV1:   fields,
			Time:       &metav1.Time{Time: time.Time{}.Add(time.Hour * time.Duration(order))},
		}
	}

	testCases := []struct {
		name     string
		input    []metav1.ManagedFieldsEntry
		expected []metav1.ManagedFieldsEntry
	}{
		{
			name: "one version, no ancient changes",
			input: []metav1.ManagedFieldsEntry{

kind: KubeSchedulerConfiguration
clientConnection:
  kubeconfig: '%s'
leaderElection:
  leaseDuration: 1h
`, configKubeconfig)), os.FileMode(0600)); err != nil {
		t.Fatal(err)
	}

	testcases := []struct {
		name                 string
		flags                []string
		registryOptions      []Option
		restoreFeatures      map[featuregate.Feature]bool
		wantPlugins          map[string]*config.Plugins

	}
	return nil
}

func TestGetNodeIPs(t *testing.T) {
	type expectation struct {
		matchAll bool
		ips      sets.Set[string]
	}

	testCases := []struct {
		name          string
		cidrs         []string
		itfAddrsPairs []InterfaceAddrsPair
		expected      map[v1.IPFamily]expectation
	}{
		{
			name:  "IPv4 single",
			cidrs: []string{"10.20.30.0/24"},

	}
	errs := StatusStrategy.ValidateUpdate(ctx, newPdb, oldPdb)
	if len(errs) != 0 {
		t.Errorf("Unexpected error %v", errs)
	}
}

func TestPodDisruptionBudgetStatusValidationByApiVersion(t *testing.T) {
	testCases := map[string]struct {
		apiVersion string
		validation bool
	}{
		"policy/v1beta1 should not do update validation": {
			apiVersion: "v1beta1",
			validation: false,
		},

func TestDecode(t *testing.T) {
	gvk1 := &schema.GroupVersionKind{Kind: "Test", Group: "other", Version: "blah"}
	decodable1 := &testDecodable{}
	decodable2 := &testDecodable{}
	decodable3 := &testDecodable{}

	testCases := []struct {
		serializer runtime.Serializer
		convertor  runtime.ObjectConvertor
		creater    runtime.ObjectCreater
		typer      runtime.ObjectTyper
		defaulter  runtime.ObjectDefaulter
		yaml       bool

		t.Helper()
		m := map[string]interface{}{}
		if err := json.Unmarshal([]byte(data), &m); err != nil {
			t.Fatal(err)
		}
		return &unstructured.Unstructured{Object: m}
	}
	testcases := []struct {
		Name          string
		Attrs         *VersionedAttributes
		GVK           schema.GroupVersionKind
		ExpectedAttrs *VersionedAttributes
	}{
		{
			Name: "noop",

			},
		},
	}

	for _, testCase := range testCases {
		t.Run(testCase.description, func(t *testing.T) {
			featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, pkgfeatures.CPUManagerPolicyAlphaOptions, true)

			var activePods []*v1.Pod
			for p := range testCase.assignments {
				pod := v1.Pod{}
				pod.UID = types.UID(p)
				for c := range testCase.assignments[p] {

			}
		},
	}}
	for index, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			allErrs := ValidateLabelSelector(testCase.labelSelector, LabelSelectorValidationOptions{false}, field.NewPath("labelSelector"))
			if len(allErrs) != testCase.wantErrorNumber {
				t.Errorf("case[%d]: expected failure", index)
			}
			if len(allErrs) >= 1 && testCase.validateErrs != nil {

// proposal go.dev/issue/50429
func TestRangePos(t *testing.T) {
	testcases := []string{
		"package p; func _() { for range x {} }",
		"package p; func _() { for i = range x {} }",
		"package p; func _() { for i := range x {} }",
		"package p; func _() { for k, v = range x {} }",
		"package p; func _() { for k, v := range x {} }",
	}

	for _, src := range testcases {
		fset := token.NewFileSet()

			items:             []runtime.Object{},
		},
	}

	for testName, testCase := range testCases {
		kubeClient := fake.NewSimpleClientset(&testCase.quota)
		listersForResourceConfig := map[schema.GroupVersionResource]cache.GenericLister{
			testCase.gvr:      newGenericLister(testCase.gvr.GroupResource(), testCase.items),
			testCase.errorGVR: newErrorLister(),
		}