searchRequestBuilder.setQuery(
                            QueryBuilders.termsQuery(docIdField, deleteFileMap.keySet().toArray(new String[deleteFileMap.size()])));
                    searchRequestBuilder.setFetchSource(new String[] { docIdField }, StringUtil.EMPTY_STRINGS);
                    return true;
                }).forEach(m -> {

        public void sendError(int sc, String msg) {
            this.sendErrorCode = sc;
        }

        @Override
        public java.util.Collection<String> getHeaderNames() {
            return headers.keySet();
        }

        @Override
        public java.util.Collection<String> getHeaders(String name) {
            String value = headers.get(name);

     */
    protected void mergeResponseData(final Map<String, Object> dataMap, final Map<String, Object> responseDataMap) {
        dataMap.putAll(responseDataMap);
        dataMap.keySet()
                .stream()
                .filter(key -> key.endsWith(".overwrite")) //
                .collect(Collectors.toList())
                .forEach(key -> {

        if (!path.equals("\\")) {
            key += path;
        }

        key = key.toLowerCase(Locale.ROOT);

        final int searchLen = key.length();
        for (final String cachedKey : refs.map.keySet()) {
            final int cachedKeyLen = cachedKey.length();

            boolean match = false;
            if (cachedKeyLen == searchLen) {
                match = cachedKey.equals(key);

        if (random.nextBoolean()) {
          removeMinFromReplica(replica, mmHeap.poll());
        } else {
          removeMaxFromReplica(replica, mmHeap.pollLast());
        }
        for (Integer v : replica.keySet()) {
          assertThat(mmHeap).contains(v);
        }
        assertIntact(mmHeap);
        currentHeapSize--;
        assertEquals(currentHeapSize, mmHeap.size());
      }
    }

    Object[] lookupKeys = new Object[] {new Object(), new Object(), new Object()};
    Map<Object, Object> result = cache.getAll(asList(lookupKeys));
    assertThat(result.keySet()).containsExactlyElementsIn(asList(lookupKeys));
    for (Entry<Object, Object> entry : result.entrySet()) {
      Object key = entry.getKey();
      Object value = entry.getValue();

                            managedVersions.put(key, plugin.getVersion());
                        }
                    }
                }
            }
        }

        for (String key : versions.keySet()) {
            if (versions.get(key) == null && managedVersions.get(key) == null) {
                InputLocation location = plugins.get(key).getLocation("");

        if (random.nextBoolean()) {
          removeMinFromReplica(replica, mmHeap.poll());
        } else {
          removeMaxFromReplica(replica, mmHeap.pollLast());
        }
        for (Integer v : replica.keySet()) {
          assertThat(mmHeap).contains(v);
        }
        assertIntact(mmHeap);
        currentHeapSize--;
        assertEquals(currentHeapSize, mmHeap.size());
      }
    }

    Object[] lookupKeys = new Object[] {new Object(), new Object(), new Object()};
    Map<Object, Object> result = cache.getAll(asList(lookupKeys));
    assertThat(result.keySet()).containsExactlyElementsIn(asList(lookupKeys));
    for (Entry<Object, Object> entry : result.entrySet()) {
      Object key = entry.getKey();
      Object value = entry.getValue();

              return valueComparator.compare(
                  requireNonNull(map.get(left)), requireNonNull(map.get(right)));
            }
          };
      return keyOrdering.immutableSortedCopy(map.keySet());
    }

    abstract Class<?> getRawType(K type);

    abstract Iterable<? extends K> getInterfaces(K type);

    abstract @Nullable K getSuperclass(K type);