cache,
        MAX_SIZE,
        new Receiver<ReferenceEntry<Integer, Integer>>() {
          @Override
          public void accept(ReferenceEntry<Integer, Integer> entry) {
            cache.getUnchecked(entry.getKey());
          }
        });
  }

  public void testUpdateRecency_onInvalidate() {
    IdentityLoader<Integer> loader = identityLoader();
    final LoadingCache<Integer, Integer> cache =

                    Map<String, String> map = CompactLinkedHashMap.create();
                    for (Entry<String, String> entry : entries) {
                      map.put(entry.getKey(), entry.getValue());
                    }
                    return map;
                  }
                })
            .named("CompactLinkedHashMap")
            .withFeatures(

  @Override
  public boolean putAll(Multimap<? extends K, ? extends V> multimap) {
    boolean changed = false;
    for (Entry<? extends K, ? extends V> entry : multimap.entries()) {
      changed |= put(entry.getKey(), entry.getValue());
    }
    return changed;
  }

  @CanIgnoreReturnValue
  @Override
  public Collection<V> replaceValues(@ParametricNullness K key, Iterable<? extends V> values) {

  public void testPut_nullValueSupported() {
    Entry<K, V> nullValueEntry = entry(k3(), null);
    assertNull(
        "putIfAbsent(key, null) should return null",
        getMap().putIfAbsent(nullValueEntry.getKey(), nullValueEntry.getValue()));
    expectAdded(nullValueEntry);
  }

                Artifact artifact, ArtifactRepository localRepository, List<ArtifactRepository> remoteRepositories)
                throws ArtifactMetadataRetrievalException {
            String key = getKey(artifact);

            ArtifactSpec a = (ArtifactSpec) artifacts.get(key);
            try {
                return new ResolutionGroup(
                        artifact,
                        createArtifacts(

    @SuppressWarnings("unchecked") // we'll only be using getKey and getValue, which are covariant
    Entry<K, V>[] entryArray = (Entry<K, V>[]) Iterables.toArray(entries, EMPTY_ENTRY_ARRAY);
    switch (entryArray.length) {
      case 0:
        return of();
      case 1:
        Entry<K, V> entry = entryArray[0];
        return of(entry.getKey(), entry.getValue());
      default:
        /*

    assertThat(expected.getMessage()).containsMatch("1|2");
  }

  public void testToImmutableBiMap() {
    Collector<Entry<String, Integer>, ?, ImmutableBiMap<String, Integer>> collector =
        toImmutableBiMap(Entry::getKey, Entry::getValue);
    Equivalence<ImmutableBiMap<String, Integer>> equivalence =
        Equivalence.equals()
            .<Entry<String, Integer>>pairwise()
            .onResultOf(ImmutableBiMap::entrySet);

        final Map<String, String> metaConfigMap = crawlingConfig.getConfigParameterMap(ConfigName.META);
        for (final Map.Entry<String, String> entry : metaConfigMap.entrySet()) {
            final String key = entry.getKey();
            final String[] values = entry.getValue().split(",");
            for (final String value : values) {

        new ImmutableMap.Builder<>(mapEntries.size());
    int size = 0;

    for (Entry<? extends K, ? extends Collection<? extends V>> entry : mapEntries) {
      K key = entry.getKey();
      Collection<? extends V> values = entry.getValue();
      ImmutableList<V> list =
          (valueComparator == null)
              ? ImmutableList.copyOf(values)

    ImmutableMultiset.Builder<T> builder = ImmutableMultiset.builder();
    for (Entry<T, Integer> entry : counts.entrySet()) {
      builder.addCopies(entry.getKey(), entry.getValue());
    }
    return builder.build();
  }

  private ListenerCallQueue.Event<Object> countDownEvent(final CountDownLatch latch) {
    return new ListenerCallQueue.Event<Object>() {