populateForColumnKeySet(table, elements);
                    return table.columnKeySet();
                  }
                })
            .named("ArrayTable.columnKeySet")
            .withFeatures(
                CollectionSize.ONE,
                CollectionSize.SEVERAL,
                CollectionFeature.KNOWN_ORDER,

                    populateForColumnKeySet(table, elements);
                    return table.columnKeySet();
                  }
                })
            .named("ArrayTable.columnKeySet")
            .withFeatures(
                CollectionSize.ONE,
                CollectionSize.SEVERAL,
                CollectionFeature.KNOWN_ORDER,

            'X');
    assertEquals("[20, 15, 10, 5, 3, 2, 1]", table.columnKeySet().toString());
  }

  public void testColumnKeySet_empty() {
    table = create();
    assertEquals("[]", table.columnKeySet().toString());
  }

  public void testColumnKeySet_oneRow() {
    table = create("a", 2, 'X', "a", 1, 'X');
    assertEquals("[1, 2]", table.columnKeySet().toString());
  }

    assertThat(copy.cellSet()).containsExactlyElementsIn(original.cellSet()).inOrder();
    assertThat(copy.rowKeySet()).containsExactlyElementsIn(original.rowKeySet()).inOrder();
    assertThat(copy.columnKeySet()).containsExactlyElementsIn(original.columnKeySet()).inOrder();
  }

  @J2ktIncompatible
  @GwtIncompatible // Mind-bogglingly slow in GWT
  @AndroidIncompatible // slow
  public void testOverflowCondition() {

    }

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

    @Override
    public Set<C> columnKeySet() {
      return fromTable.columnKeySet();
    }

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

    @Override

    public Map<R, V> column(C columnKey) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.column(columnKey);
    }

    @Override
    public Set<C> columnKeySet() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.columnKeySet();
    }

    @Override
    public Map<C, Map<R, V>> columnMap() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.columnMap();
    }

    Table<String, Integer, Character> transpose = transpose(original);
    original.put(1, "foo", 'a');
    assertSame(original.columnKeySet(), transpose.rowKeySet());
    assertSame(original.rowKeySet(), transpose.columnKeySet());
    assertSame(original.columnMap(), transpose.rowMap());
    assertSame(original.rowMap(), transpose.columnMap());
    assertSame(original.values(), transpose.values());

   * table.rowKeySet()} and the column keys in {@code table.columnKeySet()}. Calling {@link #put}
   * with other keys leads to an {@code IllegalArgumentException}.
   *
   * <p>The ordering of {@code table.rowKeySet()} and {@code table.columnKeySet()} determines the
   * row and column iteration ordering of the returned table.
   *

    public Map<R, V> column(C columnKey) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.column(columnKey);
    }

    @Override
    public Set<C> columnKeySet() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.columnKeySet();
    }

    @Override
    public Map<C, Map<R, V>> columnMap() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.columnMap();
    }

  }

  public void testColumn() {
    assertEquals(ImmutableMap.of(), INSTANCE.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));
  }