});
    }

    private static <T> Map<AccessorKey, T> diff(Map<AccessorKey, T> first, Map<AccessorKey, T> second) {
        return first.entrySet().stream()
            .filter(e -> !second.containsKey(e.getKey()))
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
    }

        final AtomicReference<String> sentIndex = new AtomicReference<>();
        final List<Map<String, Object>> sentDocList = new ArrayList<>();
        final SearchEngineClient client = new SearchEngineClient() {
            @Override
            public String[] addAll(final String index, final List<Map<String, Object>> docList,
                    final BiConsumer<Map<String, Object>, IndexRequestBuilder> options) {
                sentIndex.set(index);

        return idList;
    }

    protected static List<Map<String, Object>> readJobLog(final String namePrefix) {
        final List<Map<String, Object>> logList = readLogItems("joblog");
        final List<Map<String, Object>> resList = new ArrayList<>();
        for (Map<String, Object> elem : logList) {

      // pass
    }
  }

  public void testEmptyMap() {
    Map<Character, String> map = ImmutableMap.of();
    ArrayBasedEscaperMap fem = ArrayBasedEscaperMap.create(map);
    // Non-null array of zero length.
    assertEquals(0, fem.getReplacementArray().length);
  }

  public void testMapLength() {
    Map<Character, String> map =
        ImmutableMap.of(
            'a', "first",
            'z', "last");

 */
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);
    }

    @Override

import java.lang.annotation.RetentionPolicy;
import java.util.Map;
import java.util.Set;

/**
 * Optional features of classes derived from {@code Map}.
 *
 * @author George van den Driessche
 */
@SuppressWarnings("rawtypes") // maybe avoidable if we rework the whole package?
@GwtCompatible
public enum MapFeature implements Feature<Map> {
  /**

        set.clear();
    }

    private void assertFieldLogs(Map<String, List<String>> fieldLogMap) {
        @SuppressWarnings("unchecked")
        Map<String, List<String>> map = (Map<String, List<String>>) getMockRequest().getAttribute(Constants.FIELD_LOGS);
        if (fieldLogMap != null) {
            assertEquals(fieldLogMap, map);
        }
        map.clear();
    }

    private QueryContext buildQuery(String query) {

      return Collections2.transform(fromTable.values(), function);
    }

    @Override
    public Map<R, Map<C, V2>> rowMap() {
      Function<Map<C, V1>, Map<C, V2>> rowFunction =
          new Function<Map<C, V1>, Map<C, V2>>() {
            @Override
            public Map<C, V2> apply(Map<C, V1> row) {
              return Maps.transformValues(row, function);
            }
          };

        }
        return null;
    }

    protected Map<String, Object> ingest(final AccessResult<String> accessResult, final Map<String, Object> map) {
        if (ingestFactory == null) {
            return map;
        }
        Map<String, Object> target = map;
        for (final Ingester ingester : ingestFactory.getIngesters()) {
            try {

  }

  /**
   * Guaranteed to throw an exception and leave the map unmodified.
   *
   * @deprecated unsupported operation
   * @throws UnsupportedOperationException always
   */
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public void putAll(Map<? extends TypeToken<? extends B>, ? extends B> map) {
    throw new UnsupportedOperationException();
  }

  @Override