FileCollection sources

                @OutputFile
                File outputFile

                @TaskAction
                def exec() {
                    outputFile.text = sources*.name.join("\\n")
                }
            }
        """
        buildFile << """
            task test(type: PathSensitiveTask) {
                outputFile = file("build/output.txt")
            }
        """

                @InputFiles
                abstract ConfigurableFileCollection getInputFiles()

                @OutputFile
                abstract RegularFileProperty getOutputFile()

                @TaskAction
                void run() {
                    outputFile.get().asFile.text = inputFiles.files.collect { it.text }.join()
                }
            }

        outputDirectories.add(outputDir);
        return outputDir;
    }

    @Override
    public File file(Object path) {
        File outputFile = resolveAndRegister(path, location -> GFileUtils.mkdirs(location.getParentFile()));
        outputFiles.add(outputFile);
        return outputFile;
    }

    private File resolveAndRegister(Object path, Consumer<File> prepareOutputLocation) {
        File output = resolver.resolve(path);

        <executions>
          <execution>
            <phase>validate</phase>
            <goals>
              <goal>eval</goal>
            </goals>
            <configuration>
              <outputFile>target/pom.properties</outputFile>
              <expressions>
                <expression>project/properties</expression>
              </expressions>
            </configuration>
          </execution>
        </executions>

    embeddedKotlinBaseDependencies(libs.kotlinReflect)
}

val writeEmbeddedKotlinDependencies by tasks.registering {
    val outputFile = layout.buildDirectory.file("embeddedKotlinDependencies/gradle-kotlin-dsl-embedded-kotlin.properties")
    outputs.file(outputFile)
    val values = embeddedKotlinBaseDependencies
    inputs.files(values)
    val skippedModules = setOf(project.name, "distributions-dependencies")

    def "can register files, directories and file collections"() {
        given:
        def dir1 = file('dir1')
        File file1 = file('someDir/test1.txt')
        File outputFile = file('someDir/test2.txt')
        def outputFiles = TestFiles.fixed(outputFile)


        when:
        registry.registerOutputs(dir1)
        registry.registerOutputs(file1)
        registry.registerOutputs(outputFiles)

        def outputFile = fileSnapshot("outputs", TestHashCodes.hashCodeFrom(345))

        def emptyDirectory = directorySnapshot()
        def directoryWithStaleFile = directorySnapshot(staleFile)
        def directoryWithStaleFileAndOutput = directorySnapshot(outputFile, staleFile)
        def directoryWithOutputFile = directorySnapshot(outputFile)

            task adHocTask {
                outputs.cacheIf { true }
                def outputFile = file("\$buildDir/output.txt")
                inputs.file(file("input.txt"))
                outputs.file(outputFile)
                doLast {
                    outputFile.parentFile.mkdirs()
                    outputFile.text = file("input.txt").text
                }
            }

            task executedTask {

                    def inputFile = input.get().asFile
                    println "Transforming " + inputFile.name
                    def outputFile = outputs.file(inputFile.name + ".green")
                    outputFile.text = "green"
                }
            }
        """

        buildFile << """
            allprojects { p ->
                dependencies {

        objCPCHCompile.targetPlatform = platform
        objCPCHCompile.compilerArgs = ["arg"]
        objCPCHCompile.macros = [def: "value"]
        objCPCHCompile.objectFileDir = temporaryFolder.file("outputFile")
        objCPCHCompile.source sourceFile
        execute(objCPCHCompile)

        then:
        _ * toolChain.outputType >> "c"
        platform.getName() >> "testPlatform"