* @author Omar Darwish
 * @author Jens Nyman
 * @param <N> Node parameter type
 * @since 20.0
 */
@Immutable(containerOf = {"N"})
public class ImmutableGraph<N> extends ForwardingGraph<N> {
  @SuppressWarnings("Immutable") // The backing graph must be immutable.
  private final BaseGraph<N> backingGraph;

  ImmutableGraph(BaseGraph<N> backingGraph) {
    this.backingGraph = backingGraph;
  }

import org.jspecify.annotations.NullUnmarked;

/**
 * Unit test for {@link ForwardingMultimap}.
 *
 * @author Hayward Chan
 */
@NullUnmarked
public class ForwardingMultimapTest extends TestCase {

  @SuppressWarnings("rawtypes")
  public void testForwarding() {
    new ForwardingWrapperTester()
        .testForwarding(
            Multimap.class,
            new Function<Multimap, Multimap<?, ?>>() {
              @Override

import org.jspecify.annotations.NullUnmarked;

/**
 * Tests {@link ForwardingTable}.
 *
 * @author Gregory Kick
 */
@NullUnmarked
public class ForwardingTableTest extends TestCase {

  @SuppressWarnings("rawtypes")
  public void testForwarding() {
    new ForwardingWrapperTester()
        .testForwarding(
            Table.class,
            new Function<Table, Table<?, ?, ?>>() {
              @Override

   */
  public static <K, V> ImmutableMultimap<K, V> copyOf(Multimap<? extends K, ? extends V> multimap) {
    if (multimap instanceof ImmutableMultimap) {
      @SuppressWarnings("unchecked") // safe since multimap is not writable
      ImmutableMultimap<K, V> kvMultimap = (ImmutableMultimap<K, V>) multimap;
      if (!kvMultimap.isPartialView()) {
        return kvMultimap;
      }
    }

    assertThat(cache.getIfPresent(4)).isEqualTo(40);
    assertThat(cache.getIfPresent(5)).isEqualTo(50);
    assertThat(cache.getIfPresent(2)).isNull();
  }

  @SuppressWarnings({"deprecation", "LoadingCacheApply"})
  @Test
  public void loadingCache() throws ExecutionException {
    CacheLoader<Integer, Integer> loader =
        new CacheLoader<Integer, Integer>() {
          int i = 0;

@SuppressWarnings("module")
module okhttp3 {
  requires transitive kotlin.stdlib;
  requires transitive okio;
  requires java.logging;
  exports okhttp3;
  exports okhttp3.internal to okhttp3.logging, okhttp3.sse, okhttp3.java.net.cookiejar, okhttp3.dnsoverhttps, mockwebserver3, okhttp3.mockwebserver, mockwebserver3.junit5, okhttp3.coroutines, okhttp3.tls;
  exports okhttp3.internal.concurrent to mockwebserver3, okhttp3.mockwebserver;

   * inflicts spurious interrupts on us?), we might have to accept some flakiness or disable some
   * tests, at least under whichever environment (JRE or Android) we see such problems.
   */

  @SuppressWarnings("WaitNotInLoop") // see comment above
  public void testConditionAwaitTimeoutExceeded() {
    Stopwatch stopwatch = Stopwatch.createStarted();
    Condition condition = TestCondition.create();

    checkNotNull(mergeFunction);
    return Collectors.collectingAndThen(
        Collectors.toMap(keyFunction, valueFunction, mergeFunction, LinkedHashMap::new),
        ImmutableMap::copyOf);
  }

  @SuppressWarnings("unchecked") // An empty map works for all types.
  public static <K, V> ImmutableMap<K, V> of() {
    return (ImmutableMap<K, V>) RegularImmutableMap.EMPTY;
  }

import org.jspecify.annotations.Nullable;

/**
 * Tests for {@link ImmutableMultimap}.
 *
 * @author Jared Levy
 */
@GwtCompatible
@NullMarked
public class ImmutableMultimapTest extends TestCase {

  @SuppressWarnings("JUnitIncompatibleType")
  public void testBuilder_withImmutableEntry() {
    ImmutableMultimap<String, Integer> multimap =
        new Builder<String, Integer>().put(immutableEntry("one", 1)).build();

      return Maps.valueIterator(entrySet().iterator());
    }

    @Override
    public @Nullable Object[] toArray() {
      return standardToArray();
    }

    @Override
    @SuppressWarnings("nullness") // bug in our checker's handling of toArray signatures
    public <T extends @Nullable Object> T[] toArray(T[] array) {
      return standardToArray(array);
    }

    @Override