val outputDir =
            root.resolve("output")

        scriptPlugin(
            "my-script.gradle.kts",
            """

                package org.acme

            """
        ).writeScriptPluginAdapterTo(outputDir)

        val expectedFile =
            outputDir.resolve("org/acme/MyScriptPlugin.kt")

        assertThat(

        private final File outputDir;
        private final String inputArtifactPrefix;
        private final String outputDirPrefix;
        private final Builder delegate = TransformExecutionResult.builder();

        public OutputTypeInferringBuilder(File inputArtifact, File outputDir) {
            this.inputArtifact = inputArtifact;
            this.outputDir = outputDir;

            def taskName = binary.tasks.taskName("compile", markdownSourceSet.name)
            def outputDir = new File(binary.outputDir, markdownSourceSet.name)
            tasks.create(taskName, MarkdownHtmlCompile) { compileTask ->
                compileTask.source = markdownSourceSet.source
                compileTask.destinationDir = outputDir
                compileTask.smartQuotes = markdownSourceSet.smartQuotes

                def outputDir = file("build/dir1").toPath()
                inputs.file(inputFile)
                inputs.dir(inputDir)
                outputs.file(outputFile)
                outputs.dir(outputDir)
                doLast {
                    Files.createDirectories(outputFile.parent)
                    Files.createDirectories(outputDir)

            visitor.visitOutputProperty("file", TreeType.FILE, UnitOfWork.OutputFileValueSupplier.fromStatic(outputFile, TestFiles.fixed(outputFile)))
            visitor.visitLocalState(localStateFile)
            visitor.visitDestroyable(destroyableFile)
        }

        then:
        outputDir.assertIsEmptyDir()

    templateEngine = TemplateEngineType.FREEMARKER
    sourceFiles.from fileTree('src/templates')
    templateData.name = 'test'
    templateData.variables = [year: '2012']
    outputDir = file(layout.buildDirectory.dir('genOutput'))
}

interface Injected {
    @Inject FileSystemOperations getFs()
}

// tag::ad-hoc-task[]
tasks.register('processTemplatesAdHoc') {

        buildFile << """
            task createClasspathManifest {
                def outputDir = file("\$buildDir/\$name")

                inputs.files sourceSets.main.runtimeClasspath
                outputs.dir outputDir

                doLast {
                    outputDir.mkdirs()
                    file("\$outputDir/plugin-classpath.txt").text = sourceSets.main.runtimeClasspath.join("\\n")
                }
            }

        File outputFile = getOutputFile().getAsFile().get();
        File outputDir = outputFile.getParentFile();
        if (outputDir.exists() || outputFile.mkdirs()) {
            doGenerate(model, outputFile);
        } else {
            throw new GradleException("Unable to generate TOML dependencies file into " + outputDir);
        }
    }

    // The directory to write source files to
    @get:OutputDirectory
    abstract val outputDir: DirectoryProperty

    @TaskAction
    fun compile() {
        val inFile = configFile.get().asFile
        logger.quiet("configuration file = $inFile")
        val dir = outputDir.get().asFile
        logger.quiet("output dir = $dir")
        val className = inFile.readText().trim()

            "outputDir", emptyDirectory
        )
        def outputsBeforeExecution = ImmutableSortedMap.<String, FileSystemSnapshot> of(
            "outputDir", directoryWithStaleFile
        )
        def outputsAfterExecution = ImmutableSortedMap.<String, FileSystemSnapshot> of(
            "outputDir", directoryWithStaleFileAndOutput
        )