import java.lang.annotation.Target;

/**
 * Indicates that a property of a managed model element is explicitly of an unmanaged type.
 * <p>
 * This annotation must be present on the <b>getter</b> of the property for the unmanaged type.
 * If the annotation is not present for a property that is not a managed type, a fatal error will occur.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)

        class Widget {
            String name
        }

        @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)
        }

                        assert components*.name == ["managed", "unmanaged"]
                        assert components.withType(ComponentSpec)*.name == ["managed", "unmanaged"]
                        assert components.withType(UnmanagedComponentSpec)*.name == ["managed", "unmanaged"]
                        assert components.withType(ManagedComponentSpec)*.name == ["managed"]

A managed collection can not contain 'java.io.FileInputStream's
A valid managed collection takes the form of ModelSet<T> or ModelMap<T> where 'T' is:
        - A managed type (annotated with @Managed)""")
    }

    @Managed
    interface ManagedWithInvalidModelMap {
        ModelMap<FileInputStream> getMap()
    }

    @Managed
    interface ManagedWithUnsupportedType {

        'UnmanagedComponent' | 'UnmanagedBinary' | 'UnmanagedLanguageSourceSet' | "Unmanaged"
        'UnmanagedComponent' | 'UnmanagedBinary' | 'ManagedLanguageSourceSet'   | "Managed"
        'UnmanagedComponent' | 'ManagedBinary'   | 'UnmanagedLanguageSourceSet' | "Unmanaged"
        'UnmanagedComponent' | 'ManagedBinary'   | 'ManagedLanguageSourceSet'   | "Managed"

            class MyFile extends File {
              MyFile(String s) { super(s) }
            }

            @Managed
            interface ManagedThing {
                @Unmanaged
                UnmanagedThing getUnmanaged()
                void setUnmanaged(UnmanagedThing unmanaged)

                @Unmanaged
                MyFile getFile()
                void setFile(MyFile file)
            }

        return unmanaged(builder, ModelType.of(modelType), inputPath, referenceDescription, action);
    }

    public static <C> ModelRegistration unmanaged(ModelRegistrations.Builder builder, ModelType<C> modelType, String inputPath, Transformer<? extends C, Object> action) {
        return unmanaged(builder, modelType, inputPath, inputPath, action);
    }

            File]
    }

    def "can have a #type as an @Unmanaged property"() {
        when:
        def clazz = classLoader.parseClass """
            import org.gradle.api.artifacts.Configuration.State
            import org.gradle.model.Managed
            import org.gradle.model.Unmanaged

            @Managed
            interface ManagedType {
                @Unmanaged
                $type getUnmanagedReadWriteProperty()

                }
            }
        }

        then:
        registry.get("foo", Foo).bar.first().name == "one"
    }

    def "cannot create unmanaged"() {
        when:
        modelDsl.configure {
            unmanaged(Unmanaged)
        }

        then:
        thrown ModelTypeInitializationException
    }

    def "can use property accessors in DSL to build model object path"() {

    /**
     * Return information about the implementation of an unmanaged type.
     */
    @Nullable
    <S extends T> ImplementationInfo getImplementationInfo(ModelType<S> publicType);

    /**
     * Return information about the implementation of a managed type with an unmanaged super-type.
     */
    <S extends T> ImplementationInfo getManagedSubtypeImplementationInfo(ModelType<S> publicType);