@Override
  public boolean containsRow(@Nullable Object rowKey) {
    return Maps.safeContainsKey(rowMap(), rowKey);
  }

  @Override
  public boolean containsColumn(@Nullable Object columnKey) {
    return Maps.safeContainsKey(columnMap(), columnKey);
  }

  @Override
  public Set<R> rowKeySet() {
    return rowMap().keySet();
  }

  @Override
  public Set<C> columnKeySet() {
    return columnMap().keySet();

  }

  public void testRowMapComparator() {
    sortedTable = TreeBasedTable.create();
    assertThat(sortedTable.rowMap().comparator()).isEqualTo(Ordering.natural());

    sortedTable = TreeBasedTable.create(Collections.reverseOrder(), Ordering.usingToString());
    assertThat(sortedTable.rowMap().comparator()).isEqualTo(Collections.reverseOrder());
  }

  public void testRowMapFirstKey() {

    }

    @Override
    Collection<V2> createValues() {
      return Collections2.transform(fromTable.values(), function);
    }

    @Override
    public Map<R, Map<C, V2>> rowMap() {
      return Maps.transformValues(fromTable.rowMap(), row -> Maps.transformValues(row, function));
    }

    @Override
    public Map<C, Map<R, V2>> columnMap() {
      return Maps.transformValues(

    }

    @Override
    Collection<V2> createValues() {
      return Collections2.transform(fromTable.values(), function);
    }

    @Override
    public Map<R, Map<C, V2>> rowMap() {
      return Maps.transformValues(fromTable.rowMap(), row -> Maps.transformValues(row, function));
    }

    @Override
    public Map<C, Map<R, V2>> columnMap() {
      return Maps.transformValues(

  }

  @LazyInit private transient @Nullable RowMap rowMap;

  @Override
  public Map<R, Map<C, @Nullable V>> rowMap() {
    RowMap map = rowMap;
    return (map == null) ? rowMap = new RowMap() : map;
  }

  @WeakOuter
  private final class RowMap extends ArrayMap<R, Map<C, @Nullable V>> {
    private RowMap() {
      super(rowKeyToIndex);
    }

    @Override

    assertThat(transpose.columnKeySet()).isSameInstanceAs(original.rowKeySet());
    assertThat(transpose.rowMap()).isSameInstanceAs(original.columnMap());
    assertThat(transpose.columnMap()).isSameInstanceAs(original.rowMap());
    assertThat(transpose.values()).isSameInstanceAs(original.values());
    assertEquals(original.row(1), transpose.column(1));

  }

  @LazyInit private transient @Nullable Map<R, Map<C, V>> rowMap;

  @Override
  public Map<R, Map<C, V>> rowMap() {
    Map<R, Map<C, V>> result = rowMap;
    return (result == null) ? rowMap = createRowMap() : result;
  }

  Map<R, Map<C, V>> createRowMap() {
    return new RowMap();
  }

  @WeakOuter
  class RowMap extends ViewCachingAbstractMap<R, Map<C, V>> {
    @Override

    }
  }

  public final void testConsistentToString() {
    for (ImmutableTable<Character, Integer, String> testInstance : getTestInstances()) {
      assertThat(testInstance.toString()).isEqualTo(testInstance.rowMap().toString());
    }
  }

  public final void testConsistentHashCode() {
    for (ImmutableTable<Character, Integer, String> testInstance : getTestInstances()) {

  }

  public void testRowKeySet() {
    assertEquals(ImmutableSet.of(), INSTANCE.rowKeySet());
  }

  public void testRowMap() {
    assertEquals(ImmutableMap.of(), INSTANCE.rowMap());
  }

  public void testValues() {
    assertTrue(INSTANCE.values().isEmpty());
  }

  }

  public void testRowKeySet() {
    assertEquals(ImmutableSet.of('a'), testTable.rowKeySet());
  }

  public void testRowMap() {
    assertEquals(ImmutableMap.of('a', ImmutableMap.of(1, "blah")), testTable.rowMap());
  }

  public void testEqualsObject() {
    new EqualsTester()
        .addEqualityGroup(testTable, HashBasedTable.create(testTable))
        .addEqualityGroup(ImmutableTable.of(), HashBasedTable.create())