// 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
        )

For /f "tokens=1-3 delims=/: " %%a in ("%TIME%") do (if %%a LSS 10 (set timestamp=0%%a%%b%%c) else (set timestamp=%%a%%b%%c))
set timestamp=%timestamp:~0,6%
''' + "set outputDir=\${relativeToRoot}\\\\output\\\\%timestamp%" + '''
md %outputDir%
set outputLog=%outputDir%\\\\output.txt
set errorLog=%outputDir%\\\\error.txt
echo %outputLog%
''' + value + ' 1>%outputLog% 2>%errorLog%'
            }
        """
    }

    File getHostGradleWrapperFile() {

    @PathSensitive(PathSensitivity.RELATIVE)
    @InputArtifact
    abstract Provider<FileSystemLocation> getInput()

    @Override
    void transform(TransformOutputs outputs) {
        def outputDir = outputs.dir("${input.get().asFile.name}.loc")
        println("Running transform on ${input.get().asFile.name}, incremental: ${inputChanges.incremental}")
        inputChanges.getFileChanges(input).forEach { change ->          // <2>

        source.forEach { file ->
            workQueue.submit(ReverseFile::class) {
                fileToReverse = file
                destinationDir = outputDir
            }
        }
        // end::worker-daemon[]
    }
}

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

    def "notifies listener about specific outputs changing"() {
        def outputDir = file("output-dir")
        def localStateDir = file("local-state-dir")
        def destroyableDir = file("destroyable-dir")
        def changingOutputs = [
            outputDir.absolutePath,
            destroyableDir.absolutePath,
            localStateDir.absolutePath
        ]

        when:

				c.EmitMarkdown = true
				c.EmitHTMLFragmentWithFrontMatter = true
				c.ManPageInfo = *hdr
			}

			return EmitCollateral(root, &c)
		},
	}

	cmd.Flags().StringVarP(&c.OutputDir, "outputDir", "o", c.OutputDir, "Directory where to generate the collateral files")
	cmd.Flags().BoolVarP(&all, "all", "", all, "Produce all supported collateral files")

        val oldSuperTypes = Properties()
        val outputDir = outputs.dir("instrumentation")
        val superTypesFile = File(outputDir, DIRECT_SUPER_TYPES_FILE)
        if (superTypesFile.exists()) {
            // Load properties with reader to use UTF_8 Charset
            superTypesFile.reader().use { reader -> oldSuperTypes.load(reader) }
        }
        val instrumentedClassesFile = File(outputDir, INSTRUMENTED_CLASSES_FILE)

    val unpackKotlinJsStdlib by registering {
        group = "build"
        description = "Unpack the Kotlin JavaScript standard library"
        val outputDir = file("$buildDir/$name")
        inputs.property("compileClasspath", configurations.compileClasspath.get())
        outputs.dir(outputDir)
        doLast {
            val kotlinStdLibJar = configurations.compileClasspath.get().single {

    }

    @TaskAction
    fun compile() {
        outputDir.withOutputDirectory { outputDir ->
            val scriptFiles = sourceFiles.map { it.path }
            if (scriptFiles.isNotEmpty())
                compileKotlinScriptModuleTo(
                    outputDir,
                    compilerOptions,
                    kotlinModuleName,
                    scriptFiles,