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

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

        // Use writeFile because the cache can internally recover from datafile
        // corruption, so we don't care at this level if it's corrupt
        fileAccess.writeFile(() -> cache.put(key, value));
    }

    @Override
    public void remove(final K key) {
        final BTreePersistentIndexedCache<K, V> cache = getCache();
        // Use writeFile because the cache can internally recover from datafile

            if (buildArtifacts) {
                files.each {
                    writeFile("file-file", writer, it)
                }
                files.filter { true }.each {
                    writeFile("file-filtered", writer, it)
                }

                incomingFiles.each {
                    writeFile("incoming-file", writer, it)
                }
                incomingArtifacts.each {

		os.RemoveAll(dir)
		log.Fatal(err)
	}
	tmpdir = dir

	writeFile("p1.go", `
		package p1

		func F() {
			println("hello from p1")
		}
	`)
	writeFile("p2.go", `
		package p2

		import "./p1"

		func F() {
			p1.F()
			println("hello from p2")
		}

		func main() {}
	`)
	writeFile("p3.go", `
		package main

		import "./p2"

		func main() {
			p2.F()

        given:
        def lockManager = new DefaultFileLockManager(metaDataProvider, contentionHandler)
        writeFile(lockManager)

        and:
        def lock = createLock(lockMode)
        def beforeUpdate = lock.state
        lock.close()

        and:
        writeFile(lockManager)
        writeFile(lockManager)

        when:
        lock = createLock(lockMode)
        def afterUpdate = lock.state