},
		{ // secret invalid
			args:           strings.Split("secret invalid", " "),
			expectedString: "unable to retrieve Pod: pods \"invalid\" not found",
			wantException:  true, // "istioctl proxy-config secret invalid" should fail
		},
		{ // endpoint invalid
			args:           strings.Split("endpoint invalid", " "),
			expectedString: "unable to retrieve Pod: pods \"invalid\" not found",

					},
					NodeName: "valid-node",
				},
			},
			true,
		},
		{
			"invalid attacher name",
			&storage.VolumeAttachment{
				ObjectMeta: metav1.ObjectMeta{
					Name: "foo",
				},
				Spec: storage.VolumeAttachmentSpec{
					Attacher: "invalid!@#$%^&*()",
					Source: storage.VolumeAttachmentSource{
						PersistentVolumeName: &validPVName,
					},
					NodeName: "valid-node",
				},
			},

// Go generate should process this file with GOPACKAGE=c

//go:generate echo Success $GOPACKAGE
package c
// Invalid package clause, should be ignored:
package cinvalid
//go:generate echo Success $GOPACKAGE

-- inconsistent/d.go --
// Go file with invalid package name.
// Go generate should ignore this file.

package +d+
//go:generate echo Fail $GOPACKAGE

-- syntax/a.go --

		scheduling: &node.Scheduling{},
	}, {
		name: "invalid nodeSelector",
		scheduling: &node.Scheduling{
			NodeSelector: map[string]string{"not a valid key!!!": "nope"},
		},
		expectErrs: 1,
	}, {
		name: "invalid toleration",
		scheduling: &node.Scheduling{
			Tolerations: []core.Toleration{{
				Key:      "valid",
				Operator: core.TolerationOpExists,
				Effect:   core.TaintEffectNoSchedule,
			}, {

										},
									},
									{
										AllocationResultModel: resource.AllocationResultModel{}, // invalid
									},
								},
							},
						},
					},
				}
				return claim
			},
		},
		"invalid-duplicated-data": {
			wantFailures: field.ErrorList{field.Invalid(field.NewPath("status", "allocation", "resourceHandles").Index(0), nil, "data and structuredData are mutually exclusive")},

		},
		{
			desc:      "invalid input with invalid limit",
			argc:      "blah --reserved-memory=0:memory=",
			expectVal: nil,
			expectErr: true,
		},
		{
			desc:      "invalid input with invalid memory type",
			argc:      "blah --reserved-memory=0:type=1Gi",
			expectVal: nil,
			expectErr: true,
		},
		{
			desc:      "invalid input with invalid quantity",

	if err != nil {
		allErrs = append(allErrs, field.Invalid(fldPath, input, "must be IP:port"))
		return allErrs
	}

	if ip := netutils.ParseIPSloppy(hostIP); ip == nil {
		allErrs = append(allErrs, field.Invalid(fldPath, hostIP, "must be a valid IP"))
	}

	if p, err := strconv.Atoi(port); err != nil {
		allErrs = append(allErrs, field.Invalid(fldPath, port, "must be a valid port"))
	} else if p < 1 || p > 65535 {

- Method broken3(java.lang.String) is not a valid rule method: A method annotated with @Rules must have void return type.
- Method broken3(java.lang.String) is not a valid rule method: A method annotated with @Rules must have at least two parameters

		defer tmpl.muFuncs.RUnlock()
		if fn := tmpl.execFuncs[name]; fn.IsValid() {
			return fn, false, true
		}
	}
	if fn := builtinFuncs()[name]; fn.IsValid() {
		return fn, true, true
	}
	return reflect.Value{}, false, false
}

// prepareArg checks if value can be used as an argument of type argType, and
// converts an invalid value to appropriate zero if possible.

Adrian Kuegel <******@****.***> 1648469008 -0700