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"

            connection.newBuild()
                .forTasks(clean)
                .run()
        }

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

    def "receives progress while the build is executing"() {
        file('build.gradle') << '''
System.out.println 'this is stdout'
System.err.println 'this is stderr'
'''
        when:

        when:
        succeeds(":testCodeCoverageReport")

        then:
        file("transitive/build/jacoco/test.exec").assertDoesNotExist()
        file("transitive/build/libs/transitive-1.0.jar").assertExists()
        file("direct/build/jacoco/test.exec").assertExists()