cases := []struct {
		name string
		cidr string
	}{
		{
			name: "invalid IPv4 loopback CIDR",
			cidr: "192.168.1.1/24",
		},
		{
			name: "invalid CIDR with mask below range",
			cidr: "10.0.0.1/7",
		},
		{
			name: "invalid CIDR with mask above range",
			cidr: "172.16.0.1/40",
		},
	}

	for _, tc := range cases {

	test := genericregistrytest.New(t, storage.Store)
	resourceClass := validNewResourceClassParameters("foo")
	resourceClass.ObjectMeta = metav1.ObjectMeta{}
	test.TestCreate(
		// valid
		resourceClass,
		// invalid
		&resource.ResourceClassParameters{
			ObjectMeta: metav1.ObjectMeta{Name: "*BadName!"},
		},
	)
}

func TestUpdate(t *testing.T) {
	storage, server := newStorage(t)

				Arch:            "amd64",
			},
			output:      doNothing,
			errExpected: false,
		},
		{
			name:        "invalid syntax, passing nil",
			template:    invalidTmpl1,
			data:        nil,
			output:      "",
			errExpected: true,
		},
		{
			name:        "invalid syntax",
			template:    invalidTmpl2,
			data:        struct{}{},
			output:      "",
			errExpected: true,
		},
	}

    def mockLogger = Mock(Logger)

    def 'reporter logs only invalid installations'() {
        given:
        def reporter = new InvalidInstallationWarningReporter(mockLogger)
        def location = InstallationLocation.userDefined(new File("_"), "_")
        def metadata = Mock(JvmInstallationMetadata) {
            isValidInstallation() >> isValid
        }

        when:
        reporter.accept(location, metadata)

				allErrs = append(allErrs, field.Invalid(pth.Child("default"), s.Default.Object, fmt.Sprintf("must result in valid metadata: %v", err)))
			} else if errs := schemaobjectmeta.Validate(nil, obj, rootSchema, true); len(errs) > 0 {
				allErrs = append(allErrs, field.Invalid(pth.Child("default"), s.Default.Object, fmt.Sprintf("must result in valid metadata: %v", errs.ToAggregate())))

        failure.assertHasFileName("Build file '$buildFile.path'")
        failure.assertHasLineNumber(lines + 3)
        failureHasCause("""Type BadRuleSource is not a valid rule source:
- Method process(java.lang.String) is not a valid rule method: First parameter of a rule method must be of type org.gradle.api.artifacts.ComponentMetadataDetails""")

    }

		}
		if len(terms) >= maxTermCount {
			if isValid(u) {
				check.errorf(x, InvalidUnion, "cannot handle more than %d union terms (implementation limitation)", maxTermCount)
				u = Typ[Invalid]
			}
		} else {
			terms = append(terms, term)
			u = &Union{terms}
		}

		if i > 0 {
			check.recordTypeAndValue(blist[i-1], typexpr, u, nil)
		}
	}

	if !isValid(u) {
		return u
	}

    def "invalid JDK is cached only for current build if in daemon"() {
        // Require a different JDK to be able to find the logs of its probing for system properties
        def existingJdk = AvailableJavaHomes.differentJdk

        // Use two invalid installation paths to verify that the implementation reports a warning on each of them

        metadata        | message
        "branch ''"     | "Invalid publication 'ivy': branch cannot be an empty string. Use null instead"
        "branch 'a\tb'" | "Invalid publication 'ivy': branch cannot contain ISO control character '\\u0009'"
        "status ''"     | "Invalid publication 'ivy': status cannot be an empty string. Use null instead"
        "status 'a\tb'" | "Invalid publication 'ivy': status cannot contain ISO control character '\\u0009'"

                                                      "Method theRule(java.util.List<java.lang.Integer>) is not a valid rule method: First parameter of a rule method must be of type java.util.List<java.lang.String>",