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:

 * Model maps can only contain managed types.
 *
 * @param <T> the contract type for all items
 */
@Incubating
public interface ModelMap<T> extends Iterable<T>, ModelElement {
    /**
     * Returns a collection containing the items from this collection which are of the specified type.
     *
     * @param type The type.
     * @param <S> The type.
     * @return The collection.

        when:
        registry.realize("foo")

        then:
        thrown IllegalStateException

        when:
        def modelElement = registry.find("foo", ModelType.untyped())

        then:
        noExceptionThrown()

        and:
        modelElement == null
    }

    def "can get element for which a registration has been registered"() {
        given:

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