public ClassLoader get(K key, Callable<ClassLoader> loader) throws Exception {
        return cache.get(key, loader);
    }

    public void clear() {
        cache.invalidateAll();
    }

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

    }

    def added(TestFile sourceFile) {
        virtualFileSystem.invalidateAll()
        modifiedFiles << sourceFile
        graph[sourceFile] = []
    }

    def sourceAdded(TestFile sourceFile, List<File> deps = []) {
        virtualFileSystem.invalidateAll()
        sourceFiles << sourceFile
        modifiedFiles << sourceFile
        graph[sourceFile] = deps
    }

        try {
            for (ClassLoader classLoader : classLoaderDetails.asMap().keySet()) {
                ClassLoaderUtils.tryClose(classLoader);
            }
            classLoaderDetails.invalidateAll();
            classLoaderIds.invalidateAll();
        } finally {
            lock.unlock();
        }
    }

            LOG.info("Invalidating in-memory cache of {}", cacheId);
            outOfDate = true;
        }
        if (outOfDate) {
            inMemoryCache.invalidateAll();
        }
        delegate.afterLockAcquire(currentCacheState);
    }

    @Override
    public void finishWork() {
        delegate.finishWork();
    }

    @Override

        store.open(initAction, factory);
    }

    @Override
    public void close() {
        flush();
        indexBlockCache.invalidateAll();
        store.close();
    }

    @Override
    public void clear() {
        dirty.clear();
        indexBlockCache.invalidateAll();
        store.clear();
    }

    @Override
    public void flush() {

        then:
        collectFiles(filteredOutputs) == [outputDir]

        when:
        def outputDirFile = outputDir.file("in-output-dir").createFile()
        virtualFileSystem.invalidateAll()
        def afterExecution = snapshotOutput(outputDir)
        filteredOutputs = filterOutputAfterExecution(EMPTY, beforeExecution, afterExecution)
        then:

    /**
     * Removes any information at the absolute paths from the VFS.
     */
    void invalidate(Iterable<String> locations);

    /**
     * Removes any information from the VFS.
     */
    void invalidateAll();

                return directory(location, [])
            } as Supplier<FileSystemLocationSnapshot>)
        }
        async {
            thread.blockUntil.snapshottingStarted
            vfs.invalidateAll()
            instant.invalidated
        }
        then:
        instant.snapshottingStarted < instant.invalidated
        instant.invalidated < instant.snapshottingFinished

        }
    }

    @Override
    public void close() {
        try {
            CompositeStoppable.stoppable(connections.asMap().values()).stop();
        } finally {
            connections.invalidateAll();
        }
    }

    @NonNullApi
    private class ConsumerConnectionCreator implements Callable<ConsumerConnection> {
        private final Distribution distribution;

                userHomeServiceRegistry.getCurrentServices().ifPresent(serviceRegistry -> {
                    VirtualFileSystem virtualFileSystem = serviceRegistry.get(VirtualFileSystem.class);
                    virtualFileSystem.invalidateAll();
                });
            }
        }
    }

    @Override
    public void stop() {
        // If we are shutting down, it's not important to finish cleaning the VFS
        executor.shutdownNow();