def output = outputFile.get().asFile
        output.text = message
        logger.quiet("Wrote '${message}' to ${output}")
    }
}

abstract class Consumer extends DefaultTask {
    @InputFile
    abstract RegularFileProperty getInputFile()

    @TaskAction
    void consume() {
        def input = inputFile.get().asFile
        def message = input.text

        def output = outputFile.get().asFile
        output.text = message
        logger.quiet("Wrote '${message}' to ${output}")
    }
}

abstract class Consumer extends DefaultTask {
    @InputFiles
    abstract ListProperty<RegularFile> getInputFiles()

    @TaskAction
    void consume() {
        inputFiles.get().each { inputFile ->
            def input = inputFile.asFile
            def message = input.text

    }
}
// end::integTest[]

// tag::distributionPathInput[]
// Don't do this! Breaks relocatability!
tasks.integTest {
    systemProperty("distribution.location", layout.buildDirectory.dir("dist").get().asFile.absolutePath)
}
// end::distributionPathInput[]

// tag::distributionDirInput[]
abstract class DistributionLocationProvider : CommandLineArgumentProvider {  // <1>
    @get:InputDirectory

        link instanceof LinkExecutable
        link.linkedFile.get().asFile == projectDir.file("build/exe/$exeDir" + OperatingSystem.current().getExecutableName("test_app"))

        def install = project.tasks[installTask]
        install instanceof InstallExecutable
        install.installDirectory.get().asFile == projectDir.file("build/install/$exeDir")

        where:

                def binDir = file("$buildDir/bin")
                doLast {
                    assert mainGroovyDestDir.get().asFile == compileGroovyDestinationDir.get().asFile
                    assert mainGroovyDestDir.get().asFile == binDir
                }
            }
        '''

        expect:
        succeeds 'assertDirectoriesAreEquals'
    }

    @OutputDirectory
    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")

    @get:InputArtifact
    abstract val input: Provider<FileSystemLocation>

    override
    fun transform(outputs: TransformOutputs) {
        val outputDir = outputs.dir("${input.get().asFile.name}.loc")
        println("Running transform on ${input.get().asFile.name}, incremental: ${inputChanges.isIncremental}")
        inputChanges.getFileChanges(input).forEach { change ->          // <2>
            val changedFile = change.file

                @Inject abstract InputChanges getInputChanges()

                @Override
                void transform(TransformOutputs outputs) {
                    def input = inputArtifact.get().asFile
                    println "processing [\${input.name}]"
                    def output = outputs.file("\${input.name}.\${parameters.targetColor.get()}")

            @Override
            void execute(ExecSpec execSpec) {
                execSpec.executable = buildBuilderInstall.file("bin/build-builder").get().asFile
                execSpec.workingDir = generatedDir.get().asFile
                execSpec.args = resolvedArgs
            }
        })
    }

        writeFile(value.asFile)
    }

    override suspend fun ReadContext.decode(): Directory {
        return fileFactory.dir(readFile())
    }
}


class RegularFileCodec(private val fileFactory: FileFactory) : Codec<RegularFile> {
    override suspend fun WriteContext.encode(value: RegularFile) {
        writeFile(value.asFile)
    }