// will parse and are tested in name constraint tests at the top of this
	// file.
	badNames := []string{
		"uri:https://example.com./dsf",
		"invalidip:0102",
		"invalidip:0102030405",
	}

	priv, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
	if err != nil {
		panic(err)
	}

	for _, badName := range badNames {

				},
				{
					Key:    "invalid",
					Values: []string{},
				},
			},
			expectErr: true,
		},
		{
			in: []v1.TopologySelectorLabelRequirement{{
				Key:    "/invalidkey",
				Values: []string{"bar", "baz"},
			}},
			expectErr: true,
		},
	}

	for i, tc := range tc {
		out, err := TopologySelectorRequirementsAsSelector(tc.in)
		if err == nil && tc.expectErr {

			t.Errorf("%s", tc.name)
		}
	}
}

func TestIsZeroCIDR(t *testing.T) {
	testCases := []struct {
		name     string
		input    string
		expected bool
	}{
		{
			name:     "invalide cidr",
			input:    "",
			expected: false,
		},
		{
			name:     "ipv4 cidr",
			input:    "172.10.0.0/16",
			expected: false,
		},
		{
			name:     "ipv4 zero cidr",

* **Convertir des données** : depuis la requête vers les types requis.
* **Valider des données** : venant de chaque requête :
    * Générant automatiquement des **erreurs** renvoyées au client quand la donnée est invalide.
* **Documenter** l'API avec OpenAPI :
    * ce qui ensuite utilisé par les interfaces utilisateur automatiques de documentation interactive.

		LoadBalancer: networking.IngressLoadBalancerStatus{
			Ingress: []networking.IngressLoadBalancerIngress{
				{IP: "127.0.0.2", Hostname: "foo.com"},
			},
		},
	}
	invalidIP := newValid()
	invalidIP.Status = networking.IngressStatus{
		LoadBalancer: networking.IngressLoadBalancerStatus{
			Ingress: []networking.IngressLoadBalancerIngress{
				{IP: "abcd", Hostname: "foo.com"},
			},
		},

		}()
	}

	defer func() {
		setDefType(def, res)
	}()

	var cause string
	gtyp := check.genericType(x, &cause)
	if cause != "" {
		check.errorf(x, NotAGenericType, invalidOp+"%s%s (%s)", x, xlist, cause)
	}
	if !isValid(gtyp) {
		return gtyp // error already reported
	}

	// evaluate arguments
	targs := check.typeList(xlist)
	if targs == nil {
		return Typ[Invalid]

		}()
	}

	defer func() {
		setDefType(def, res)
	}()

	var cause string
	gtyp := check.genericType(ix.X, &cause)
	if cause != "" {
		check.errorf(ix.Orig, NotAGenericType, invalidOp+"%s (%s)", ix.Orig, cause)
	}
	if !isValid(gtyp) {
		return gtyp // error already reported
	}

	// evaluate arguments
	targs := check.typeList(ix.Indices)
	if targs == nil {
		return Typ[Invalid]

			{name: "strategic-merge-patch-warn-validation", path: "/namespaces/default/simples/id", verb: "PATCH", data: invalidSMP, queryParams: warnFieldValidation, contentType: "application/strategic-merge-patch+json;...

labels.error_title	=	Erreur
labels.system_error_title	=	Erreur système
labels.contact_site_admin	=	Contactez l'administrateur du site.
labels.request_error_title	=	Mauvaise requête
labels.bad_request	=	Requête invalide pour l'URL.
labels.page_not_found_title	=	Page non trouvée
labels.check_url	=	Vérifiez l'URL.
labels.user_name	=	Nom d'utilisateur
labels.login	=	Connexion
labels.login.placeholder_username	=	Nom d'utilisateur

	cgocall := x.mode == cgofunc

	// a type parameter may be "called" if all types have the same signature
	sig, _ := coreType(x.typ).(*Signature)
	if sig == nil {
		check.errorf(x, InvalidCall, invalidOp+"cannot call non-function %s", x)
		x.mode = invalid
		x.expr = call
		return statement
	}

	// Capture wasGeneric before sig is potentially instantiated below.
	wasGeneric := sig.TypeParams().Len() > 0