when:
        rules.all ruleSource

        then:
        def e = thrown(InvalidUserCodeException)
        e.message == "bad rule source"

        and:
        1 * adapter.createFromRuleSource(ComponentSelection, ruleSource) >> { throw new InvalidUserCodeException("bad rule source") }

        when:
        rules.withModule("group:module", ruleSource)

        then:

            recorder.mutations << input
        }
    }

    static class FirstInputCreationRule extends RuleSource {
        @Model
        String firstInput() {
            "first"
        }
    }

    static class SecondInputCreationRule extends RuleSource {
        @Model
        String secondInput() {
            "second"
        }
    }

    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

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

        when:
        action = RuleSourceBackedRuleAction.create(ModelType.of(List), ruleSource)

        then:
        action.inputTypes == [String, Integer, Set]

        when:
        action.execute(collector, ["foo", 1, ["bar", "baz"] as Set])

        then:
        collector == ["foo", 1, "bar", "baz"]

        where:
        ruleSource << [new ListRuleSource(), new ArrayListRuleSource()]
    }

            @Managed
            abstract class Person {
                abstract String getName()
                abstract void setName(String name)
            }

            class RulePlugin extends RuleSource {
                @Model
                void createPerson(Person person) {
                    person.name = "foo"
                }

                @Mutate