@Override
  protected Table<String, Integer, Character> create(@Nullable Object... data) {
    Table<Integer, String, Character> original = HashBasedTable.create();
    Table<String, Integer, Character> table = Tables.transpose(original);
    table.clear();
    populate(table, data);
    return table;
  }

  public void testTransposeTransposed() {

  }

  @Override
  Table<Integer, String, Character> makeTable() {
    RowSortedTable<Integer, String, Character> original = TreeBasedTable.create();
    return Tables.unmodifiableRowSortedTable(original);
  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    RowSortedTable<Integer, String, Character> table = TreeBasedTable.create();
    table.put(1, "foo", 'a');

  }

  @Override
  Table<Character, String, Integer> makeTable() {
    Table<Character, String, Integer> table = HashBasedTable.create();
    return Tables.transformValues(table, TableCollectionTest.DIVIDE_BY_2);
  }

  @Override
  protected Map<String, Integer> makePopulatedMap() {
    Table<Character, String, Integer> table = HashBasedTable.create();
    table.put('a', "one", 2);
    table.put('a', "two", 4);

 * {@link Map} specified in the {@link Table} interface.
 *
 * <p>Note that this implementation is not synchronized. If multiple threads access this table
 * concurrently and one of the threads modifies the table, it must be synchronized externally.
 *
 * <p>See the Guava User Guide article on <a href=
 * "https://github.com/google/guava/wiki/NewCollectionTypesExplained#table">{@code Table}</a>.
 *
 * @author Jared Levy

    table.put("cat", 1, 'b');
    table.clear();
    populate(table, data);
    return table;
  }

  public void testCreateExplicitComparators() {
    table = TreeBasedTable.create(Collections.reverseOrder(), Ordering.usingToString());
    table.put("foo", 3, 'a');
    table.put("foo", 12, 'b');
    table.put("bar", 5, 'c');
    table.put("cat", 8, 'd');

    new ForwardingWrapperTester()
        .testForwarding(
            Table.class,
            new Function<Table, Table<?, ?, ?>>() {
              @Override
              public Table<?, ?, ?> apply(Table delegate) {
                return wrap((Table<?, ?, ?>) delegate);
              }
            });
  }

  public void testEquals() {
    Table<Integer, Integer, String> table1 = ImmutableTable.of(1, 1, "one");

        }
      };

  @Override
  protected Table<String, Integer, Character> create(@Nullable Object... data) {
    Table<String, Integer, String> table = HashBasedTable.create();
    checkArgument(data.length % 3 == 0);
    for (int i = 0; i < data.length; i += 3) {
      String value = (data[i + 2] == null) ? null : (data[i + 2] + "transformed");
      table.put((String) data[i], (Integer) data[i + 1], value);
    }

  @Override
  protected Table<String, Integer, Character> create(@Nullable Object... data) {
    Table<String, Integer, Character> table = HashBasedTable.create();
    table.put("foo", 4, 'a');
    table.put("cat", 1, 'b');
    table.clear();
    populate(table, data);
    return table;
  }

  public void testIterationOrder() {
    Table<String, String, String> table = HashBasedTable.create();

   * failed CAS on base update), the table is initialized to size 2.
   * The table size is doubled upon further contention until
   * reaching the nearest power of two greater than or equal to the
   * number of CPUS. Table slots remain empty (null) until they are
   * needed.
   *
   * A single spinlock ("busy") is used for initializing and
   * resizing the table, as well as populating slots with new Cells.

  }

  @Override
  Table<Character, String, Integer> makeTable() {
    RowSortedTable<Character, String, Integer> table = TreeBasedTable.create();
    return Tables.unmodifiableRowSortedTable(table);
  }

  @Override
  protected Map<String, Integer> makePopulatedMap() {
    RowSortedTable<Character, String, Integer> table = TreeBasedTable.create();
    table.put('a', "one", 1);
    table.put('a', "two", 2);