}

  private void putAll(Iterable<Entry<K, V>> entries) {
    Map<K, V> map = new LinkedHashMap<>();
    for (Entry<K, V> entry : entries) {
      map.put(entry.getKey(), entry.getValue());
    }
    getMap().putAll(map);
  }

  /**
   * Returns the {@link Method} instance for {@link #testPutAll_nullKeyUnsupported()} so that tests

        @SuppressWarnings("rawtypes") // using raw types to avoid a bug in our nullness checker :(
        InternalEntry entry = map.getEntry(sample);
        if (entry != null) {
          Object canonical = entry.getKey();
          if (canonical != null) { // only matters if weak/soft keys are used
            // The compiler would know this is safe if not for our use of raw types (see above).
            @SuppressWarnings("unchecked")

                parser.setFeature(entry.getKey(), "true".equalsIgnoreCase(entry.getValue()));
            }

            // property
            for (final Map.Entry<String, String> entry : propertyMap.entrySet()) {
                parser.setProperty(entry.getKey(), entry.getValue());
            }

            return parser;
        } catch (final Exception e) {

    }

    Entry<K, V> getEntry(int index) {
      checkElementIndex(index, size());
      return new AbstractMapEntry<K, V>() {
        @Override
        public K getKey() {
          return ArrayMap.this.getKey(index);
        }

        @Override
        @ParametricNullness
        public V getValue() {
          return ArrayMap.this.getValue(index);
        }

        @Override

      Collection<V> collection = null;
      while (asMapItr.hasNext()) {
        Entry<K, Collection<V>> asMapEntry = asMapItr.next();
        if (key.equals(asMapEntry.getKey())) {
          collection = asMapEntry.getValue();
          break;
        }
      }
      assertNotNull(collection);
      Collection<V> expectedCollection = copyToList(collection);

        if (projectProperties != null) {
            this.projectProperties = projectProperties.entrySet().stream()
                    .collect(collectingAndThen(
                            toMap(e -> String.valueOf(e.getKey()), e -> String.valueOf(e.getValue())),
                            Collections::unmodifiableMap));
        } else {
            this.projectProperties = Collections.emptyMap();
        }

        return this;

      if (delegate != null) {
        return delegate.entrySet().contains(o);
      } else if (o instanceof Entry) {
        Entry<?, ?> entry = (Entry<?, ?>) o;
        int index = indexOf(entry.getKey());
        return index != -1 && Objects.equals(value(index), entry.getValue());
      }
      return false;
    }

    @Override
    public boolean remove(@Nullable Object o) {

    }

    @Override
    public void setLink(final String link) {
        this.link = link;
    }

    /**
     * @return the key
     */
    @Override
    public String getKey() {
        return this.key;
    }

    /**
     * @param key
     *            the key to set
     */
    @Override
    public void setKey(final String key) {
        this.key = key;
    }

    protected Object getPluginKey(Plugin plugin) {
        return plugin.getKey();
    }

    @Override
    protected Object getPluginExecutionKey(PluginExecution pluginExecution) {
        return pluginExecution.getId();
    }

    @Override
    protected Object getReportPluginKey(ReportPlugin reportPlugin) {
        return reportPlugin.getKey();
    }

    @Override

    return newView(unmodifiableSortedMap(delegate), comparator);
  }

  private static <K, V> void putEntryWithChecks(
      SortedMap<K, V> map, Entry<? extends K, ? extends V> entry) {
    K key = checkNotNull(entry.getKey());
    V value = checkNotNull(entry.getValue());
    if (map.containsKey(key)) {
      // When a collision happens, the colliding entry is the first entry
      // of the tail map.