}

    def "mutating managed objects referenced by another managed object outside of a creation rule is not allowed"() {
        when:
        buildScript '''
            @Managed
            interface Pet {
                String getName()
                void setName(String name)
            }

            @Managed
            interface Person {
                Pet getPet()

println(instance.name) // Prints: myName
----

[[managed_types]]
== Using Gradle Managed Types

A managed type as an abstract class or interface with no fields and whose properties are all managed.
These types have their state entirely managed by Gradle.

For example, this managed type is defined as an interface:

[source,java]
.Resource.java
----

        and:
        output.contains("name: foo")
    }

    def "rule can provide a managed model element backed by an abstract class that extends other classes"() {
        when:
        buildScript '''
            @Managed
            abstract class Named {
                abstract String getName()
            }

            @Managed
            abstract class Person extends Named {

        where:
        type << MANAGED_SCALAR_COLLECTION_TYPES

    }

    def "reports problem when managed type declares a #type of managed type"() {
        when:
        buildScript """
        @Managed
        interface Thing { }

        @Managed
        interface Container {
            $type<Thing> getItems()
        }

        model {
            container(Container)

 * limitations under the License.
 */

package org.gradle.model.internal.manage.schema.extract

import org.gradle.model.Managed
import org.gradle.model.internal.manage.schema.CompositeSchema
import org.gradle.model.internal.manage.schema.ManagedImplSchema
import org.gradle.model.internal.manage.schema.ManagedImplStructSchema
import org.gradle.model.internal.manage.schema.StructSchema
import org.gradle.model.internal.type.ModelType

// tag::create-rule[]
// tag::rule-inputs[]
// tag::create-rule-no-config[]
// tag::managed-type-nested-config-rule[]
model {
// end::create-rule[]
// end::rule-inputs[]
// end::create-rule-no-config[]
// end::managed-type-nested-config-rule[]
    person {
        lastName = "Smith"
    }
// end::configure-rule[]
// tag::managed-type-nested-config-rule[]
    person {
        address {
            city = "Melbourne"

        """

        expect:
        succeeds "validate"
    }

    def "user can target managed internal views of a custom managed LanguageSourceSet with rules"() {
        given:
        buildFile << """
            @Managed interface CustomManagedLSS extends LanguageSourceSet {}
            @Managed interface CustomManagedLSSInternal extends CustomManagedLSS {
                String getInternal()

        failureCauseContains("""A model element of type: 'Thing' can not be constructed.
It must be one of:
    - A managed type (annotated with @Managed)""")
    }

    def "cannot create non managed types and provide an initialization closure"() {
        when:
        buildScript '''
            apply plugin: 'language-base'
            interface Thing {

    }

    def "rule can target nested element of managed element as input through a reference to managed element"() {
        when:
        buildScript '''
            @Managed
            interface Platform {
                OperatingSystem getOperatingSystem()
                void setOperatingSystem(OperatingSystem os)
            }

            @Managed
            interface OperatingSystem {

 */

package org.gradle.model.managed

import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.integtests.fixtures.UnsupportedWithConfigurationCache

@UnsupportedWithConfigurationCache(because = "software model")
class ManagedTypeReferencesIntegrationTest extends AbstractIntegrationSpec {

    def "rule can provide a managed model element that references another managed model element"() {
        when: