def versionDir = this.versionDir
        fileAccessManager.access(distributionZip) {
            if (!markerFile.exists()) {
                distributionZip.delete()
                gradleHomeDir.deleteDir()

                URL url = getDownloadURL();
                System.out.println("downloading $url")
                distributionZip.copyFrom(url)

            //the main src dir might be locked, only delete children
            file("src/main/java").listFiles().each {
                assert !it.deleteDir().exists()
            }
        } else {
            assert !file("src/main/java").deleteDir().exists()
        }


        then:
        buildTriggeredAndSucceeded()
        executedAndNotSkipped(":compileJava")
        executed(":build")
    }

        def directories = supplier.get()

        then:
        directories.isEmpty()
    }

    def "supplies no installations for non-existing directory"() {
        given:
        assert candidates.deleteDir()

        when:
        def directories = supplier.get()

        then:
        directories.isEmpty()
    }

    def "supplies single installations for single candidate"() {
        given:

        source("class A {}")
        withBuildCache().run language.compileTaskName
        executer.stop()
        file("user-home/caches").deleteDir()
        def cachedBuild =  withBuildCache().run "clean", language.compileTaskName
        cachedBuild.groupedOutput.task(":compileJava").outcome == "FROM_CACHE"

        when:

        tgzCacheEntry.delete()

        def metadata = new Properties()
        extractDir.file("METADATA").withInputStream { input ->
            metadata.load(input)
        }
        extractDir.deleteDir()
        return metadata
    }

        withBuildCache().run compilationTask

        then:
        classes.all*.compiledClass*.exists().every()
        classes.analysisFile.assertIsFile()

        when:
        warmupDir.deleteDir()
        setupProjectInDirectory(testDirectory)
        classes = new ScalaCompilationFixture(testDirectory)
        classes.baseline()
        withBuildCache().run compilationTask

        then:

        given:
        def rootDir = tmpDir.createDir("root")
        def dir = rootDir.createDir("target")
        def link = rootDir.file("source")
        link.createLink(dir)
        dir.deleteDir()
        def file = rootDir.createFile("hello.txt")
        file << "Hello world"

        def patternSet = new PatternSet()
        patternSet.include("*.txt")

        when:

repositories {
    maven { url '${repo1.uri}' }
    maven { url '${repo2.uri}' }
}
configurations { compile }
dependencies {
    $dependencies
}
task deleteDir(type: Delete) {
    delete 'libs'
}
task retrieve(type: Copy, dependsOn: deleteDir) {
    into 'libs'
    from configurations.compile
}
"""
    }

    def "includes jar artifact if present for pom with packaging of type 'pom'"() {
        when:

}

func (m *realDeps) addIP(name string, ip netip.Addr, ipProto uint8, comment string, replace bool) error {
	return errors.New("not implemented on this platform")
}

func (m *realDeps) deleteIP(name string, ip netip.Addr, ipProto uint8) error {
	return errors.New("not implemented on this platform")
}

func (m *realDeps) flush(name string) error {
	return errors.New("not implemented on this platform")
}

@LeaksFileHandles
class ToolingApiInitScriptCrossVersionIntegrationTest extends ToolingApiSpecification {

    TestFile createDistribution(int i) {
        def distro = temporaryDistributionFolder.file("distro$i")
        distro.deleteDir()

        distro.copyFrom(getTargetDist().getGradleHomeDir())
        distro.file("bin", OperatingSystem.current().getScriptName("gradle")).permissions = 'rwx------'
        distro.file("init.d/init.gradle") << """