}

    def "accepts valid type"() {
        def ruleValidator = new DefaultRuleActionValidator(String)
        def ruleAction = Stub(RuleAction) {
            getInputTypes() >> { [String] }
        }

        expect:
        ruleValidator.validate(ruleAction) == ruleAction
    }

    def "accepts valid type with multiple valid types"() {

        nonHeapStats.maxSizeInBytes == 1000
        nonHeapStats.usedPercent == 70
    }

    def "reports invalid when maximum memory cannot be determined"() {
        expect:
        !stats.valid
        stats.maxSizeInBytes == -1

        where:
        stats << [
                GarbageCollectionStats.forHeap(withoutMaxMemory(heapEvents)),
                GarbageCollectionStats.forNonHeap(withoutMaxMemory(nonHeapEvents))

	}

	handles.Store(h, v)
	return Handle(h)
}

// Value returns the associated Go value for a valid handle.
//
// The method panics if the handle is invalid.
func (h Handle) Value() any {
	v, ok := handles.Load(uintptr(h))
	if !ok {
		panic("runtime/cgo: misuse of an invalid Handle")
	}
	return v
}

// Delete invalidates a handle. This method should only be called once

			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

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

			expr:         `isIP("192.168.0.1.0")`,
			expectResult: falseVal,
		},
		{
			name:         "ip.isCanonical valid ipv4",
			expr:         `ip.isCanonical("127.0.0.1")`,
			expectResult: trueVal,
		},
		{
			name:             "ip.isCanonical invalid ipv4",
			expr:             `ip.isCanonical("127.0.0.1.0")`,

        failure.assertHasCause "Failed to publish publication 'maven' to repository 'maven'"
        failure.assertHasCause "Invalid publication 'maven': groupId cannot be empty"
    }

    def "fails with reasonable error message for invalid #invalidComponent name"() {
        settingsFile << "rootProject.name = 'invalid'"
        buildFile << """
            apply plugin: 'maven-publish'
            apply plugin: 'java'

    }

    def "should report invalid uri"() {
        when:
        s3ConnectionProperties.configureEndpoint('httpdasd%:/ads')
        then:
        def ex = thrown(IllegalArgumentException)
        ex.message == "System property [org.gradle.s3.endpoint=httpdasd%:/ads]  must be a valid URI"
    }

    def "should allow case insensitive schemes"() {
        expect:

// Invalid versions, including the empty string, compare less than
// valid versions and equal to each other.
// The language version "go1.21" compares less than the
// release candidate and eventual releases "go1.21rc1" and "go1.21.0".
func Compare(x, y string) int {
	return gover.Compare(stripGo(x), stripGo(y))
}

// IsValid reports whether the version x is valid.
func IsValid(x string) bool {

    }

    def "prints helpful error message on invalid version argument format: #badVersion"() {
        given:
        prepareWrapper()

        expect:
        def failure = wrapperExecuter.withTasks("wrapper", "--gradle-version", badVersion).runWithFailure()

        and:
        failure.assertHasDescription("Invalid version specified for argument '--gradle-version'")