}

    def "cannot assign a non-managed instance to a property of a managed type"() {
        when:
        buildScript '''
            @Managed
            interface Platform {
                OperatingSystem getOperatingSystem()
                void setOperatingSystem(OperatingSystem operatingSystem)
            }

            @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:

            import org.gradle.model.Managed

            @Managed
            interface ManagedType {
                $someType.canonicalName getManagedProperty()
            }

        """

        then:
        failWhenRealized(clazz, Pattern.quote("Invalid managed model type 'ManagedType': read only property 'managedProperty' has non managed type ${fullyQualifiedNameOf(someType)}, only managed types can be used"))

        then:
        fails 'tasks'

        and:
        failure.assertHasCause("Calling setters of a managed type on itself is not allowed")
    }

    def "reports managed abstract type in missing property error message"() {
        when:
        buildScript '''
            @Managed
            abstract class Person {
                abstract String getName()

    }

    def "managed types can have cyclical managed type references where more than two types constitute the cycle"() {
        when:
        buildScript '''
            @Managed
            interface A {
                String getName()
                void setName(String name)

                B getB()
            }

            @Managed
            interface B {
                C getC()

        fails "components"
        failure.assertHasCause "Invalid managed model type SampleBinary: @Variant annotation only allowed for properties of type String and org.gradle.api.Named, but property has type java.lang.Integer (invalid property: variantProp)"
    }

    def "variant annotation on property with primitive type raises error"() {
        buildFile << """
        @Managed
        interface SampleBinary extends BinarySpec {

import org.gradle.internal.state.Managed;
import org.gradle.internal.state.ManagedFactory;
import org.gradle.internal.state.ManagedFactoryRegistry;

import javax.annotation.Nullable;

public class IsolatedImmutableManagedValue extends AbstractIsolatableScalarValue<Managed> {
    private final ManagedFactoryRegistry managedFactoryRegistry;

import org.gradle.model.ModelSet;
import org.gradle.model.internal.manage.schema.CollectionSchema;
import org.gradle.model.internal.manage.schema.ModelSchemaStore;
import org.gradle.model.internal.type.ModelType;

import java.util.List;
import java.util.Set;

/**
 * Thrown when a NodeInitializer can not be found for a given type or when the type is not managed and can not be constructed.
 */

 * limitations under the License.
 */

package org.gradle.model.internal.manage.binding;

import org.gradle.model.internal.type.ModelType;

/**
 * A managed property of a struct type.
 *
 * <p>Managed properties are properties whose values need to be stored in child-nodes. A
 * managed property is detected when the view schemas declaring the struct declare a property with only abstract accessor

import org.gradle.api.Action;
import org.gradle.api.Incubating;

import java.util.Set;

/**
 * A set of managed model objects.
 * <p>
 * {@link org.gradle.model.Managed} types may declare managed set properties.
 * Managed sets can only contain managed types.
 * <p>