}

    def "ignores overridden property getters and setters"() {
        expect:
        def details = ClassInspector.inspect(Overrides)

        def prop = details.getProperty('prop')
        prop.getters.size() == 1
        prop.getters[0].declaringClass == Overrides
        prop.setters.size() == 1
        prop.setters[0].declaringClass == Overrides
    }

            // Do we have an 'is'-getter as well as a 'get'-getter?
            if (previouslySeenBuilder != null) {
                // It is okay to have redundant generated 'is'-getters
                if (generatedMethodDetector.test(metadataBuilder.getter)) {
                    continue;
                }
                // The 'is'-getter is ignored, we can skip it in favor of the 'get'-getter

        '''

        then:
        succeeds "echo"

        and:
        output.contains("name: Alan Turing")
    }

    def "generative getters implemented as default methods cannot call setters"() {
        when:
        file('buildSrc/src/main/java/Rules.java') << '''
            import org.gradle.api.*;
            import org.gradle.model.*;

            @Managed

    x.set(123)
}
```

[[redundant_getters]]
== Redundant getters

This error indicates that a `boolean` property has both a `get` and an `is` getter method.
This is a problem because both getters can be annotated differently and Gradle cannot know which ones to use.

The solution to this problem is to get rid of one of the getters or to mark one of the getters with link:{javadocPath}/org/gradle/api/tasks/Internal.html[@Internal]

            )
        }
    }

    /**
     * This class recursively visits all calls of functions and getters, and if the function or the getter used for a call has
     * an annotation whose FqName is [annotationFqName], it runs [handleFunctionWithAnnotation] for the function or the getter.
     */
    private class CheckCallsWithAnnotationVisitor(
        private val annotationFqName: String,

        }

        then:
        outputEquals """
Type 'Person' property 'nice' has redundant getters: 'getNice()' and 'isNice()'.

Reason: Boolean property 'nice' has both an `is` and a `get` getter.

Possible solutions:
  1. Remove one of the getters.
  2. Annotate one of the getters with @Internal.

${validationMessage("redundant_getters")}
"""
    }

        config.description("has redundant getters: 'get${config.property.capitalize()}()' and 'is${config.property.capitalize()}()'")
            .reason("Boolean property '${config.property}' has both an `is` and a `get` getter")
            .solution("Remove one of the getters")
            .solution("Annotate one of the getters with @Internal")
            .render()
    }

                contextualLabel == 'Type \'MyTask\' property \'badTime\' is private and annotated with @Input'
                details == 'Annotations on private getters are ignored'
                solutions == [
                    'Make the getter public',
                    'Annotate the public version of the getter',
                ]

    }

    @Managed
    interface HasSingleCharGetter {
        String getA()
        void setA(String a)
    }

    def "allow single char getters"() {
        when:
        def schema = store.getSchema(HasSingleCharGetter)

        then:
        schema instanceof ManagedImplSchema
        def a = schema.properties[0]

    def "should not allow 'is' as a prefix for getter on non boolean in #type"() {
        when: extract IsNotAllowedForOtherTypeThanBoolean
        then: def ex = thrown InvalidManagedTypeException
        ex.message == """Type ${fullyQualifiedNameOf(IsNotAllowedForOtherTypeThanBoolean)} is not a valid managed type:
- Property 'thing' is not valid: it must both have an abstract getter and a setter"""
    }