/**
 * Compiles the given [residual program][ResidualProgram] to an [ExecutableProgram] subclass named `Program`
 * stored in the given [outputDir].
 */
internal
class ResidualProgramCompiler(
    private val outputDir: File,
    private val compilerOptions: KotlinCompilerOptions,
    private val classPath: ClassPath = ClassPath.EMPTY,
    private val originalSourceHash: HashCode,

        def outputJar = testDir.file("transformed.jar")
        return new JarTestFixture(transform(factory, originalJar, outputJar), 'UTF-8', null, /* checkManifest */ false)
    }

    private TestFile transformDirectory(TransformFactoryType factory, File originalDir) {
        def outputDir = testDir.file("transformed")

                PartialEvaluator(programKind, programTarget)::reduce
            )

            scriptSource.withLocationAwareExceptionHandling {
                ResidualProgramCompiler(
                    outputDir = cachedDir,
                    compilerOptions = host.compilerOptions,
                    classPath = compilationClassPath,
                    originalSourceHash = programId.sourceHash,

        testParameterType.imports += ["java.io.File", "java.util.List", "org.gradle.other.Foo"]
        testParameterType.fields += [
            "files": "List<String>",
            "outputDir": "File",
            "bar": "Foo"
        ]

        workActionThatCreatesFiles = getWorkActionThatCreatesFiles("TestWorkAction")

[source,kotlin]
----
tasks.compileJava {
    // Modify the task behavior
    doLast {
        val outputDir = File("$buildDir/compiledClasses")
        outputDir.mkdirs()

        val compiledFiles = sourceSets["main"].output.files
        compiledFiles.forEach { compiledFile ->
            val destinationFile = File(outputDir, compiledFile.name)
            compiledFile.copyTo(destinationFile, true)
        }

    }

    def "wrong output file type registered via TaskOutputs.#method is not allowed (files)"() {
        enableProblemsApiCheck()
        expectReindentedValidationMessage()
        def outputDir = file("output-dir")
        outputDir.createDir()
        buildFile << """
            task test {
                outputs.${method}({ "$path" }) withPropertyName "output"
                doLast {}
            }
        """

                        return "good";
                    }
                }

                @OutputDirectory
                private File getOutputDir() {
                    return new File("outputDir");
                }

                @TaskAction
                public void doStuff() { }
            }
        """

        expect:
        assertValidationFailsWith([

        workerThatChecksClassLoader.with {
            action += """
                File outputDir = new File(getParameters().getOutputDir().absolutePath.replace("checkClassLoader", "changeClassloader"))
                URL[] urls = parameters.files.collect { new File(outputDir, it).toURI().toURL() }
                assert !urls.any { Thread.currentThread().getContextClassLoader().URLs.contains(it) }
            """

        when:
        relocatedJarCreator.create(outputJar, [jarFile1, jarFile2, jarFile3, jarFile4, jarFile5, jarFile6, inputDirectory])

        then:

        TestFile[] contents = tmpDir.testDirectory.listFiles().findAll { it.isFile() }
        contents.length == 1
        contents[0] == outputJar
        handleAsJarFile(outputJar) { JarFile file ->
            List<JarEntry> entries = file.entries() as List

        given:
        buildFile << """
            task customTask {
                def outputDir = file("build/empty")
                outputs.dir outputDir withPropertyName "empty"
                outputs.cacheIf { true }
                doLast {
                    outputDir.mkdirs()
                }
            }
        """

        when:
        withBuildCache().run "customTask"