expectErr: true,
			expectVal: defaultIPPort,
		},
		{
			desc:      "valid ipv6 1",
			argc:      "blah --ipport=::1",
			expectVal: "::1",
		},
		{
			desc:      "valid ipv6 2",
			argc:      "blah --ipport=::",
			expectVal: "::",
		},
		{
			desc:      "valid ipv6 with port",
			argc:      "blah --ipport=[::1]:8080",
			expectVal: "[::1]:8080",
		},
		{

        {
            "detail": [
                {
                    "type": "float_parsing",
                    "loc": ["body", "price"],
                    "msg": "Input should be a valid number, unable to parse string as a number",
                    "input": "twenty",
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {

        {
            "detail": [
                {
                    "type": "float_parsing",
                    "loc": ["body", "price"],
                    "msg": "Input should be a valid number, unable to parse string as a number",
                    "input": "twenty",
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {

					Protocol: protocolPtr(api.ProtocolTCP),
				}},
				Endpoints: []discovery.Endpoint{{
					Addresses: generateIPAddresses(1),
					Hostname:  utilpointer.String("valid-123"),
					NodeName:  utilpointer.String("valid-node-name"),
				}},
			},
		},

		// expected failures
		"bad-node-name": {
			expectedErrors: 1,
			endpointSlice: &discovery.EndpointSlice{
				ObjectMeta:  standardMeta,

				return claim
			},
		},
		"valid-add-allocation": {
			oldClaim: validClaim,
			update: func(claim *resource.ResourceClaim) *resource.ResourceClaim {
				claim.Status.DriverName = "valid"
				claim.Status.Allocation = &resource.AllocationResult{
					ResourceHandles: []resource.ResourceHandle{
						{
							DriverName: "valid",

    }

    def "returns parameter invalid when more than one getter for property"() {
        when:
        ToolingParameterProxy.validateParameter(InvalidParameter7)

        then:
        IllegalArgumentException e = thrown()

func (c *StandardClaims) SetAccessKey(accessKey string) {
	c.Subject = accessKey
	c.AccessKey = accessKey
}

// Valid - implements https://godoc.org/github.com/golang-jwt/jwt#Claims compatible
// claims interface, additionally validates "accessKey" fields.
func (c *StandardClaims) Valid() error {
	if err := c.StandardClaims.Valid(); err != nil {
		return err
	}

	if c.AccessKey == "" && c.Subject == "" {

				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,
		},
		{

			expectedPostCleanFile:  testDataDir + "/expected/minikube_cni.conflist.clean",
			cniConfDirOrderedFiles: []string{"minikube_cni.conf", "calico.conflist"},
		},
		{
			name:                   "Skip non-json file for first valid .conf file",
			chainedCNIPlugin:       true,
			resultFileName:         "01-minikube_cni.conflist",
			expectedOutputFile:     testDataDir + "/expected/minikube_cni.conflist.expected",

	test := genericregistrytest.New(t, storage.Store)
	test.TestGet(newControllerRevision("valid", metav1.NamespaceDefault, newObject(), 0))
}

func TestList(t *testing.T) {
	storage, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store)
	test.TestList(newControllerRevision("valid", metav1.NamespaceDefault, newObject(), 0))
}