def "can view task container as various view types"() {
        given:
        buildFile << '''
            class MyPlugin extends RuleSource {
                @Mutate
                void applyMessages(ModelMap<Task> tasks) {
                    println "as map: $tasks"
                    assert tasks.get("tasks") != null
                }

            class MyPlugin extends RuleSource {
                @ComponentType
                void register(TypeBuilder<UnmanagedComponent> builder) {
                    builder.defaultImplementation(DefaultUnmanagedComponent)
                }
            }
            class MyOtherPlugin extends RuleSource {
                @ComponentType

    def store = new DefaultModelSchemaStore(DefaultModelSchemaExtractor.withDefaultStrategies())

    def "assembles schema for RuleSource type"() {
        expect:
        def schema = store.getSchema(ModelType.of(RuleSource))
        schema instanceof RuleSourceSchema
        !(schema instanceof ManagedImplSchema)
        !(schema instanceof CompositeSchema)
        schema instanceof StructSchema

    @Managed interface LibrarySourceSet extends LanguageSourceSet {}

    class MyBinaryDeclarationModel implements Plugin<Project> {
        void apply(final Project project) {}

        static class ComponentModel extends RuleSource {
            @ComponentType
            void registerLibrary(TypeBuilder<SampleLibrary> builder) {}

            @Mutate
            void createSampleComponentComponents(ModelMap<SampleLibrary> componentSpecs) {

                void setLongPropertyFromInt(Long value)

                Long getLongPropertyFromInteger()
                void setLongPropertyFromInteger(Long value)
            }

            class RulePlugin extends RuleSource {
                @Model
                void createPrimitiveTypes(PrimitiveTypes primitiveTypes) {
                    primitiveTypes.longPropertyFromInt = 123

        OuterClass.DoesNotExtendRuleSource | "Rule source classes must directly extend org.gradle.model.RuleSource"
        OuterClass.HasSuperclass           | "Rule source classes must directly extend org.gradle.model.RuleSource"
    }

    def "valid #type"() {
        when:
        extractor.extract(type)

        then:
        noExceptionThrown()

        where:

        given:
        def collector = new FormattingValidationProblemCollector("<thing>", ModelType.of(String))
        collector.add("does not extend RuleSource")

        expect:
        collector.format() == 'Type java.lang.String is not a valid <thing>: does not extend RuleSource'
    }

    def "formats message with a single problem with a long message"() {
        given:

        ModelRegistry modelRegistry = target.getModelRegistry();
        Iterable<Class<? extends RuleSource>> declaredSources = ruleDetector.getDeclaredSources(clazz);
        for (Class<? extends RuleSource> ruleSource : declaredSources) {
            ExtractedRuleSource<?> rules = ruleInspector.extract(ruleSource);
            for (Class<?> dependency : rules.getRequiredPlugins()) {

    def "can not create a top level LSS for using an implementation class"() {
        buildFile.text = """
        ${registerCustomLanguageWithImpl()}

        class Rules extends RuleSource {
            @Model
            void lss(DefaultCustomSourceSet source) {
            }
        }
        apply plugin: Rules
        """

        when:
        fails "model"

        then:

    ModelMap<Item> getChildren()
}

class PluginRules extends RuleSource {
    @Defaults void setDefaultFileSize(@Each FileItem file) {
        file.size = 1024
    }

    @Rules void applyValidateRules(ValidateRules rules, @Each DirectoryItem directory)  {}
}
apply plugin: PluginRules

abstract class ValidateRules extends RuleSource {
    @Validate
    void validateSizeIsPositive(ModelMap<FileItem> files) {