def "rule can mutate a managed type with a #type of scalar read-write property"() {
        given:
        buildScript """

        @Managed
        interface Container {
            $type<String> getItems()
            void setItems($type<String> items)
        }

        class Rules extends RuleSource {
            static final $type<String> INITIAL = ['initial']

            @Model

                        return self
                    }
                    maxPages * execute() >> {
                        Objects objects = new Objects()
                        objects.setItems(Collections.singletonList(new StorageObject()))
                        objects.setNextPageToken(page < maxPages - 1 ? Integer.toString(page) : null)
                        page++
                        return objects

        @Managed
        interface Container {
            @Unmanaged
            List<Widget> getWidgets()
            void setWidgets(List<Widget> l)

            @Unmanaged
            Set<Widget> getItems()
            void setItems(Set<Widget> s)

            @Unmanaged
            List getRawWidgets()
            void setRawWidgets(List l)
        }

        class Rules extends RuleSource {
            @Model

- Property 'name' is not valid: it must have either only abstract accessor methods or only implemented accessor methods"""
    }

    @Managed
    static interface CollectionType {
        List<String> getItems()
        void setItems(List<Integer> integers)
    }

    def "displays a reasonable error message when getter and setter of a property of collection of scalar types do not use the same generic type"() {

            import org.gradle.model.Managed

            @Managed
            interface CollectionType {
                List<${type.simpleName}> getItems()
                void setItems(List<${type.simpleName}> items)
            }
        """

        def schema = extract(managedType)

        then:
        assert schema instanceof ManagedImplStructSchema

        when:
        def clazz = loader.parseClass """
            @org.gradle.model.Managed
            interface PrimitiveProperty {
                List<$scalarType.name> getItems()

                void setItems(List<$scalarType.name> value)
            }
        """


        def data = [:]
        def state = Mock(GeneratedViewState)
        state.get(_) >> { args ->

	// per image stored in the node status.
	MaxNamesPerImageInNodeStatus = 5
)

// Setter modifies the node in-place, and returns an error if the modification failed.
// Setters may partially mutate the node before returning an error.
type Setter func(ctx context.Context, node *v1.Node) error

// NodeAddress returns a Setter that updates address-related information on the node.

        prop.getters.size() == 2
        prop.setters.size() == 1

        def readOnly = details.getProperty('readOnly')
        readOnly.getters.size() == 1
        readOnly.setters.size() == 0

        def someProp = details.getProperty('someProp')
        someProp.getters.size() == 1
        someProp.setters.size() == 1
    }

    def "extracts properties with overloaded getters and setters"() {
        expect:

            Set<JavaMethod> setters = gettersAndSetters.get(Boolean.FALSE).stream().map(Accessor::getMethod).collect(toSet());
            if (!getters.isEmpty() && !setters.isEmpty()) {
                return new Accessors(owningClass, propertyName, getters, setters);
            }

            }
        }

        if (setters.size() != getters.size()) {
            throwParameterValidationError(clazz, "It contains a different number of getters and setters.");
        }

        for (String property : setters.keySet()) {
            if (!getters.containsKey(property)) {