@Override public Set<C> rowKeySet() { return original.columnKeySet(); }
@Override public Set<C> columnKeySet() { return fromTable.columnKeySet(); }
@Override public Set<C> columnKeySet() { return delegate().columnKeySet(); }
@Override public Set<C> columnKeySet() { synchronized (mutex) { return set(delegate().columnKeySet(), mutex); } }
@Override public Set<C> columnKeySet() { assertTrue(Thread.holdsLock(mutex)); return delegate.columnKeySet(); }
private ArrayTable(Table<R, C, V> table) { this(table.rowKeySet(), table.columnKeySet()); putAll(table); }
@Override protected Set<String> create(String[] elements) { Table<Integer, String, Character> table = TreeBasedTable.create(); populateForColumnKeySet(table, elements); return table.columnKeySet(); }
@Override protected Set<String> create(String[] elements) { Table<Integer, String, Character> table = ArrayTable.create(ImmutableList.of(1, 2), ImmutableList.copyOf(elements)); populateForColumnKeySet(table, elements); return table.columnKeySet(); } })
@Override protected Set<String> create(String[] elements) { Table<Integer, String, Character> table = HashBasedTable.create(); populateForColumnKeySet(table, elements); return table.columnKeySet(); } })
public void testColumnKeySet_isSorted() { table = create( "a", 2, 'X', "a", 2, 'X', "b", 3, 'X', "b", 2, 'X', "c", 10, 'X', "c", 10, 'X', "c", 20, 'X', "d", 15, 'X', "d", 20, 'X', "d", 1, 'X', "e", 5, 'X'); assertEquals("[1, 2, 3, 5, 10, 15, 20]", table.columnKeySet().toString()); }
public void testColumnKeySet_oneColumn() { table = create("a", 1, 'X', "b", 1, 'X'); assertEquals("[1]", table.columnKeySet().toString()); }
public void testColumnKeySet_oneEntry() { table = create("a", 1, 'X'); assertEquals("[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()); }
public void testColumnSetPartialOverlap() { table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 2, 'c', "bar", 3, 'd'); assertThat(table.columnKeySet()).containsExactly(1, 2, 3); }
public void testColumnKeySetToString_ordered() { table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c'); assertEquals("[1, 2, 3]", table.columnKeySet().toString()); }
@Override protected Set<String> create(String[] elements) { Table<Integer, String, Character> table = HashBasedTable.create(); populateForColumnKeySet(table, elements); return Tables.unmodifiableTable(table).columnKeySet(); } })
public void testCreateCopyArrayTable() { Table<String, Integer, Character> original = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c'); Table<String, Integer, Character> copy = ArrayTable.create(original); assertEquals(original, copy); original.put("foo", 1, 'd'); assertEquals((Character) 'd', original.get("foo", 1)); assertEquals((Character) 'a', copy.get("foo", 1)); assertEquals(copy.rowKeySet(), original.rowKeySet()); assertEquals(copy.columnKeySet(), original.columnKeySet()); }
private static <R, C, V> void validateReserialization(Table<R, C, V> original) { Table<R, C, V> copy = SerializableTester.reserializeAndAssert(original); assertThat(copy.cellSet()).containsExactlyElementsIn(original.cellSet()).inOrder(); assertThat(copy.rowKeySet()).containsExactlyElementsIn(original.rowKeySet()).inOrder(); assertThat(copy.columnKeySet()).containsExactlyElementsIn(original.columnKeySet()).inOrder(); }
public void testIterationOrder() { Table<String, String, String> table = HashBasedTable.create(); for (int i = 0; i < 5; i++) { table.put("r" + i, "c" + i, "v" + i); } assertThat(table.rowKeySet()).containsExactly("r0", "r1", "r2", "r3", "r4").inOrder(); assertThat(table.columnKeySet()).containsExactly("c0", "c1", "c2", "c3", "c4").inOrder(); assertThat(table.values()).containsExactly("v0", "v1", "v2", "v3", "v4").inOrder(); }