}

    def "supplies multiple installations for multiple paths"() {
        given:
        def jdk1 = temporaryFolder.createDir("11.0.6.hs-adpt")
        def jdk2 = temporaryFolder.createDir("14")
        def jdk3 = temporaryFolder.createDir("java/8.0.262.fx-librca")
        def supplier = createSupplier([jdk1, jdk2, jdk3] as Set)

        when:
        def directories = supplier.get()

        then:

    def forkOptionsFactory = TestFiles.execFactory(temporaryFolder.testDirectory)
    def objectFactory = Stub(ObjectFactory) {
        fileCollection() >> { TestFiles.fileCollectionFactory().configurableFiles() }
    }
    def workerDirectoryProvider = Stub(WorkerDirectoryProvider) {
        getWorkingDirectory() >> { temporaryFolder.testDirectory }
    }
    def runnable = Mock(Runnable)

        setup:
        def externalInitFile = temporaryFolder.createFile("initscripts/path1/anInit.gradle")
        externalInitFile << """
            buildFinished {
                println "Gradle Plugin received build finished!"
            }
        """
        def anotherExternalInitFile = temporaryFolder.createFile("initscripts/path2/anotherInit.gradle")
        anotherExternalInitFile << """

                private
                fun withBuildscript(script: String) =
                    temporaryFolder.newFile("build.gradle.kts").apply {
                        writeText(script)
                    }

                @Rule @JvmField val temporaryFolder = TemporaryFolder()
            }
            """
        )

        println(
            build("test").output
        )
    }

import org.gradle.testkit.runner.GradleRunner
import org.junit.Before
import org.junit.Rule
import org.junit.rules.TemporaryFolder
import java.io.File

abstract class PluginTest {

    @Rule
    @JvmField
    val testProjectDir: TemporaryFolder = TemporaryFolder()
    protected lateinit var settingsFile: File
    protected lateinit var buildFile: File

    @Before
    fun setup() {

import org.gradle.testkit.runner.GradleRunner
import org.junit.Before
import org.junit.Rule
import org.junit.rules.TemporaryFolder
import java.io.File

abstract class PluginTest {

    @Rule
    @JvmField
    val testProjectDir: TemporaryFolder = TemporaryFolder()
    protected lateinit var settingsFile: File
    protected lateinit var buildFile: File

    @Before
    fun setup() {

    def originWriter = Mock(OriginWriter)

    def "unpack invokes unpacker and fingerprints trees"() {
        def outputFile = temporaryFolder.file("output.txt")
        def outputDir = temporaryFolder.file("outputDir")
        def outputDirFile = outputDir.file("file.txt")
        def input = temporaryFolder.createFile("input")
        def entity = entity(
            prop("outputDir", DIRECTORY, outputDir),

@CleanupTestDirectory
abstract class CrossVersionIntegrationSpec extends Specification {
    @Rule TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())
    private final List<GradleExecuter> executers = []
    final GradleDistribution current = new UnderDevelopmentGradleDistribution()
    static GradleDistribution previous

import org.junit.Rule
import spock.lang.Specification

class CompositeCleanupActionTest extends Specification {

    @Rule TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())
    def cleanableStore = Stub(CleanableStore) {
        getBaseDir() >> temporaryFolder.getTestDirectory()
        getDisplayName() >> "My Cache"
    }
    def progressMonitor = Stub(CleanupProgressMonitor)

    }

    def "cleans outputs and delegates spec for clean compilation"() {
        def spec = Mock(NativeCompileSpec)
        def existingSource = temporaryFolder.file("existing")
        def newSource = temporaryFolder.file("new")
        def outputFile = temporaryFolder.createFile("output", "previous")

        def sources = [existingSource, newSource]

        when:
        outputFile.assertExists()

        and: