then:
        testFile("build/resources/main/prod.resource").assertExists()
        testFile("build/classes/java/main/prod.resource").assertDoesNotExist()

        testFile("build/resources/test/test.resource").assertExists()
        testFile("build/classes/java/test/test.resource").assertDoesNotExist()

        testFile("build/classes/java/main/Main.class").assertExists()

        result.assertTaskNotExecuted(':application:testAggregateTestReport')

        file("application/build/reports/tests/unit-test/aggregated-results").assertDoesNotExist()
    }

    def 'test verification failure creates aggregated report with --continue flag'() {
        given:file("application/build.gradle") << """
            apply plugin: 'org.gradle.test-report-aggregation'

model {
    components {
        main(NativeLibrarySpec)
    }
}
"""
        and:
        succeeds "visualStudio"

        when:
        debugBinaryLib.assertDoesNotExist()
        debugBinaryDll.assertDoesNotExist()
        def resultDebug = msbuild
            .withSolution(solutionFile("app.sln"))
            .withConfiguration('win32Debug')
            .succeeds()

        then:

        cleanupAction.clean(cleanableStore, progressMonitor)

        then:
        cacheEntries[0].assertExists()
        cacheEntries[1].assertExists()
        cacheEntries[2].assertExists()
        cacheEntries[3].assertDoesNotExist()
        1 * fileAccessTimeJournal.deleteLastAccessTime(cacheEntries[3])
    }

    def "finds no files to delete when files are new"() {
        given:
        long now = System.currentTimeMillis()

            return delegateResult
        }

        then:
        immutableWorkspace.assertDoesNotExist()
        temporaryWorkspace.file("output.txt").assertIsFile()
        temporaryWorkspace.file("origin.bin").assertDoesNotExist()
        0 * _

        when:
        def resolvedResult = result.getOutputAs(Object)

        then:

        when:
        buildFile << """compileJava.options.annotationProcessorPath = files()"""
        fails("compileJava")

        then:
        file("build/generated-sources/TestAppHelper.java").assertDoesNotExist()
    }

    def "generated sources directories track task dependency"() {
        given:
        buildFile << """
            dependencies {
                compileOnly project(":annotation")

                destinationDirectory = buildDir
                archiveFileName = 'test.tar'
            }
            """
        when:
        run "tar"

        then:
        file('build/test.tar').assertDoesNotExist()
    }

    def canCopyFromATar() {
        given:
        createTar('test.tar') {
            subdir1 {
                file 'file1.txt'
            }
            subdir2 {

        expect:
        succeeds "compileDebug"
        result.assertTasksExecuted(":compileDebugCpp", ":compileDebug")
        objectFiles(lib.sources)*.assertExists()
        staticLibrary("build/lib/main/debug/hello").assertDoesNotExist()
    }

            }
        """
        when:
        succeeds("extract")
        then:
        file("build/extract/hello.txt").text == "hello"
        cachedFile.assertExists()
        otherFile.assertDoesNotExist()

        when:
        // write into the directory used by the extracted zip file
        cachedFile.text = "some incorrect pre-existing pre-expanded content"
        otherFile.touch()

        and:

        releaseX86.exec().out == "Hello world!\n"

        debugX64.arch.name == "x86-64"
        releaseX64.arch.name == "x86-64"

        // Itanium not built
        debugIA64.assertDoesNotExist()
        releaseIA64.assertDoesNotExist()
    }

    @ToBeFixedForConfigurationCache
    def "tool chains"() {
        given:
        sample toolChains

        when:
        run "installMainExecutable"