import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import javax.annotation.CheckForNull;

/**
 * Implementation of {@code Table} whose row keys and column keys are ordered by their natural
 * ordering or by supplied comparators. When constructing a {@code TreeBasedTable}, you may provide

                        repositories {
                            mavenCentral()
                        }
                        dependencies {
                            "implementation"(gradleApi())
                            "implementation"(kotlin("stdlib"))
                        }
                    }
                    project(":v1") {
                        version = "1.0"
                    }

import java.util.Map.Entry;
import java.util.Set;
import junit.framework.TestSuite;

/**
 * Creates, based on your criteria, a JUnit test suite that exhaustively tests a {@code
 * SortedSetMultimap} implementation.
 *
 * @author Louis Wasserman
 */
@GwtIncompatible
public class SortedSetMultimapTestSuiteBuilder<K, V>
    extends MultimapTestSuiteBuilder<K, V, SetMultimap<K, V>> {

import com.google.errorprone.annotations.concurrent.LazyInit;
import com.google.j2objc.annotations.RetainedWith;
import java.util.function.BiConsumer;
import javax.annotation.CheckForNull;

/**
 * Implementation of {@link ImmutableMap} with exactly one entry.
 *
 * @author Jesse Wilson
 * @author Kevin Bourrillion
 */
@GwtCompatible(serializable = true, emulated = true)

   * will return {@code Double.MAX_VALUE}, not {@code Double.POSITIVE_INFINITY}.
   *
   * <p>For the case of {@link RoundingMode#HALF_EVEN}, this implementation uses the IEEE 754
   * default rounding mode: if the two nearest representable values are equally near, the one with
   * the least significant bit zero is chosen. (In such cases, both of the nearest representable

          // if this is a concern we could add special cases for some known charsets (like utf8)
          // or we could avoid inputstreamreader and use the decoder api directly
          // TODO(lukes): in a real implementation we would need to handle overflow conditions
          int maxChars = (int) (size.get().intValue() * cs.newDecoder().maxCharsPerByte());
          char[] buffer = new char[maxChars];
          int bufIndex = 0;

  SHA384(Hashing.sha384()),
  SHA512(Hashing.sha512()),
  SIP_HASH24(Hashing.sipHash24()),
  FARMHASH_FINGERPRINT_64(Hashing.farmHashFingerprint64()),

  // Hash functions found in //javatests for comparing against current implementation of CityHash.
  // These can probably be removed sooner or later.
  ;

  private final HashFunction hashFunction;

  private HashFunctionEnum(HashFunction hashFunction) {
    this.hashFunction = hashFunction;

import com.google.common.annotations.GwtCompatible;
import java.util.Queue;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * An Iterator implementation which draws elements from a queue, removing them from the queue as it
 * iterates. This class is not thread safe.
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault

import com.google.common.annotations.GwtIncompatible;
import java.util.List;

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

there are limitations to what a Go implementation can do in response to a data race.
An implementation may always react to a data race by reporting the race and terminating the program.
Otherwise, each read of a single-word-sized or sub-word-sized memory location
must observe a value actually written to that location (perhaps by a concurrent executing goroutine)
and not yet overwritten.
These implementation constraints make Go more like Java or JavaScript,