new ClasspathWalker(TestFiles.fileSystem()),
            new DefaultClasspathBuilder(TestFiles.tmpDirTemporaryFileProvider(tmpDir.createDir("tmp")))
        )
    }

    def "creates JAR file for input directory"() {
        given:
        def inputFilesDir = tmpDir.createDir('inputFiles')
        writeClass(inputFilesDir, "org/gradle/MyClass")

        when:
        relocatedJarCreator.create(outputJar, [inputFilesDir])

        given:
        settingsFile << """
            include 'a', 'b'
        """
        buildScript """
            task ok
        """
        def a = createDir('a')
        def b = createDir('b')
        def configurationCache = newConfigurationCacheFixture()

        when:
        inDirectory a
        configurationCacheRun ':ok'

        then:

        TestFile tempUnzipDir = temporaryFolder.createDir("temp-unzip")
        distribution.binDistribution.unzipTo(tempUnzipDir)
        assert tempUnzipDir.file("gradle-${distribution.version.baseVersion.version}", "bin", "gradle").delete()
        TestFile tempZipDir = temporaryFolder.createDir("temp-zip-foo")

    def "fails if custom executable is a directory"() {
        def javaCompile = project.tasks.create("compileJava", JavaCompile)
        javaCompile.destinationDirectory.fileValue(temporaryFolder.createDir())
        def executableDir = temporaryFolder.createDir("javac")

        when:
        javaCompile.options.fork = true
        javaCompile.options.forkOptions.executable = executableDir.absolutePath
        javaCompile.createSpec()

    List<Closeable> loaders = []

    TestFile distDir

    def setup() {
        distDir = tmpDir.createDir("dist")
        distDir.createDir("lib")
        distDir.createDir("lib/plugins")
    }

    def cleanup() {
        CompositeStoppable.stoppable(loaders).stop()
    }

    }

    private
    fun createContainer(k: K, creator: () -> V): CalculatedValueContainer<BlockAddress, *> =
        calculatedValueContainerFactory.create<BlockAddress>(displayNameFor(k)) {
            loadPreviousOrCreateValue(k, creator)
        }

    private
    fun loadPreviousOrCreateValue(key: K, creator: () -> V): BlockAddress {
        previousValues[key]?.let { previouslyCached ->

    def "reading a file in transform action with #task does not create a build input"() {
        given:
        getTransformFixture().tap {
            withTransformPlugin(testDirectory.createDir("buildSrc"))
            withJavaLibrarySubproject(testDirectory.createDir("subproject"))
        }

        settingsFile("""
            include("subproject")
        """)

        buildFile("""

                }
            }
        '''
        createDir('lib') {
            file('settings.gradle') << 'rootProject.name = "lib"'
            file('build.gradle') << '''
                plugins { id 'java-library' }
                group = 'com.example'
                version = '1.0'
            '''
        }
        createDir('util') {
            file('settings.gradle') << 'rootProject.name = "util"'

        given:
        getTransformFixture(snippetsFactory.newSnippets(execOperationsFixture)).tap {
            withTransformPlugin(testDirectory.createDir("buildSrc"))
            withJavaLibrarySubproject(testDirectory.createDir("subproject"))
        }

        settingsFile("""
            include("subproject")
        """)

        buildFile("""

        UnsupportedBuildArgumentException ex = thrown()
        ex.message.contains('--foreground')
    }

    def "can overwrite project dir via build arguments"() {
        given:
        file('otherDir').createDir()
        file('otherDir/build.gradle') << "assert projectDir.name.endsWith('otherDir')"
        file('otherDir/settings.gradle') << ''

        when:
        withConnection {