given:
        def cacheDir = temporaryFolder.getTestDirectory()
        def filter = new NonReservedFileFilter([cacheDir.file("cache.properties"), cacheDir.file("gc.properties"), cacheDir.file("cache.lock")])

        expect:
        !filter.accept(cacheDir.file("cache.properties"))
        !filter.accept(cacheDir.file("gc.properties"))
        !filter.accept(cacheDir.file("cache.lock"))

        and:

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
                }
            }

                logger.lifecycle("Removing old cache directory : $cacheDir")
                delete {
                    delete(cacheDir)
                }
            }
        }
    }
}


fun FileSystemOperations.removeCachedScripts(cachesDir: File) {
    if (cachesDir.isDirectory) {
        cachesDir.listFiles()
            .filter { it.isDirectory }

        given:
        buildscriptWithDependency(snapshotModule)

        when:
        succeeds 'resolve'

        then:
        def resource = findFile(cacheDir, 'resources-*/**/maven-metadata.xml')
        def files = findFiles(cacheDir, "files-*/**/*")
        files.size() == 2

        when:
        forceCleanup(gcFile)

        and:
        succeeds 'help'

        then:

        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
                    }
                }
            }
        }
    }