configurationCache.assertStateStored()
    }

    def "file contents #usage used as build logic input"() {

        given:
        def configurationCache = newConfigurationCacheFixture()
        buildKotlinFile """
            val ciFile = layout.projectDirectory.file("ci")
            val isCi = providers.fileContents(ciFile)
            if (isCi.$expression) {
                tasks.register("run") {

            prefixPath.substringAfterLast("/")
        ).toFile()

    private
    fun File.withDirectory(path: String): File =
        resolve(path).apply {
            mkdirs()
        }

    private
    fun File.withSettings(text: String = ""): File =
        withFile("settings.gradle.kts", text)

    private
    fun File.withBuildScript(text: String = ""): File =
        withFile("build.gradle.kts", text)

}

// rotate checks to see whether the file f needs to be rotated,
// meaning to start a new counter file with a different date in the name.
// rotate is also used to open the file initially, meaning f.current can be nil.
// In general rotate should be called just once for each file.
// rotate will arrange a timer to call itself again when necessary.
func (f *file) rotate() {
	expire, cleanup := f.rotate1()
	cleanup()

	if err := ioutil.WriteFile(keyFile, []byte(testingcert.KeyFileContent), 0644); err != nil {
		t.Fatal(err)
	}
	caFile = path.Join(tempDir, "ca.pem")
	if err := ioutil.WriteFile(caFile, []byte(testingcert.CAFileContent), 0644); err != nil {
		t.Fatal(err)
	}
	return certFile, keyFile, caFile

                doLast {
                    println(file.get().asFile.text)
                }
            }
        """

        when:
        configurationCacheRun 'answer'

        then:
        '42' == file('build/dir/answer.txt').text
        outputContains '42'

        where:
        desc   | provider
        'dir'  | 'dir(computedDirName).map { it.file("answer.txt") }'

import org.gradle.internal.vfs.FileSystemAccess;
import org.gradle.internal.vfs.impl.AbstractVirtualFileSystem;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Duration;
import java.util.Collections;

public class ExampleBuildCacheClient {

        file("files/dir1/file1.txt") << ""
        file("files/dir2/file2.txt") << ""

        and:
        buildFile """
            def files = files("files/file0.txt", "files/dir1", "files/dir2", "files/dir3").elements.map {
                it.findAll { file ->
                    file.asFile.isDirectory()
                }
            }
            tasks.register("sync", Sync) {
                from files

        delegate,
        acceptedViolations,
        apiSourceFolders,
        baseVersion.get(),
        mainApiChangesJsonFile.asFile,
        rootProject.layout.projectDirectory,
        currentUpgradedPropertiesFile.get().asFile,
        baselineUpgradedPropertiesFile.get().asFile
    )
}
tasks.named("check").configure { dependsOn(checkBinaryCompatibility) }

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

 * limitations under the License.
 */

package org.gradle.internal.serialize.codecs.core

import org.gradle.api.file.Directory
import org.gradle.api.file.RegularFile
import org.gradle.api.internal.file.FileFactory
import org.gradle.internal.serialize.graph.Codec
import org.gradle.internal.serialize.graph.ReadContext
import org.gradle.internal.serialize.graph.WriteContext