}
}


internal
fun Encoder.writeDefaultClassPath(classPath: ClassPath) {
    writeCollection(classPath.asFiles) {
        writeFile(it)
    }
}


internal
fun Encoder.writeTransformedClassPath(classPath: TransformedClassPath) {
    writeCollection(classPath.asFiles.zip(classPath.asTransformedFiles)) {
        writeFile(it.first)
        writeFile(it.second)
    }
}


internal

        1 * cacheBuilder.open() >> { initializer.accept(cache); return cache }
        _ * cache.getBaseDir() >> cacheDir
        1 * cache.close()
        0 * cache._
        classpath.asFiles == [jarFile]
        jarFile.file
    }

    def reusesTheCachedClasspath() {
        def cacheDir = tmpDir.testDirectory
        def jarFile = cacheDir.file('gradle-worker.jar')

    def "uses modules to determine gradle API classpath"() {
        when:
        def classpath = provider.findClassPath("GRADLE_API")

        then:
        classpath.asFiles.collect{it.name} == [
            "gradle-worker-main-runtime",
            "gradle-launcher-runtime",
            "gradle-cli-runtime",
            "gradle-workers-runtime",

        fileAccess.updateFile(maybeUpdater);
        return maybeUpdater.result;
    }

    private void serialize(T newValue) {
        try {
            if (!cacheFile.isFile()) {
                cacheFile.createNewFile();
            }
            chmod.chmod(cacheFile.getParentFile(), 0700); // read-write-execute for user only
            chmod.chmod(cacheFile, 0600); // read-write for user only

            File candidate = new File(exeName);
            if (candidate.isFile()) {
                return candidate;
            }
            return null;
        }
        for (File dir : getPath()) {
            File candidate = new File(dir, exeName);
            if (candidate.isFile()) {
                return candidate;
            }
        }

        return null;
    }

interface IgnoredConfigurationInputs {
    /**
     * Checks if the [file] should be excluded from the configuration inputs fingerprint if it participates
     * in file system checks, such as [File.exists], [File.isFile] etc.
     */
    fun isFileSystemCheckIgnoredFor(file: File): Boolean

            return DefaultFileMetadata.missing(AccessType.DIRECT);
        }
        if (f.isDirectory()) {
            return DefaultFileMetadata.directory(AccessType.DIRECT);
        }
        if (f.isFile()) {
            return DefaultFileMetadata.file(f.lastModified(), f.length(), AccessType.DIRECT);
        }
        throw new UncheckedIOException("Unsupported file type for " + f.getAbsolutePath());
    }

            File dir = new File(cache.getBaseDir(), "maps/" + hash + "/" + moduleMap.getModuleName());
            File moduleMapFile = new File(dir, "module.modulemap");
            if (!moduleMapFile.isFile()) {
                generateFile(moduleMapFile, moduleMap.getModuleName(), moduleMap.getPublicHeaderPaths());
            }
            return moduleMapFile;
        });
    }

    @Override

    inner class ReadableConfigurationCacheStateFile(
        private val file: File,
        override val stateType: StateType
    ) : ConfigurationCacheStateFile {
        override val exists: Boolean
            get() = file.isFile

        override val stateFile: StateFile
            get() = StateFile(stateType, file)

        override fun outputStream(): OutputStream =
            throw UnsupportedOperationException()

            cache.open()
        } finally {
            cache.close()
        }

        then:
        0 * _  // Does not call initialization action.
        dir.file("cache.properties").isFile()
        dir.file("some-file").isFile()
    }

    def "will rebuild cache if not unlocked cleanly"() {
        given:
        def dir = temporaryFolder.testDirectory.createDir("cache")
        def initialized = false