static class SourceOne extends RuleSource {}

        static class SourceTwo extends RuleSource {}

        static class NotSource {}
    }

    static class IsASource extends RuleSource {
    }

    static class SourcesNotDeclaredAlphabetically {
        static class B extends RuleSource {}

        static class A extends RuleSource {}
    }

    def "find model rule sources - #clazz"() {

                }
            }

            class EchoRules extends RuleSource {
                @Mutate
                void mutateEcho(Task echo, String message) {
                    echo.message = message
                }
            }

            class Rules extends RuleSource {
                @Model
                String message() {
                    "foo"
                }

        then:
        succeeds "value"

        and:
        output.contains "value: [foo]"
    }

    def "plugin RuleSource can be abstract"() {
        buildFile << '''
@Managed
interface Thing {
    String getName()
    void setName(String name)
}

abstract class MyPlugin extends RuleSource {
    @Model
    void p1(Thing t) {
        println "creating " + t + " from " + toString()
        assert this == this

        ModelThing(String name) {
            this.name = name
        }
    }

    static class EmptyClass extends RuleSource {}

    def "can inspect class with no rules"() {
        expect:
        extract(EmptyClass).empty
    }

    static class ClassWithNonRuleMethods extends RuleSource {
        static List thing() {
            []
        }

        static <T> List<T> genericThing() {
            []

     *
     * The ruleSource provides the rule as exactly one rule method annotated with {@link org.gradle.model.Mutate}.
     *
     * This rule method:
     * <ul>
     *     <li>must return void.</li>
     *     <li>must have {@link org.gradle.api.artifacts.ComponentSelection} as its parameter.</li>
     * </ul>
     *
     * @param ruleSource an instance providing a rule implementation
     * @return this

    def "setup"() {
        buildFile << """
        @Managed interface SampleLibrary extends GeneralComponentSpec {}
        @Managed interface SampleBinary extends BinarySpec {}

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

            @ComponentType
            void registerBinary(TypeBuilder<SampleBinary> builder) {

        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 "provides basic meta-data for map"() {
        when:
        buildScript '''
            @Managed
            interface Thing {
            }

            class Rules extends RuleSource {
              @Model
              void things(ModelMap<Thing> things) {
              }
            }

            apply type: Rules

            model {
              tasks {

    def "provides basic meta-data for set"() {
        when:
        buildScript '''
            @Managed
            interface Person {
            }

            class Rules extends RuleSource {
              @Model
              void people(ModelSet<Person> people) {
              }
            }

            apply type: Rules

            model {
              tasks {