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 {

	return &lastAppliedManager{
		fieldManager:    fieldManager,
		typeConverter:   typeConverter,
		objectConverter: objectConverter,
		groupVersion:    groupVersion,
	}
}

// Update implements Manager.
func (f *lastAppliedManager) Update(liveObj, newObj runtime.Object, managed Managed, manager string) (runtime.Object, Managed, error) {
	return f.fieldManager.Update(liveObj, newObj, managed, manager)
}

    }

    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()

        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

        """

        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()

// 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"

        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: