tasks.create("validate") {
                        assert components*.name == ["sampleLib"]
                        assert components.withType(ModelElement)*.name == ["sampleLib"]
                        assert components.withType(ComponentSpec)*.name == ["sampleLib"]
                        assert components.withType($componentSpecType)*.name == ["sampleLib"]

        succeeds "checkModel"
    }

    def "custom binary type can viewed as ModelElement"() {
        when:
        buildWithCustomBinaryPlugin()

        and:
        buildFile << '''
            class Rules extends RuleSource {
                @Mutate
                void tasks(ModelMap<Task> tasks, @Path("binaries.sampleBinary") ModelElement binary) {
                    tasks.create("checkModel") {

                void types(PrimitiveTypes primitiveTypes) {
                }

                @Mutate
                void addCheckTask(ModelMap<Task> tasks, @Path("types.intProp") ModelElement intProp, @Path("types.longProp") ModelElement longProp) {
                    tasks.create("check") {
                        doLast {
                            println "intProp: $intProp"

        '''

        then:
        succeeds "echo"

        and:
        output.contains("person: Person 'someone'")
        output.contains("name: foo")
    }

    def "can view a managed element as ModelElement"() {
        when:
        buildScript '''
            @Managed
            interface Person {
                String getName()
                void setName(String name)
            }

        and:
        output.contains "name: things"
        output.contains "display-name: ModelMap<Thing> 'things'"
        output.contains "to-string: ModelMap<Thing> 'things'"
    }

    def "can view as ModelElement"() {
        when:
        buildScript '''
            @Managed
            interface Thing {
            }

            class Rules extends RuleSource {
              @Model

    }

    def "can view a functional source set as a ModelElement"() {
        buildScript """
        apply plugin: 'language-base'

        class Rules extends RuleSource {
            @Model
            void fss(FunctionalSourceSet sources) {
            }

            @Mutate void printTask(ModelMap<Task> tasks, @Path("fss") ModelElement sources) {
                tasks.create("printTask") {

        and:
        output.contains "name: people"
        output.contains "display-name: ModelSet<Person> 'people'"
        output.contains "to-string: ModelSet<Person> 'people'"
    }

    def "can view as ModelElement"() {
        when:
        buildScript '''
            @Managed
            interface Person {
            }

            class Rules extends RuleSource {
              @Model

                    println "as container: $tasks"
                    assert tasks.getByName("tasks") != null
                }
                @Mutate
                void applyMessages(@Path("tasks") ModelElement tasks) {
                    println "as model element: $tasks"
                    println "name: $tasks.name"
                }
            }

            apply type: MyPlugin
        '''

        when:

This element was created by testrule > create(item) and can be mutated as the following types:
  - ${fullyQualifiedNameOf(itemClass)} (or assignment compatible type thereof)
  - ${ModelElement.name} (or assignment compatible type thereof)"""
    }

    static class NamedRules extends RuleSource {}