def produce() {
                    dirName.get().asFile.text = 'dir'
                }
            }

            abstract class Consumer extends DefaultTask {

                @OutputFile
                abstract RegularFileProperty getOutputFile()

                @TaskAction
                def consume() {
                    outputFile.get().asFile.write('42')
                }
            }

                inFile = file("in.txt")
                outFile = layout.buildDirectory.file("out.txt")
            }
            task transformer(type: InputTask) {
                inValue = producer.outFile.map { f -> f.asFile.text as Integer }.map { i -> i + 2 }
                outFile = file("out.txt")
            }
        """
        def input = file("in.txt")
        def output = file("out.txt")

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

            "-DintegTest.apiJarRepoLocation=${repoLocation.get().asFile.absolutePath}",
            "-DintegTest.kotlinVersion=${kotlinVersion.get()}"
        )
}

tasks.withType<IntegrationTest>() {
    val argument = objects.newInstance(IntegTestCommandLineArgumentProvider::class.java).apply {
        repoLocation.fileProvider(resolveTestRepo.flatMap { it.elements }.map { it.first().asFile })
        kotlinVersion = libs.kotlinVersion
    }

}

val ruleStoreDir = layout.projectDirectory.dir("src/changes/archunit-store")

tasks {
    val reorderRuleStore by registering(ReorderArchUnitRulesTask::class) {
        ruleFile = ruleStoreDir.file("stored.rules").asFile
    }

    test {
        // Looks like loading all the classes requires more than the default 512M
        maxHeapSize = "1g"

        // Only use one fork, so freezing doesn't have concurrency issues

            if (moduleBaseDir.exists()) {
                // Make sure artifacts do not pile up locally
                moduleBaseDir.deleteRecursively()
            }
        }

        doLast {
            localRepository.get().file("org/gradle/${baseName.get()}/maven-metadata.xml").asFile.apply {

}

tasks.jar.configure {
    val classpath = resolveManifestClasspath.flatMap { configuration ->
        configuration.elements.map { classpathDependency ->
            classpathDependency.joinToString(" ") { it.asFile.name }
        }
    }
    manifest.attributes("Class-Path" to classpath)
    if (app.mainClassName.isPresent) {
        manifest.attributes("Main-Class" to app.mainClassName)
    }

}

sourceSets.main {
    groovy.srcDir(generateLanguageAnnotations.flatMap { it.destDir })
    output.dir(prepareVersionsInfo.map { it.destFile.get().asFile.parentFile })
    output.dir(copyTestedVersionsInfo)
}

@CacheableTask
abstract class PrepareVersionsInfo : DefaultTask() {

    @get:OutputFile
    abstract val destFile: RegularFileProperty

    @InputDirectory
    abstract DirectoryProperty getJsonFileDirectory()

    @TaskAction
    void clean() {
        def jsonFileManager = new AcceptedApiChangesJsonFileManager()
        jsonFileDirectory.asFile.get().listFiles()
            ?.findAll { it.name.endsWith(".json") }
            ?.each { jsonFileManager.emptyAcceptedApiChanges(it) }
    }

                name = moduleIdentity.baseName.map { "${project.group}:$it"}
            }
        }
    }
    repositories {
        maven {
            name = "test"
            url = testRepoLocation.get().asFile.toURI()
        }
    }
}

val testRepoElements = configurations.consumable("testRepoElements") {
    outgoing.artifact(testRepoLocation) {
        builtBy( "publishMavenPublicationToTestRepository")
    }