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)

        isTransformed("changing-1.2.jar", "changing-1.2.jar.txt")
        isTransformed("snapshot-1.2-SNAPSHOT.jar", "snapshot-1.2-SNAPSHOT.jar.txt")
        def outputDir1 = outputDir("changing-1.2.jar", "changing-1.2.jar.txt")
        def outputDir2 = outputDir("snapshot-1.2-SNAPSHOT.jar", "snapshot-1.2-SNAPSHOT.jar.txt")

        when:
        // No changes
        server.resetExpectations()
        m1.pom.expectHead()

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());

        touch(task.outputDirs.get(0).getParentFile())

        when:
        execute(task)

        then:
        def e = thrown WorkValidationException
        validateException(task, e, cannotWriteToDir {
            property('outputDirs')
                .dir(task.outputDirs[0])
                .ancestorIsNotDirectory(task.outputDirs[0].parentFile)
                .includeLink()

                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