then:
        calledFor == ["e"]
    }

    def "callbacks called for composite of composites"() {
        given:
        def component1 = collection("a")
        def component2 = collection("b")
        def component3 = collection("c")
        def component4 = collection("d")

        def composite1 = composite(component1, component2)
        def composite2 = composite(component3, component4)

    def providesALoggingManagerFactory() {
        given:
        def registry = LoggingServiceRegistry.newCommandLineProcessLogging()

        expect:
        def factory = registry.getFactory(LoggingManagerInternal.class)
        factory instanceof DefaultLoggingManagerFactory
    }

    def providesAStyledTextOutputFactory() {
        given:

class DependencyGraphBuilderTest extends Specification {
    def conflictResolver = Mock(ModuleConflictResolver)
    def idResolver = Mock(DependencyToComponentIdResolver)
    def metaDataResolver = Mock(ComponentMetaDataResolver)
    def attributesSchema = Mock(AttributesSchemaInternal)
    def attributes = ImmutableAttributes.EMPTY
    def moduleReplacements = Mock(ModuleReplacementsData)
    def moduleIdentifierFactory = Mock(ImmutableModuleIdentifierFactory) {

        def result = parser.parse(['-a'])
        result.hasOption('a')
        !result.hasOption('b')
    }

    def canUseDoubleDashesForShortOptions() {
        parser.option('a')

        expect:
        def result = parser.parse(['--a'])
        result.hasOption('a')
    }

    def parsesShortOptionWithArgument() {
        parser.option('a').hasArgument()

        expect:

    }

    def "collects all failures from actions when running sequentially"() {
        given:
        def action1 = Mock(Supplier)
        def action2 = Mock(Supplier)
        def action3 = Mock(Supplier)
        def failure1 = new RuntimeException()
        def failure2 = new RuntimeException()

        when:
        runner.run([action1, action2, action3])

        then:

        0 * listener.onDiscovered(_)
    }

    def "notifies listener of node with matching ancestor"() {
        def a = node("a")
        def b = node("a.b")
        def c = node("a.b.c")
        def d = node("a.b.d")
        def e = node("a.b.c.e")
        def f = node("d")

        given:
        def listener = Mock(ModelListener) {
            matches(_) >> true

        def bean = new BeanWithDynamicProperties(prop: "value")
        def dynamicObject = new BeanDynamicObject(bean)

        expect:
        dynamicObject.hasProperty("prop")
        !dynamicObject.hasProperty("dyno")
    }

    def "can get property of closure delegate via closure instance"() {
        def bean = new BeanWithDynamicProperties(prop: "value")
        def cl = {}
        cl.delegate = bean

    }

    def callsClosureWithNewObjectAsParameterWhenObjectAdded() {
        def seen = []
        def closure = { seen << it }

        container.whenObjectAdded(closure)

        when:
        container.add("a")

        then:
        seen == ["a"]
    }

    def callsClosureWithRemovedObjectAsParameterWhenObjectRemoved() {
        def seen = []
        def closure = { seen << it }

        rawList != list
    }

    def "class can be assigned from itself or subtypes"() {
        expect:
        def type = ModelType.of(Number)
        def object = ModelType.of(Object)
        def intType = ModelType.of(Integer)
        def string = ModelType.of(String)
        def rawCollection = ModelType.of(Collection)
        def rawList = ModelType.of(List)
        def list = new ModelType<List<String>>() {}

    }

    def "can view directory as a file tree"() {
        def dir1 = projectDir.createDir("dir1")
        def file1 = dir1.createFile("sub-dir/file1")
        def file2 = dir1.createFile("file2")
        def dir2 = projectDir.createDir("dir2")
        def file3 = dir2.createFile("other/file3")

        expect:
        def tree1 = layout.projectDirectory.dir("dir1").asFileTree