* returns a {@link SortedMap}, instead of the {@link Set} and {@link Map} specified by the {@link
 * Table} interface.
 *
 * <p>The views returned by {@link #column}, {@link #columnKeySet()}, and {@link #columnMap()} have
 * iterators that don't support {@code remove()}. Otherwise, all optional operations are supported.
 * Null row keys, columns keys, and values are not supported.
 *

      table.put(1, "foo", 'a');
      table.put(1, "bar", 'b');
      table.put(3, "foo", 'c');
      return table.columnMap();
    }

    @Override
    protected Map<String, Map<Integer, Character>> makeEmptyMap() {
      return makeTable().columnMap();
    }
  }

      table.put(1, "foo", 'a');
      table.put(1, "bar", 'b');
      table.put(3, "foo", 'c');
      return table.columnMap();
    }

    @Override
    protected Map<String, Map<Integer, Character>> makeEmptyMap() {
      return makeTable().columnMap();
    }
  }

        return map(transformValues(delegate().rowMap(), m -> map(m, mutex)), mutex);
      }
    }

    @Override
    public Map<C, Map<R, V>> columnMap() {
      synchronized (mutex) {
        return map(transformValues(delegate().columnMap(), m -> map(m, mutex)), mutex);
      }
    }

    @Override
    public int hashCode() {
      synchronized (mutex) {

        return map(transformValues(delegate().rowMap(), m -> map(m, mutex)), mutex);
      }
    }

    @Override
    public Map<C, Map<R, V>> columnMap() {
      synchronized (mutex) {
        return map(transformValues(delegate().columnMap(), m -> map(m, mutex)), mutex);
      }
    }

    @Override
    public int hashCode() {
      synchronized (mutex) {

    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));

  }

  public void testColumnKeySet() {
    assertEquals(ImmutableSet.of(), INSTANCE.columnKeySet());
  }

  public void testColumnMap() {
    assertEquals(ImmutableMap.of(), INSTANCE.columnMap());
  }

  public void testContains() {
    assertFalse(INSTANCE.contains('a', 1));
  }

  public void testContainsColumn() {
    assertFalse(INSTANCE.containsColumn(1));
  }

  public void testColumnKeySet() {
    assertEquals(ImmutableSet.of(1), testTable.columnKeySet());
  }

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

  public void testRow() {
    assertEquals(ImmutableMap.of(), testTable.row('A'));
    assertEquals(ImmutableMap.of(1, "blah"), testTable.row('a'));
  }

  public void testRowKeySet() {

      assertEquals(
          ImmutableMap.of(
              1, ImmutableMap.of('a', "foo", 'b', "bar"), 2, ImmutableMap.of('a', "baz")),
          testInstance.columnMap());
    }
  }

  public void testContains() {
    for (ImmutableTable<Character, Integer, String> testInstance : getTestInstances()) {
      assertTrue(testInstance.contains('a', 1));