() -> String.format(NODE_PAIR_REMOVED_FROM_GRAPH, nodeU, nodeV));
  }

  private static <N, E> Map<E, EndpointPair<N>> edgeIncidentNodesMap(Network<N, E> network) {
    return Maps.asMap(network.edges(), network::incidentNodes);
  }

    // add a non-serializable entry
    one.getUnchecked(new Object());
    assertThat(one.size()).isEqualTo(1);
    assertThat(one.asMap().isEmpty()).isFalse();
    LocalLoadingCache<Object, Object> two = SerializableTester.reserialize(one);
    assertThat(two.size()).isEqualTo(0);
    assertThat(two.asMap().isEmpty()).isTrue();

    LocalCache<Object, Object> localCacheOne = one.localCache;

        builder.build(CacheLoader.from(Suppliers.ofInstance(value)));
    assertThat(cache.getUnchecked(key)).isSameInstanceAs(value);
    assertThat(cache.size()).isEqualTo(0);
    assertThat(cache.asMap().containsKey(key)).isFalse();
  }

  public void testCacheBuilderFrom_string() {
    CacheBuilder<?, ?> fromString =
        CacheBuilder.from(
            "initialCapacity=10,maximumSize=20,concurrencyLevel=30,"

   * {@code ConcurrentMap} documentation. They will not function correctly and it is impossible for
   * Guava to fix them until Guava is ready to <i>require</i> Java 8 for all users.
   */
  ConcurrentMap<K, V> asMap();

  /**
   * Performs any pending maintenance operations needed by the cache. Exactly which activities are
   * performed -- if any -- is implementation-dependent.
   */
  void cleanUp();

                MapFeature.REJECTS_DUPLICATES_AT_CREATION,
                CollectionFeature.KNOWN_ORDER,
                CollectionFeature.ALLOWS_NULL_QUERIES)
            .named("ImmutableMap.asMultimap.asMap")
            .createTestSuite());

    suite.addTest(
        CollectionTestSuiteBuilder.using(new ImmutableMapUnhashableValuesGenerator())
            .withFeatures(
                CollectionSize.ANY,

    // add a non-serializable entry
    one.getUnchecked(new Object());
    assertThat(one.size()).isEqualTo(1);
    assertThat(one.asMap().isEmpty()).isFalse();
    LocalLoadingCache<Object, Object> two = SerializableTester.reserialize(one);
    assertThat(two.size()).isEqualTo(0);
    assertThat(two.asMap().isEmpty()).isTrue();

    LocalCache<Object, Object> localCacheOne = one.localCache;

    LenientSerializableTester.reserializeAndAssertLenient(multimap.keySet());
    LenientSerializableTester.reserializeAndAssertLenient(multimap.keys());
    SerializableTester.reserializeAndAssert(multimap.asMap());
    Collection<Integer> valuesCopy = SerializableTester.reserialize(multimap.values());
    assertEquals(HashMultiset.create(multimap.values()), HashMultiset.create(valuesCopy));
  }

  @J2ktIncompatible

   *       {@code MapJoiner} method that accepts entries as input, and receive output of the form
   *       {@code key1=A&key1=B&key2=C}.
   *   <li>To output a single entry for each key, pass {@code multimap.asMap()} to a {@code
   *       MapJoiner} method that accepts a map as input, and receive output of the form {@code
   *       key1=[A, B]&key2=C}.
   * </ul>
   *
   * @since 2.0
   */

    public void invalidateAll() {
      localCache.clear();
    }

    @Override
    public long size() {
      return localCache.size();
    }

    @Override
    public ConcurrentMap<K, V> asMap() {
      return localCache;
    }
  }

  /**
   * LocalLoadingCache is a wrapper around LocalCache for a cache with loading.
   *
   * @param <K> the base key type
   * @param <V> the base value type

            return getDummyValue(TypeToken.of(interfaceType).method(method).getReturnType());
          }
        };
    for (Entry<Class<?>, Collection<Object>> entry : distinctValues.asMap().entrySet()) {
      generator.addSampleInstances((Class) entry.getKey(), entry.getValue());
    }
    return generator;
  }