public void storeLocally(BuildCacheKey key, File file) {
        cache.storeLocally(((BuildCacheKeyInternal) key).getHashCodeInternal(), file);
    }

    @Override
    public void withTempFile(HashCode key, Consumer<? super File> action) {
        cache.withTempFile(key, action);
    }

    @Override
    public void close() throws IOException {
        cache.close();
    }

        }
        fileAccessTracker.markAccessed(targetFile);
    }

    @Override
    public void withTempFile(HashCode key, Consumer<? super File> action) {
        persistentCache.withFileLock(() -> tempFileStore.withTempFile(key, action));
    }

    @Override
    public void close() {
        persistentCache.close();
    }

    String PARTIAL_FILE_SUFFIX = ".part";

    /**
     * Run the given action with a temp file allocated based on the given cache key.
     * The temp file will be deleted once the action is completed.
     */
    void withTempFile(HashCode key, Consumer<? super File> action);

    public DefaultBuildCacheTempFileStore(TemporaryFileFactory temporaryFileFactory) {
        this.temporaryFileFactory = temporaryFileFactory;
    }

    @Override
    public void withTempFile(HashCode key, Consumer<? super File> action) {
        File tempFile = temporaryFileFactory.createTemporaryFile(key + "-", PARTIAL_FILE_SUFFIX);
        try {
            action.accept(tempFile);
        } finally {

        if (!remote.canLoad()) {
            return Optional.empty();
        }
        AtomicReference<Optional<BuildCacheLoadResult>> result = new AtomicReference<>(Optional.empty());
        tmp.withTempFile(((BuildCacheKeyInternal) key).getHashCodeInternal(), file -> {
            Optional<BuildCacheLoadResult> remoteResult;
            try {

        void store(BuildCacheKey key, BuildCacheEntryWriter writer) throws BuildCacheException {
        }

        @Override
        void close() {

        }

        @Override
        void withTempFile(HashCode key, Consumer<? super File> action) {
        }
    }

        identity >> ":test"
        type >> CacheableEntity
    }
    Duration executionTime = Duration.ofMillis(123)
    Map<String, FileSystemSnapshot> snapshots = [:]

    def local = Mock(Local) {
        withTempFile(_ as HashCode, _ as Consumer) >> { key, action ->
            action.accept(tmpDir.file("file"))
        }
    }
    def localPush = true
    def remote = Mock(BuildCacheService)
    def remotePush = true