abstract val outputDir: DirectoryProperty

    protected
    abstract fun File.writeFiles()

    @Suppress("unused")
    @TaskAction
    fun run() {
        outputDir.get().asFile.apply {
            recreate()
            writeFiles()
        }
    }

    protected
    fun File.writeFile(relativePath: String, text: String) {
        resolve(relativePath).apply {
            parentFile.mkdirs()

            return subproject(':').task(name)
        }

        void writeFiles() {
            super.writeFiles()
            settingsFile << """
                ${builds.keySet().collect { "includeBuild " + quote(it) }.join('\n')}
            """.stripIndent()
            builds.values().each { it.writeFiles() }
        }
    }

    class BuildFixture {
        final String name

abstract class GenerateKotlinDslPluginsExtensions : CodeGenerationTask() {

    @get:Input
    abstract val kotlinDslPluginsVersion: Property<Any>

    override fun File.writeFiles() {
        writeFile(
            "org/gradle/kotlin/dsl/plugins/Version.kt",
            """$licenseHeader
package org.gradle.kotlin.dsl.plugins


internal

    abstract val kotlinDslPluginsVersion: Property<String>

    override fun File.writeFiles() {

        val kotlinDslPluginsVersion = kotlinDslPluginsVersion.get()
        val embeddedKotlinVersion = embeddedKotlinVersion.get()

        // IMPORTANT: kotlinDslPluginsVersion should NOT be made a `const` to avoid inlining
        writeFile(
            "org/gradle/kotlin/dsl/support/KotlinDslPlugins.kt",
            """$licenseHeader

            ConfigurationMetadata configuration = transformed.getConfiguration(configurationName);
            writeConfiguration(encoder, configuration);
            writeFiles(encoder, configuration.getArtifacts());
            writeDependencies(encoder, configuration, deduplicationDependencyCache);
        }
    }

	common.LogAndPrintf("\n")
	writeFiles(archive.AnalyzePath(tempDir, common.StrNamespaceAll), out, config.DryRun)
}

func writeFiles(dir string, files map[string]string, dryRun bool) {
	defer logRuntime(time.Now(), "Done writing files for dir %v", dir)
	for fname, text := range files {
		writeFile(filepath.Join(dir, fname), text, dryRun)
	}
}

func writeFile(path, text string, dryRun bool) {
	if dryRun {

        encoder.writeSmallInt(derivedVariants.size());
        for (ConfigurationMetadata derivedVariant : derivedVariants) {
            writeConfiguration(encoder, derivedVariant);
            writeFiles(encoder, derivedVariant.getArtifacts());
            writeDerivedVariantExtra(encoder, derivedVariant, deduplicationDependencyCache);
        }
    }

   * the operating system's default line separator. This method is equivalent to {@code
   * writeLines(lines, System.getProperty("line.separator"))}.
   *
   * @throws IOException if an I/O error occurs while writing to this sink
   */
  public void writeLines(Iterable<? extends CharSequence> lines) throws IOException {
    writeLines(lines, System.getProperty("line.separator"));
  }

  /**

        then:
        1 * fileAccess.writeFile(!null) >> { Runnable action -> action.run() }
        1 * backingCache.put("key", "value")
        0 * _._
    }

    def "holds write lock while removing entry from cache"() {
        given:
        cacheOpened()

        when:
        cache.remove("key")

        then:
        1 * fileAccess.writeFile(!null) >> { Runnable action -> action.run() }

        lock.updateFile {}

        then:
        thrown FileIntegrityViolationException
    }

    def "writeFile does not throw integrity exception when not cleanly unlocked file"() {
        given:
        unlockUncleanly()

        when:
        createLock(Exclusive).writeFile {}

        then:
        notThrown FileIntegrityViolationException
    }

    def "can lock a file"() {