def snapshot = reportFile.snapshot()
        then:
        executedAndNotSkipped ":test", ":jacocoTestReport", ":jacocoTestCoverageVerification"
        reportFile.assertIsFile()

        when:
        succeeds "clean"
        then:
        reportFile.assertDoesNotExist()

        when:
        withBuildCache().run "jacocoTestReport", "jacocoTestCoverageVerification"
        then:

        outputFile.assertIsFile()

        when:
        configurationCacheRun "a"

        then:
        result.assertTasksSkipped(":a")

        when:
        outputFile.delete()
        configurationCacheRun "a"

        then:
        result.assertTasksExecutedAndNotSkipped(":a")
        outputFile.assertIsFile()
    }

        return strippedRuntimeFile
    }

    @Override
    void assertExists() {
        super.assertExists()
        if (toolChain.visualCpp) {
            file.withExtension(".lib").assertIsFile()
            file.withExtension(".exp").assertIsFile()
        }
    }

    @Override
    void assertDoesNotExist() {
        super.assertDoesNotExist()
        if (toolChain.visualCpp) {

    }

    protected void commonFilesGenerated(BuildInitDsl scriptDsl, dslFixture = dslFixtureFor(scriptDsl)) {
        dslFixture.assertGradleFilesGenerated()
        targetDir.file(".gitignore").assertIsFile()
        targetDir.file(".gitattributes").assertIsFile()
        mavenCentralRepositoryDeclared(scriptDsl)
    }

    protected void commonJvmFilesGenerated(BuildInitDsl scriptDsl) {
        commonFilesGenerated(scriptDsl)

            return DeletionAction.CONTINUE
        }

        when:
        deleter.deleteRecursively(targetDir)

        then:
        targetDir.assertIsDir()
        nonDeletable.assertIsFile()
        newFile.assertIsFile()

        and:
        def ex = thrown IOException
        normaliseLineSeparators(ex.message) == """
            Unable to delete directory '$targetDir'

        when:
        succeeds 'publish'

        then:
        def localPom = file("build/publications/maven/pom-default.xml").assertIsFile()
        def localArtifact = file("build/libs/publish-2.jar").assertIsFile()

        module.pomFile.assertIsCopyOf(localPom)
        module.pom.verifyChecksums()
        module.artifactFile.assertIsCopyOf(localArtifact)

        executer.withTasks('classes').run()
        file('build/resources/main').assertHasDescendants('org/gradle/resource.txt')

        file('src/main/resources/org/gradle/resource.txt').assertIsFile().delete()
        file('src/main/resources/org/gradle/resource2.txt').createFile()

        executer.withTasks('classes').run()
        file('build/resources/main').assertHasDescendants('org/gradle/resource2.txt')
    }

            def sha1File = getSha1File()
            sha1File.assertIsFile()
            assert HashCode.fromString(sha1File.text) == Hashing.sha1().hashFile(getFile())
        }
        if (server.supportsHash(HttpServer.SupportedHash.MD5)) {
            def md5File = getMd5File()
            md5File.assertIsFile()
            assert HashCode.fromString(md5File.text) == Hashing.md5().hashFile(getFile())
        }

    }

    private static void checkApplicationImage(String applicationName, TestFile installDir) {
        installDir.file("bin/${applicationName}").assertIsFile()
        installDir.file("bin/${applicationName}.bat").assertIsFile()
        installDir.file("lib/application.jar").assertIsFile()

        def builder = new ScriptExecuter()
        builder.workingDir installDir.file('bin')
        builder.executable applicationName

    public void unzipTo(File target) {
        assertIsFile();
        new TestFileHelper(this).unzipTo(target, useNativeTools);
    }

    public void unzipToWithoutCheckingParentDirs(File target) {
        assertIsFile();
        new TestFileHelper(this).unzipTo(target, useNativeTools, false);
    }

    public void untarTo(File target) {
        assertIsFile();