Completions:    pointer.Int32(1_000_000_000),
			},
		},
		"invalid PodTemplate": {
			spec: &batch.JobSpec{
				CompletionMode: completionModePtr(batch.NonIndexedCompletion),
				Template: core.PodTemplateSpec{
					Spec: core.PodSpec{ImagePullSecrets: []core.LocalObjectReference{{Name: ""}}},
				},
			},
			wantWarningsCount: 1,
		},
		"valid Indexed low completions low parallelism": {
			spec: &batch.JobSpec{

			check.recordDef(ident, fld)
		}
	}

	// addInvalid adds an embedded field of invalid type to the struct for
	// fields with errors; this keeps the number of struct fields in sync
	// with the source as long as the fields are _ or have different names
	// (go.dev/issue/25627).
	addInvalid := func(ident *syntax.Name) {
		typ = Typ[Invalid]
		tag = ""
		add(ident, true)
	}

	var prev syntax.Expr

			valid:       true,
		},
		{
			description: "valid name with namespace",
			name:        "testNamespace/testName",
			want:        "testNamespace/testName",
			valid:       true,
		},
	}
	for _, s := range steps {
		t.Run(s.description, func(tt *testing.T) {
			n, err := ParseFullName(s.name)
			if err == nil && n.String() != s.want {
				tt.Fatalf("unexpected name: %v", n)
			}
			if s.valid {

		name       string
		newHistory *apps.ControllerRevision
		oldHistory *apps.ControllerRevision
		isValid    bool
	}{
		{
			name:       "valid",
			newHistory: valid,
			oldHistory: valid,
			isValid:    true,
		},
		{
			name:       "changed data",
			newHistory: changedData,
			oldHistory: valid,
			isValid:    false,
		},
		{
			name:       "changed revision",
			newHistory: changedRevision,

	tests := []struct {
		desc   string
		in     string
		expect bool
	}{
		{
			desc:   "valid",
			in:     "[1:2]",
			expect: true,
		},
		{
			desc:   "invalid",
			in:     "[:2]",
			expect: false,
		},
		{
			desc:   "invalid-2",
			in:     "[1:]",
			expect: false,
		},
		{
			desc:   "empty",
			in:     "",
			expect: false,
		},

	pvName := "foo"
	test.TestCreate(
		// valid
		volumeAttachment,
		// invalid
		&storageapi.VolumeAttachment{
			ObjectMeta: metav1.ObjectMeta{Name: "*BadName!"},
			Spec: storageapi.VolumeAttachmentSpec{
				Attacher: "invalid-attacher-!@#$%^&*()",
				Source: storageapi.VolumeAttachmentSource{
					PersistentVolumeName: &pvName,
				},
				NodeName: "invalid-node-!@#$%^&*()",
			},
		},
	)
}

			outputFormat:  "invalid",
			expectNoMatch: true,
		},
		{
			name:          "printer should not match on any other format supported by another printer",
			outputFormat:  "go-template",
			expectNoMatch: true,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			printFlags := NamePrintFlags{
				Operation: tc.operation,
			}

				Object:    runtime.RawExtension{Raw: valid},
				Operation: kube.Create,
			},
			allowed: true,
		},
		{
			name:  "valid update",
			admit: wh.validate,
			in: &kube.AdmissionRequest{
				Kind:      metav1.GroupVersionKind{Kind: collections.Mock.Kind()},
				Object:    runtime.RawExtension{Raw: valid},
				Operation: kube.Update,
			},
			allowed: true,
		},
		{

			expectedErr:    nil,
			shouldPass:     true,
			expectedConfig: actualKMSConfig,
			keyID:          "my-minio-key",
		},
		// 3. Invalid - more than one rule
		{

		},
		"invalid-name-update": {
			oldResourceSlice: validResourceSlice,
			update: func(slice *resource.ResourceSlice) *resource.ResourceSlice {
				slice.Name += "-update"
				return slice
			},
			wantFailures: field.ErrorList{field.Invalid(field.NewPath("metadata", "name"), name+"-update", "field is immutable")},
		},
		"invalid-update-nodename": {