* limitations under the License.
 */
package org.gradle.cache.internal;

import java.util.Map;

public class MapBackedCache<K, V> extends CacheSupport<K, V> {

    private final Map<K, V> map;

    public MapBackedCache(Map<K, V> map) {
        this.map = map;
    }

    @Override
    protected <T extends K> V doGet(T key) {
        return map.get(key);
    }

import org.gradle.cache.Cache;
import org.gradle.cache.internal.MapBackedCache;
import xsbti.compile.AnalysisStore;
import xsbti.compile.FileAnalysisStore;

import java.io.File;
import java.util.concurrent.ConcurrentHashMap;

public class AnalysisStoreProvider {

    private final Cache<File, AnalysisStore> cache = new MapBackedCache<>(new ConcurrentHashMap<>());

    AnalysisStore get(final File analysisFile) {

 */
package org.gradle.launcher.daemon.registry;

import org.gradle.cache.Cache;
import org.gradle.cache.FileLockManager;
import org.gradle.cache.internal.CacheAccessSerializer;
import org.gradle.cache.internal.MapBackedCache;
import org.gradle.internal.file.Chmod;
import org.gradle.internal.service.Provides;
import org.gradle.internal.service.ServiceRegistrationProvider;

import java.io.File;
import java.util.HashMap;

 */
package org.gradle.cache.internal

import spock.lang.Specification

import java.util.function.Supplier

class MapBackedCacheTest extends Specification {

    def cache(map = [:]) {
        new MapBackedCache(map)
    }

    def "has cache semantics"() {
        given:
        def map = [:]
        def cache = cache(map)

        expect:
        cache.get("a", { 1 } as Supplier) == 1

import org.gradle.api.logging.Logger;
import org.gradle.api.logging.Logging;
import org.gradle.api.tasks.WorkResult;
import org.gradle.api.tasks.WorkResults;
import org.gradle.cache.internal.MapBackedCache;
import org.gradle.internal.jvm.Jvm;
import org.gradle.internal.time.Time;
import org.gradle.internal.time.Timer;
import org.gradle.language.base.internal.compile.Compiler;
import org.gradle.util.internal.GFileUtils;