keyToKeyList = Platform.newHashMapWithExpectedSize(expectedKeys);
  }

  private LinkedListMultimap(Multimap<? extends K, ? extends V> multimap) {
    this(multimap.keySet().size());
    putAll(multimap);
  }

  /**
   * Adds a new node for the specified key-value pair before the specified {@code nextSibling}
   * element, or at the end of the list if {@code nextSibling} is null. Note: if {@code nextSibling}

        this.repositorySystemSession = requireNonNull(repositorySystemSession);
        Properties executionProperties = new Properties();
        executionProperties.putAll(request.getSystemProperties());
        executionProperties.putAll(request.getUserProperties());
        this.executionProperties = executionProperties;
    }

    @Deprecated
    public MavenSession(
            PlexusContainer container,

    assertThrows(UnsupportedOperationException.class, () -> multimapView.put("baz", 3));
    assertThrows(
        UnsupportedOperationException.class, () -> multimapView.putAll("baz", singleton(3)));
    assertThrows(UnsupportedOperationException.class, () -> multimapView.putAll(multimap));
    assertThrows(
        UnsupportedOperationException.class,
        () -> multimapView.replaceValues("foo", Collections.<Integer>emptySet()));

    multimap.put("foo", 3);
    multimap.put("bar", 1);
    multimap.putAll("foo", asList(-1, 2, 4));
    multimap.putAll("bar", asList(2, 3));
    multimap.put("foo", 1);
    TreeMultimap<String, Integer> copy =
        TreeMultimap.create(StringLength.COMPARATOR, DECREASING_INT_COMPARATOR);
    copy.putAll(multimap);
    assertEquals(multimap, copy);

        newMap.putAll(map);
        return newMap;
      }
    },
    MapMakerStrongKeysWeakValues {
      @Override
      public <K extends Comparable<K>, V> Map<K, V> create(Map<K, V> map) {
        ConcurrentMap<K, V> newMap = new MapMaker().weakValues().makeMap();
        checkState(newMap instanceof MapMakerInternalMap);
        newMap.putAll(map);
        return newMap;
      }
    },

    multimap.put("tree", 4);
    multimap.put("tree", 0);
    return multimap;
  }

  public void testToString() {
    SetMultimap<String, Integer> multimap = create();
    multimap.putAll("bar", asList(3, 1, 2));
    multimap.putAll("foo", asList(2, 3, 1, -1, 4));
    assertThat(multimap.toString()).isEqualTo("{bar=[1, 2, 3], foo=[-1, 1, 2, 3, 4]}");
  }

  public void testOrderedGet() {

                }
            }

        } catch (final IOException ioe) {
            log.error("Failed to load config", ioe); //$NON-NLS-1$
        }
        p.putAll(System.getProperties());
        if (props != null) {
            p.putAll(props);
        }
        INSTANCE = new SingletonContext(p);
    }

    /**
     * Get singleton context
     *

            synchronized (systemProperties) { // avoid concurrent modification if someone else sets/removes an unrelated
                // system property
                this.systemProperties.putAll(systemProperties);
            }
        } else {
            this.systemProperties = null;
        }

        return this;
    }

    @Override
    public Properties getUserProperties() {

        final Map<String, Object> sourceMap = new HashMap<>();
        if (name != null) {
            sourceMap.put("name", name);
        }
        if (attributes != null) {
            sourceMap.putAll(attributes);
        }
        return sourceMap;
    }

                    ImmutableSetMultimap<String, Integer> badEntries =
                        ImmutableSetMultimap.of("foo", 314, "one", 159, "two", 265, "bar", 358);
                    multimap.putAll(badEntries);
                    return Multimaps.filterEntries(
                        multimap, not(Predicates.in(badEntries.entries())));
                  }
                })