1 * source2.replace(source3, _) >> source2

        replaced.is(collection)

        when:
        def replaced2 = collection.replace(source3, {})

        then:
        1 * source1.replace(source3, _) >> source1
        1 * source2.replace(source3, _) >> source4

        replaced2 != collection
        replaced2.sourceCollections == [source1, source4]
    }

        expect:
        collection.contains(file2)
    }

    def "does not contain file when no source collection contains file"() {
        def source1 = new TestFileCollection(file1)
        def source2 = new TestFileCollection(file2)
        def collection = new TestCompositeFileCollection(source1, source2)

        expect:
        !collection.contains(file3)
    }

        then:
        1 * source1.visit(visitor)
        1 * source2.visit(visitor)
    }

    def visitsEachTreeWithClosure() {
        final Closure visitor = TestUtil.TEST_CLOSURE
        final FileVisitor closureAsVisitor = DefaultGroovyMethods.asType(visitor, FileVisitor.class)

        when:
        tree.visit(visitor)

        then:
        1 * source1.visit(closureAsVisitor)

    val source2 = relay.newSource()!!.buffer()
    assertThat(source1.readUtf8(5)).isEqualTo("abcde")
    assertThat(source2.readUtf8(5)).isEqualTo("abcde")
    assertThat(source2.readUtf8(5)).isEqualTo("fghij")
    assertThat(source1.readUtf8(5)).isEqualTo("fghij")
    assertThat(source1.exhausted()).isTrue()
    assertThat(source2.exhausted()).isTrue()
    source1.close()
    source2.close()
    assertThat(relay.isClosed).isTrue()

        given:
        initialFiles()

        when:
        modified(dep2, [source2])
        sourceFiles.remove(source2)

        then:
        checkCompile recompiled: [source1], removed: [source2]

        when:
        sourceFiles.add(source2)

        then:
        checkCompile recompiled: [source2], removed: []
    }

        }
        1 * runnable.run() >> {
            assert context.current().id == application1.id
            assert context.current().source == source
        }

        and:
        context.current() == null
    }

    def "can run supplier registered by previous application"() {
        def source = Stub(UserCodeSource)
        def source2 = Stub(UserCodeSource)
        def action = Mock(Action)

    }

    def "tasks have common output directories"() {
        def sourceFile1 = file('source1/source1.txt')
        sourceFile1 << 'a'
        def sourceFile2 = file('source2/source2.txt')
        sourceFile2 << 'b'
        def targetFile1 = file('target/source1.txt')
        def targetFile2 = file('target/source2.txt')
        def taskPath = ':copyAll'

        buildFile << """

    }

    def "visual studio project contains sources for native binaries for all configurations"() {
        def sourceCommon = file("source")
        def source1 = file("source1")
        def source2 = file("source2")
        def executableBinary1 = targetBinary("vsConfig1", sourceCommon, source1)
        def executableBinary2 = targetBinary("vsConfig2", sourceCommon, source2)

        when:

        assertThat(source.getClassName(), matchesRegexp("__[0-9a-z]+"));
    }

    @Test
    public void filesWithSameNameAndDifferentPathHaveDifferentClassName() {
        ScriptSource source1 = forFile(new File(testDir, "build.gradle"));
        ScriptSource source2 = forFile(new File(testDir, "subdir/build.gradle"));
        assertThat(source1.getClassName(), not(equalTo(source2.getClassName())));

        when:
        assert source2.delete()
        createJavaClass("Class3")
        withBuildCache().run(compilationTask)
        then:
        executedAndNotSkipped(compilationTask)
        !class2.exists()
    }

    def "zinc handles removal of stale output files after loading from cache"() {
        createJavaClass("Class1")
        def source2 = createJavaClass("Class2")