class TestBuildCache {
    private final TestFile cacheDir

    TestBuildCache(File cacheDir) {
        this.cacheDir = new TestFile(cacheDir)
    }

    def localCacheConfiguration(boolean push = true) {
        """
            buildCache {
                local {
                    directory = '${cacheDir.absoluteFile.toURI()}'
                    push = $push
                }
            }

        then:
        service instanceof DirectoryBuildCacheService
        1 * config.getDirectory() >> cacheDir
        1 * config.getRemoveUnusedEntriesAfterDays() >> 10
        1 * resolver.resolve(cacheDir) >> cacheDir
        1 * cacheRepository.cache(cacheDir) >> cacheBuilder
        1 * cacheConfigurations.getCleanupFrequency() >> Mock(Provider)
        0 * _
    }

        _ * 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')
        CacheBuilder cacheBuilder = Mock()

    }

    @Override
    public PersistentCache open(File cacheDir, String displayName, Map<String, ?> properties, LockOptions lockOptions, @Nullable Consumer<? super PersistentCache> initializer, CacheCleanupStrategy cacheCleanupStrategy) throws CacheOpenException {
        lock.lock();
        try {
            return doOpen(cacheDir, displayName, properties, lockOptions, initializer, cacheCleanupStrategy);
        } finally {

                }
            } else {
                progressMonitor.incrementSkipped();
            }
        }
    }

    private void deleteCacheDir(File cacheDir) throws IOException {
        LOGGER.debug("Deleting version-specific cache directory at {}", cacheDir);
        deleter.deleteRecursively(cacheDir);
    }

    def cacheDir = temporaryFolder.createDir(CacheLayout.MODULES.key)
    def resourcesDir = cacheDir.createDir(CacheLayout.RESOURCES.key)
    def filesDir = cacheDir.createDir(CacheLayout.FILE_STORE.key)
    def metaDataDir = cacheDir.createDir(CacheLayout.META_DATA.key)
    def artifactCacheMetadata = Stub(ArtifactCacheMetadata) {
        getCacheDir() >> cacheDir

                    if (isLastRun(context, invocationSettings) && checkIfCacheUsed) {
                        assert !(buildCacheServer.cacheDir.allDescendants().empty && cacheDir.allDescendants().isEmpty())
                        assert pushToRemote || buildCacheServer.cacheDir.allDescendants().empty
                    }
                }
            }
        }
    }

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