expectedPaths
    }

    def createSupplier(Set<File> javaHomes) {
        def cacheDir = newCacheDirProvider(javaHomes)
        new AutoInstalledInstallationSupplier(new DefaultToolchainConfiguration(), cacheDir)
    }

    private JdkCacheDirectory newCacheDirProvider(javaHomes) {
        new JdkCacheDirectory() {
            @Override

    def store = new DefaultPersistentDirectoryStore(cacheDir, "<display>", mode(OnDemand), cacheCleanup, lockManager, Mock(ExecutorFactory), buildOperationRunner)

    def "has useful toString() implementation"() {
        expect:
        store.toString() == "<display> ($cacheDir)"
    }

    def "open creates directory if it does not exist"() {
        given:
        cacheDir.assertDoesNotExist()

        when:

            return withExclusiveAccessToCache(baseDir) { cacheDir ->
                action(ReadableLayout(cacheDir))
            }
        }

        override fun <T> useForStore(action: (Layout) -> T): T =
            withExclusiveAccessToCache(baseDir) { cacheDir ->
                // TODO GlobalCache require(!cacheDir.isDirectory)
                Files.createDirectories(cacheDir.toPath())

        this.webapp.setInitParameter("org.eclipse.jetty.servlet.Default.useFileMappedBuffer", "false")
    }

    TestFile getCacheDir() {
        Preconditions.checkNotNull(cacheDir)
    }

    List<TestFile> listCacheFiles() {
        cacheDir.listFiles().findAll { it.name ==~ /\p{XDigit}{${Hashing.defaultFunction().hexDigits}}/ }.sort()
    }

    void deleteCacheFiles() {
        listCacheFiles().each { it.delete() }
    }

    @Override
    public PersistentCache open(File cacheDir, String displayName, Map<String, ?> properties, LockOptions lockOptions, @Nullable Consumer<? super PersistentCache> initializer, @Nullable CacheCleanupStrategy cacheCleanupStrategy) throws CacheOpenException {
        GFileUtils.mkdirs(cacheDir);

            cacheDir = new File(userHomeDirProvider.getGradleUserHomeDirectory(), UNDEFINED_BUILD + Hashing.hashString(buildLayout.getRootDirectory().getAbsolutePath()));
        } else {
            // Use the .gradle directory in the build root directory
            cacheDir = new File(buildLayout.getRootDirectory(), ".gradle");
        }
        if (cacheDir.exists() && !cacheDir.isDirectory()) {

        )
    }

    static class GradleDistDirs {
        private final TestFile cacheDir
        private final TestFile distDir
        private final TestFile customDistDir

        GradleDistDirs(TestFile cacheDir, TestFile distDir, TestFile customDistDir) {
            this.cacheDir = cacheDir
            this.distDir = distDir
            this.customDistDir = customDistDir
        }

        1 * cacheBuilder.open() >> { cache }
        _ * cache.getBaseDir() >> cacheDir
        1 * cache.useCache(_)
        jarFile == resolvedFile

        where:
        identifier << ["api", "test-kit"]
    }

    def "reuses existing JAR file if existent"() {
        def cacheDir = tmpDir.testDirectory
        def jarFile = cacheDir.file("gradle-api-${gradleVersion}.jar")
        def cacheBuilder = Mock(CacheBuilder)

class DirectoryBuildCacheTest extends Specification {
    @Rule
    TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())
    def cacheDir = temporaryFolder.createDir("cache")
    def persistentCache = Mock(PersistentCache) {
        getBaseDir() >> cacheDir
        withFileLock(_) >> { Runnable r -> r.run() }
    }
    def fileAccessTracker = Mock(FileAccessTracker)

    def "local build cache configuration is exposed"() {
        given:
        def cacheDir = temporaryFolder.file("cache-dir").createDir()
        settingsFile << """
            buildCache {
                local {
                    enabled = true
                    directory = '${cacheDir.absoluteFile.toURI().toString()}'
                    push = true
                }
            }
        """