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 "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

        dep1.addExclusion( exc );

        Dependency dep2 = new Dependency();
        dep2.setGroupId( "test" );
        dep2.setArtifactId( "test-artifact2" );
        dep2.setVersion( "1" );
        dep2.setType( "jar" );

        List<Dependency> deps = new ArrayList<>();
        deps.add( dep1 );
        deps.add( dep2 );

        ArtifactFactory factory = container.lookup( ArtifactFactory.class );

        setup:
        def testFile = folder.createFile("test1")
        def notation = Stub(Directory)
        notation.asFile >> testFile
        when:
        def object = parse(notation)
        then:
        object == testFile
    }

    def "with TextResource returns the underlying File"() {
        setup:
        def testFile = folder.createFile("test1")

        def property = propertyWithValue(someValue())

        expect:
        property.type == property.shallowCopy().type
    }

    def "shallow copy inherits dependencies of the original"() {
        given:
        def task = Mock(Task)
        def provider = supplierWithProducer(task)
        def property = propertyWithNoValue()
        property.set(provider)

        expect:

    def format = new SimpleDateFormat('yyyyMMddHHmmssZ')

    def setup() {
        format.timeZone = TimeZone.getTimeZone("UTC")
    }

    def "final release is added to list"() {
        def snapshot = snapshot('4.3')
        def rc = releasedVersion('4.3-rc-1')
        def versions = releasedVersions(snapshot, rc, [])
        def version = new ReleasedVersion('4.2', '20170913122310+0000')

        task5Details.path == pathOf(task5)
    }

    def addsAGroupThatContainsTheTasksWithNoGroup() {
        def task1 = task('task1')
        def task2 = task('task2', 'group', task1)
        def task3 = task('task3')
        def task4 = task('task4', task2)
        def task5 = task('task5', task3, task4)

        when:
        def model = modelFor([task1, task2, task3, task4, task5])

        then:

        def id1 = new ChannelIdentifier("channel1")
        def id2 = new ChannelIdentifier("channel2")
        def message1 = new ChannelMessage(id1, "message 1")
        def message2 = broadcast()

        given:
        def endpoint1 = queue.getChannel(id1).newEndpoint()
        def endpoint2 = queue.getChannel(id2).newEndpoint()

        when:
        def messages1 = []
        def messages2 = []
        queue.queue(message1)

        given:
        def locator = buildLayoutFactoryFor()

        and: "temporary tree created out of the Gradle build tree"
        def tmpDir = File.createTempFile("stop-", "-at").canonicalFile
        def stopAt = new File(tmpDir, 'stopAt')
        def currentDir = new File(new File(stopAt, "intermediate"), 'current')
        currentDir.mkdirs()

        expect:
        def layout = locator.getLayoutFor(currentDir, true)

        def barFactory = factory(Bar)
        def buzzFactory = factory(Buzz)
        registry.withFactories(barFactory, fooFactory)

        expect:
        registry.lookup(buzzFactory.id) == null
    }

    def "can lookup factory in parent registry"() {
        def fooFactory = factory(Foo)
        def barFactory = factory(Bar)
        def parent = new DefaultManagedFactoryRegistry().withFactories(fooFactory)