final Map<String, String> paramEnvMap = systemHelper.getFilteredEnvMap(fessConfig.getCrawlerDataEnvParamKeyPattern());
        final Map<String, String> configParamMap = config.getHandlerParameterMap().entrySet().stream().map(e -> {
            final String key = e.getKey();
            String value = e.getValue();
            for (final Map.Entry<String, String> entry : paramEnvMap.entrySet()) {

 * for search result filtering and navigation.
 */
public class FacetResponse {
    /**
     * Map containing query facet counts, where keys are decoded query strings
     * and values are document counts for each query.
     */
    protected Map<String, Long> queryCountMap = new LinkedHashMap<>();

    /**
     * List of field facets containing aggregated field values and their counts.
     */

    private final RegularImmutableMap<K, ?> map;

    KeySet(RegularImmutableMap<K, ?> map) {
      this.map = map;
    }

    @Override
    K get(int index) {
      return map.entries[index].getKey();
    }

    @Override
    public boolean contains(@Nullable Object object) {
      return map.containsKey(object);
    }

    @Override
    boolean isPartialView() {

            Map<String, Object> doc = result.getDocumentList().get(i);
            assertEquals(String.valueOf(i), doc.get("id"));
            assertEquals(i, doc.get("index"));
        }
    }

    public void test_toString() {
        // Test toString method
        Map<String, Object> doc = new HashMap<>();
        doc.put("key", "value");

     * Returns {@literal true} if the given {@link Map} is {@literal null} or empty.
     *
     * @param map the map
     * @return {@literal true} if the map is {@literal null} or empty
     */
    public static boolean isEmpty(final Map<?, ?> map) {
        return map == null || map.isEmpty();
    }

    /**
     * Returns {@literal true} if the given {@link Map} is not {@literal null} and not empty.
     *

 * present in the map to be reclaimed by the garbage collector. Entries with reclaimed keys or
 * values may be removed from the map on each map modification or on occasional map accesses; such
 * entries may be counted by {@link Map#size}, but will never be visible to read or write
 * operations. A partially-reclaimed entry is never exposed to the user. Any {@link Map.Entry}

        Map<Object, Object> map = new HashMap<Object, Object>();
        assertEquals(0, (int) StreamUtil.stream(map).get(s -> s.toArray().length));
    }

    public void test_ofMap() {
        Map<String, String> map = new HashMap<String, String>();
        map.put("key1", "value1");
        map.put("key2", "value2");

	Targets                    map[string]replication.StatusType // map of ARN->replication status for ongoing replication activity
	PurgeTargets               map[string]VersionPurgeStatusType // map of ARN->VersionPurgeStatus for all the targets
	ResetStatusesMap           map[string]string                 // map of ARN-> stringified reset id and timestamp for all the targets
}

  public void testEmptyBuilder() {
    ImmutableBiMap<String, Integer> map = new Builder<String, Integer>().build();
    assertEquals(Collections.<String, Integer>emptyMap(), map);
    assertEquals(Collections.<Integer, String>emptyMap(), map.inverse());
    assertSame(ImmutableBiMap.of(), map);
  }

  public void testSingletonBuilder() {
    ImmutableBiMap<String, Integer> map = new Builder<String, Integer>().put("one", 1).build();

    /**
     * Constructs an instance.
     *
     * @param key
     *            Key of the map
     * @param map
     *            Map
     */
    public IllegalKeyOfBeanMapException(final Object key, final Map<?, ?> map) {
        super("key", "ECL0016", asArray(key, map));
    }