import com.google.common.collect.HashBiMap;
import com.google.common.collect.ImmutableBiMap;
import java.util.Collections;
import java.util.Map;
import java.util.Set;

/**
 * An implementation of {@link NetworkConnections} for undirected networks.
 *
 * @author James Sexton
 * @param <N> Node parameter type
 * @param <E> Edge parameter type
 */
@ElementTypesAreNonnullByDefault

import java.util.Arrays;
import java.util.List;

/**
 * Creates, based on your criteria, a JUnit test suite that exhaustively tests a ConcurrentMap
 * implementation.
 *
 * @author Louis Wasserman
 */
@GwtIncompatible
public class ConcurrentMapTestSuiteBuilder<K, V> extends MapTestSuiteBuilder<K, V> {

         * recognize instances of our TypeVariable implementation. This is a problem because users
         * compare TypeVariables from the JDK against TypeVariables returned by TypeResolver. To
         * work with all JDK versions, TypeResolver must return the appropriate TypeVariable
         * implementation in each of the three possible cases:
         *

import com.google.common.base.Objects;
import java.util.Map.Entry;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Implementation of the {@code equals}, {@code hashCode}, and {@code toString} methods of {@code
 * Entry}.
 *
 * @author Jared Levy
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault

import com.google.common.annotations.GwtCompatible;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * An implementation of {@code Iterable} which throws an exception on all invocations of the {@link
 * #iterator()} method after the first, and whose iterator is always unmodifiable.
 *

 * asymptotics but requires O(n) memory, and a {@code PriorityQueue} implementation takes O(n log
 * k). In benchmarks, this implementation performs at least as well as either implementation, and
 * degrades more gracefully for worst-case input.
 *
 * <p>The implementation does not necessarily use a <i>stable</i> sorting algorithm; when multiple

 * </ul>
 *
 * <h3>Implementations</h3>
 *
 * <ul>
 *   <li>{@link ImmutableListMultimap}
 *   <li>{@link ImmutableSetMultimap}
 *   <li>Configure your own mutable multimap with {@link MultimapBuilder}
 *   <li>{@link LinkedListMultimap} (for one unusual kind of mutable {@code Multimap})
 * </ul>
 *
 * Guava contains a number of other multimap implementations, such as {@link ArrayListMultimap}. In

   * any {@code Entry} instances already retrieved from the entry set (this is
   * implementation-dependent). Furthermore, implementations are not required to support
   * modifications to the entry set at all, and the {@code Entry} instances themselves don't even
   * have methods for modification. See the specific implementation class for more details on how
   * its entry set handles modifications.
   *

import com.google.common.annotations.J2ktIncompatible;
import com.google.common.base.Preconditions;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Implementation of {@link ImmutableSet} with exactly one element.
 *
 * @author Kevin Bourrillion
 * @author Nick Kralevich
 */
@GwtCompatible(serializable = true, emulated = true)

 * override {@code putAll} as well, either providing your own implementation, or delegating to the
 * provided {@code standardPutAll} method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingSortedMap}.
 *