given:
        def newId = UniqueId.generate()

        when:
        def id = loader.user.id

        then:
        1 * globalScopedCacheBuilderFactory.baseDirForCrossVersionCache("user-id.txt") >> storeFile

        and:
        1 * storeFactory.create(storeFile, _) >> store

        and:
        1 * store.maybeUpdate(_) >> { ObjectHolder.UpdateAction action ->

    def cache = Stub(GlobalScopedCacheBuilderFactory)

    def "calculates file store directory"() {
        given:
        TestFile testCacheDir = temporaryFolder.file("test/cache")
        cache.baseDirForCrossVersionCache(CacheLayout.MODULES.key) >> testCacheDir

        when:
        def metaData = new DefaultArtifactCacheMetadata(cache)
        File fileStore = metaData.getFileStoreDirectory()

        then:

        return unscopedCacheBuilderFactory.cache(baseDirForCrossVersionCache(key));
    }

    @Override
    public File baseDirForCache(String key) {
        return cacheScopeMapping.getBaseDirectory(rootDir, key, VersionStrategy.CachePerVersion);
    }

    @Override
    public File baseDirForCrossVersionCache(String key) {

    private final File checkoutDir;
    private final File metadataDir;

    public VcsDirectoryLayout(BuildTreeScopedCacheBuilderFactory cacheBuilderFactory) {
        this.checkoutDir = cacheBuilderFactory.baseDirForCrossVersionCache("vcs-1");
        this.metadataDir = cacheBuilderFactory.baseDirForCache("vcsMetadata");
    }

    public File getMetadataDir() {
        return metadataDir;
    }

        then:
        service instanceof DirectoryBuildCacheService
        1 * config.getDirectory() >> null
        1 * config.getRemoveUnusedEntriesAfterDays() >> 10
        1 * globalScopedCache.baseDirForCrossVersionCache("build-cache-1") >> cacheDir
        1 * cacheRepository.cache(cacheDir) >> cacheBuilder
        1 * cacheConfigurations.getCleanupFrequency() >> Mock(Provider)
        0 * _
    }

    public DefaultArtifactCacheMetadata(GlobalScopedCacheBuilderFactory cacheBuilderFactory) {
        this.baseDir = cacheBuilderFactory.getRootDir();
        this.cacheDir = cacheBuilderFactory.baseDirForCrossVersionCache(CacheLayout.MODULES.getKey());
    }

    public DefaultArtifactCacheMetadata(GlobalScopedCacheBuilderFactory cacheBuilderFactory, File baseDir) {
        this(cacheBuilderFactory.createCacheBuilderFactory(baseDir));

     */
    File baseDirForCache(String key);

    /**
     * Returns the base directory that would be used for a cross Gradle version cache builder created by this factory.
     */
    File baseDirForCrossVersionCache(String key);

                    return oldValue;
                }
            }
        });
    }

    private ObjectHolder<UniqueId> store(ScopeParams params) {
        File file = params.cacheBuilderFactory.baseDirForCrossVersionCache(params.fileName);
        return storeFactory.create(file, params.description);
    }

    private static class ScopeParams {
        private final ScopedCacheBuilderFactory cacheBuilderFactory;

        File target;
        if (cacheDirectory != null) {
            target = resolver.resolve(cacheDirectory);
        } else {
            target = cacheBuilderFactory.baseDirForCrossVersionCache(BUILD_CACHE_KEY);
        }
        checkDirectory(target);

        @SuppressWarnings("deprecation")
        int removeUnusedEntriesAfterDays = configuration.getRemoveUnusedEntriesAfterDays();