}

    /**
     * The directory where object files will be generated.
     */
    @OutputDirectory
    public File getOutputDir() {
        return outputDir;
    }

    public void setOutputDir(File outputDir) {
        this.outputDir = outputDir;
    }

    /**
     * Returns the header directories to be used for compilation.
     */
    @Incremental
    @PathSensitive(PathSensitivity.RELATIVE)

                    File outputFile = new File(outputDir, "out-" + index + ".txt");
                    workerConfiguration.setParams(index, outputFile);
                }
            });
        }
    }

    @OutputDirectory
    public File getOutputDir() {
        return outputDir;
    }

    @Input
    public int getOutputSize() {
        return outputSize;
    }

abstract class CodeGenerationTask : DefaultTask() {

    @get:OutputDirectory
    abstract val outputDir: DirectoryProperty

    protected
    abstract fun File.writeFiles()

    @Suppress("unused")
    @TaskAction
    fun run() {
        outputDir.get().asFile.apply {
            recreate()
            writeFiles()
        }
    }

    protected

        def projectName = args[0]
        def outputDir = new File(args[1])

        JavaTestProjectGenerator project = JavaTestProjectGenerator.values().find { it.projectName == projectName }
        if (project == null) {
            throw new IllegalArgumentException("Project not defined: $projectName")
        }
        def projectDir = new File(outputDir, projectName)

internal
class ClassPathBuilderScope(val outputDir: File)


internal
fun ClassPathBuilderScope.publicClass(name: String) {
    writeClassFileTo(outputDir, name, ACC_PUBLIC)
}


internal
fun ClassPathBuilderScope.publicInterface(name: String, vararg interfaces: String) {
    val internalName = InternalName.from(name)
    writeClassFileTo(
        outputDir,
        internalName,
        beginClass(

        File outputDir = getExtractedPluginRequestsClassesDirectory().get().dir(scriptPlugin.getId()).getAsFile();
        getScriptCompilationHandler().compileToDir(
            scriptPlugin.getFirstPassSource(), classLoaderScope.getExportClassLoader(), outputDir, outputDir, pluginsCompileOperation,
            FirstPassPrecompiledScript.class, Actions.doNothing());

                parameters.fileToReverse = file
                parameters.destinationDir = outputDir
            }
        }
    }
}
// end::task-implementation[]

tasks.register('reverseFiles', ReverseFiles) {
    outputDir = layout.buildDirectory.dir("reversed")
    source("sources")

    abstract DirectoryProperty getOutputDir()

    @TaskAction
    def compile() {
        def inFile = configFile.get().asFile
        logger.quiet("configuration file = $inFile")
        def dir = outputDir.get().asFile
        logger.quiet("output dir = $dir")
        def className = inFile.text.trim()
        def srcFile = new File(dir, "${className}.java")
        srcFile.text = "public class ${className} { ... }"
    }

    private
    fun extractPluginsFrom(vararg scriptPlugins: PrecompiledScriptPlugin) {
        extractPrecompiledScriptPluginPluginsTo(
            outputDir,
            scriptPlugins.asList()
        )
    }

    private
    fun outputFile(fileName: String) = outputDir.resolve(fileName)

    private
    fun scriptPlugin(fileName: String, text: String) = PrecompiledScriptPlugin(newFile(fileName, text))

    private

        def previousOutputSnapshot = Mock(FileSystemSnapshot)
        def previousOutputSnapshots = ImmutableSortedMap.of("outputDir", previousOutputSnapshot)
        def beforeExecutionOutputSnapshot = Mock(FileSystemSnapshot)
        def beforeExecutionOutputSnapshots = ImmutableSortedMap.of("outputDir", beforeExecutionOutputSnapshot)

        when:
        step.execute(work, context)
        then: