* limitations under the License.
 */

package com.google.common.collect.testing;

import com.google.common.annotations.GwtCompatible;

/**
 * A generator that relies on a preexisting generator for most of its work. For example, a derived
 * iterator generator may delegate the work of creating the underlying collection to an inner
 * collection generator.
 *

  private EmptyImmutableListMultimap() {
    super(ImmutableMap.<Object, ImmutableList<Object>>of(), 0);
  }

  /*
   * TODO(b/242884182): Figure out why this helps produce the same class file when we compile most
   * of common.collect a second time with the results of the first compilation on the classpath. Or
   * just back this out once we stop doing that (which we'll do after our internal GWT setup
   * changes).
   */
  @Override

 * the License.
 */

package com.google.common.util.concurrent.internal;


/**
 * Static utilities for {@link InternalFutureFailureAccess}. Most users will never need to use this
 * class.
 *
 * <p>This class is GWT-compatible.
 *
 * @since {@code com.google.guava:failureaccess:1.0}, which was added as a dependency of Guava in
 *     Guava 27.0
 */

 * }</pre>
 *
 * @author James Sexton
 * @author Joshua O'Madadhain
 * @param <N> The most general node type this builder will support. This is normally {@code Object}
 *     unless it is constrained by using a method like {@link #nodeOrder}, or the builder is
 *     constructed based on an existing {@code Network} using {@link #from(Network)}.
 * @param <E> The most general edge type this builder will support. This is normally {@code Object}

import java.io.Serializable;
import java.util.Map;
import java.util.concurrent.Executor;

/**
 * Computes or retrieves values, based on a key, for use in populating a {@link LoadingCache}.
 *
 * <p>Most implementations will only need to implement {@link #load}. Other methods may be
 * overridden as desired.
 *
 * <p>Usage example:
 *
 * <pre>{@code
 * CacheLoader<Key, Graph> loader = new CacheLoader<Key, Graph>() {

   *     arguments
   */
  boolean apply(@ParametricNullness T input);

  /**
   * Indicates whether another object is equal to this predicate.
   *
   * <p>Most implementations will have no reason to override the behavior of {@link Object#equals}.
   * However, an implementation may also choose to return {@code true} whenever {@code object} is a

   *       in the {@code exceptions} collection.
   * </ul>
   *
   * <p>Though this method takes any {@link Collection}, it often makes most sense to pass a {@link
   * java.util.List} or some other collection that preserves the order in which the exceptions got
   * added.
   *
   * @throws NullPointerException if {@code exceptions} is null

     * Only under Windows (or hypothetically when running with some other non-POSIX, ACL-based
     * filesystem) does our prod code look up the username. Thus, this test doesn't necessarily test
     * anything interesting under most environments. Still, we can run it (except for Android, at
     * least old versions), so we mostly do. This is useful because we don't actually run our CI on
     * Windows under Java 8, at least as of this writing.
     *

      </plugin>
      <plugin>
        <artifactId>maven-source-plugin</artifactId>
        <executions>
          <execution>
            <id>attach-test-sources</id>
            <phase>post-integration-test</phase>
            <goals><goal>test-jar</goal></goals>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <artifactId>maven-jar-plugin</artifactId>

public abstract class ForwardingMapEntry<K extends @Nullable Object, V extends @Nullable Object>
    extends ForwardingObject implements Map.Entry<K, V> {
  // TODO(lowasser): identify places where thread safety is actually lost

  /** Constructor for use by subclasses. */
  protected ForwardingMapEntry() {}

  @Override
  protected abstract Entry<K, V> delegate();

  @Override
  @ParametricNullness
  public K getKey() {