task ant(dependsOn: target1)
"""
        TestFile target1File = testFile('build/target1.txt')
        TestFile target2File = testFile('build/target2.txt')
        target1File.assertDoesNotExist()
        target2File.assertDoesNotExist()

        inTestDirectory().withTasks('ant').run().assertTasksExecutedInOrder(':initialize', ':target2', ':target1', ':ant')

        target1File.assertExists()
        target2File.assertExists()

        executedAndNotSkipped ":test", ":jacocoTestReport", ":jacocoTestCoverageVerification"
        reportFile.assertIsFile()

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

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

        dslDir.file("build/my-test-results/test").directory
        dslDir.file("build/test-results/test").assertDoesNotExist()

        and: "the reports are in the custom directory"
        dslDir.file("my-reports").directory
        getStandardTestReportDir(dslDir, "", "").assertDoesNotExist()

        where:
        dsl << ['groovy', 'kotlin']
    }

    @UsesSample("testing/testReport")

        then:
        dir.assertDoesNotExist()
        didWork
    }

    def "deletes file"() {
        given:
        TestFile dir = tmpDir.getTestDirectory()
        TestFile file = dir.file("someFile")
        file.createFile()

        when:
        boolean didWork = deleter.deleteRecursively(file)

        then:
        file.assertDoesNotExist()
        didWork
    }

        succeeds("unpackLibsDirectory")

        then:
        def outputDir = dslDir.file("build/resources")
        outputDir.file("libs/first.txt").assertDoesNotExist()
        outputDir.file("libs/other.txt").assertDoesNotExist()
        outputDir.file("docs.txt").assertDoesNotExist()
        outputDir.file("first.txt").isFile()
        outputDir.file("other.txt").isFile()

        where:
        dsl << ['groovy', 'kotlin']

            library.linkage = [Linkage.STATIC]
        """

        lib.writeToProject(testDirectory)
        succeeds("xcode")

        when:
        debugBinary.assertDoesNotExist()
        def resultDebug = xcodebuild
            .withProject(rootXcodeProject)
            .withScheme('App')
            .succeeds()

        then:

    }

    void assertGradleFilesNotGenerated(TestFile parentFolder = rootDir) {
        getBuildFile(parentFolder).assertDoesNotExist()
        getSettingsFile(parentFolder).assertDoesNotExist()
        getVersionCatalogFile().assertDoesNotExist()
        assertWrapperFilesNotGenerated(parentFolder)
    }

    void assertWrapperFilesNotGenerated(TestFile parentFolder = rootDir) {

        then:
        configurationCache.assertStateStored()

        and:
        buildDir.assertDoesNotExist()

        when:
        buildDir.mkdir()
        configurationCacheRun 'clean'

        then:
        configurationCache.assertStateLoaded()

        and:
        buildDir.assertDoesNotExist()
    }

        succeeds("foo")
        file('build/foo/foo').text == 'bar'
        getGcFile(currentCacheDir).assertDoesNotExist()

        when:
        file('foo').text = 'baz'

        then:
        buildTriggeredAndSucceeded()
        file('build/foo/foo').text == 'baz'
        getGcFile(currentCacheDir).assertDoesNotExist()

        when:
        sendEOT()

        then:
        waitForNotRunning()

        buildFile << """
            apply plugin: 'cpp-application'
        """

        app.writeToProject(testDirectory)
        succeeds("xcode")

        when:
        debugBinary.assertDoesNotExist()
        def resultDebug = xcodebuild
            .withProject(rootXcodeProject)
            .withScheme('App')
            .succeeds()

        then: