import com.google.common.base.Supplier;
import java.util.Map;
import java.util.TreeMap;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Test cases for {@link Tables#newCustomTable}.
 *
 * @author Jared Levy
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public class NewCustomTableTest extends AbstractTableTest<Character> {

  @Override

import java.io.ObjectOutputStream;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Implementation of {@link Multimap} using hash tables.
 *
 * <p>The multimap does not store duplicate key-value pairs. Adding a new key-value pair equal to an
 * existing key-value pair has no effect.
 *

 *
 * <p>{@code Object.hashCode} implementations tend to be very fast, but have weak collision
 * prevention and <i>no</i> expectation of bit dispersion. This leaves them perfectly suitable for
 * use in hash tables, because extra collisions cause only a slight performance hit, while poor bit
 * dispersion is easily corrected using a secondary hash function (which all reasonable hash table

    @Override
    SetBuilderImpl<E> copy() {
      return this;
    }

    @Override
    ImmutableSet<E> build() {
      return ImmutableSet.of();
    }
  }

  // We use power-of-2 tables, and this is the highest int that's a power of 2
  static final int MAX_TABLE_SIZE = Ints.MAX_POWER_OF_TWO;

  // Represents how tightly we can pack things, as a maximum.

  }

  /**
   * Applies a supplemental hash function to a given hash code, which defends against poor quality
   * hash functions. This is critical when the concurrent hash map uses power-of-two length hash
   * tables, that otherwise encounter collisions for hash codes that do not differ in lower or upper
   * bits.
   *
   * @param h hash code
   */
  static int rehash(int h) {

 *
 * <p>See the Guava User Guide article on <a href=
 * "https://github.com/google/guava/wiki/CollectionUtilitiesExplained#tables">{@code Tables}</a>.
 *
 * @author Jared Levy
 * @author Louis Wasserman
 * @since 7.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public final class Tables {
  private Tables() {}

  /**
   * Returns a {@link Collector} that accumulates elements into a {@code Table} created using the

                    return new SampleElements<>(
                        Tables.immutableCell("bar", 1, 'a'),
                        Tables.immutableCell("bar", 2, 'b'),
                        Tables.immutableCell("bar", 3, (Character) null),
                        Tables.immutableCell("bar", 4, 'b'),
                        Tables.immutableCell("bar", 5, 'b'));
                  }

                  @Override

public class RegularImmutableTableTest extends AbstractImmutableTableTest {
  private static final ImmutableSet<Cell<Character, Integer, String>> CELLS =
      ImmutableSet.of(
          Tables.immutableCell('a', 1, "foo"),
          Tables.immutableCell('b', 1, "bar"),
          Tables.immutableCell('a', 2, "baz"));

  private static final ImmutableSet<Character> ROW_SPACE = ImmutableSet.of('a', 'b');

    return Tables.immutableCell(
        checkNotNull(rowKey, "rowKey"),
        checkNotNull(columnKey, "columnKey"),
        checkNotNull(value, "value"));
  }

  /**
   * A builder for creating immutable table instances, especially {@code public static final} tables
   * ("constant tables"). Example:
   *
   * <pre>{@code

    return Tables.transformValues(original, FIRST_CHARACTER);
  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    Table<Integer, String, String> table = HashBasedTable.create();
    table.put(1, "foo", "apple");
    table.put(1, "bar", "banana");
    table.put(3, "foo", "cat");
    return Tables.transformValues(table, FIRST_CHARACTER).columnMap();
  }