final Map<K, V> map;

    MapMultimap(Map<K, V> map) {
      this.map = checkNotNull(map);
    }

    @Override
    public int size() {
      return map.size();
    }

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

    @Override

                            final String label = locale.getDisplayName(displayLocale);
                            final Map<String, String> map = new HashMap<>(2);
                            map.put(Constants.ITEM_LABEL, label);
                            map.put(Constants.ITEM_VALUE, lang);
                            langItems.add(map);
                        }
                        return langItems;
                    }
                });

     * Determines if the given document data matches the configured match expression.
     *
     * @param map the document data as a map of field names to values
     * @return true if the document matches the expression, false otherwise
     */
    public boolean match(final Map<String, Object> map) {

        if (map == null || map.isEmpty() || matchExpression == null) {
            return false;
        }

    extends AbstractMapBasedMultimap<K, V> implements SetMultimap<K, V> {
  /**
   * Creates a new multimap that uses the provided map.
   *
   * @param map place to store the mapping from each key to its corresponding values
   */
  protected AbstractSetMultimap(Map<K, Collection<V>> map) {
    super(map);
  }

  @Override
  abstract Set<V> createCollection();

  @Override
  Set<V> createUnmodifiableEmptyCollection() {

     */
    public static boolean mavenMaven3Personality(@Nullable Map<String, ?> userProperties) {
        return doGet(userProperties, Constants.MAVEN_MAVEN3_PERSONALITY, false);
    }

    /**
     * Check if the consumer POM feature is active.
     */
    public static boolean consumerPom(@Nullable Map<String, ?> userProperties) {

        // Test HashMap
        final Map<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        map.put("two", 2);
        binary = SerializeUtil.fromObjectToBinary(map);
        @SuppressWarnings("unchecked")
        final Map<String, Integer> resultMap = (Map<String, Integer>) SerializeUtil.fromBinaryToObject(binary);
        assertEquals(map.size(), resultMap.size());

    }

    /**
     * Gets the map of parser features.
     *
     * @return the feature map
     */
    public Map<String, String> getFeatureMap() {
        return featureMap;
    }

    /**
     * Sets the map of parser features.
     *
     * @param featureMap the feature map to set
     */
    public void setFeatureMap(final Map<String, String> featureMap) {

                    .plugin("org.apache.maven.plugins", "maven-compiler-plugin", "3.8.1")
                    .build();

            Document document = Document.of(pomXml);
            Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);

            UpgradeContext context = createMockContext();
            UpgradeResult result = strategy.doApply(context, pomMap);

            to.add(ArtifactUtils.copyArtifact(artifact));
        }
        return to;
    }

    public static <K, T extends Map<K, Artifact>> T copyArtifacts(Map<K, ? extends Artifact> from, T to) {
        if (from != null) {
            for (Map.Entry<K, ? extends Artifact> entry : from.entrySet()) {
                to.put(entry.getKey(), ArtifactUtils.copyArtifact(entry.getValue()));
            }
        }

    /** Map of parser features to configure the DOM parser. */
    protected Map<String, String> featureMap = new HashMap<>();

    /** Map of parser properties to configure the DOM parser. */
    protected Map<String, String> propertyMap = new HashMap<>();

    /** Map of HTML tag names to attribute names for extracting child URLs. */
    protected Map<String, String> childUrlRuleMap = new LinkedHashMap<>();