public void testCreateCopyEmptyTable() {
Table<String, Integer, Character> original = HashBasedTable.create();
try {
ArrayTable.create(original);
fail();
} catch (IllegalArgumentException expected) {
}
}
@Override
protected Map<String, Map<Integer, Character>> makePopulatedMap() {
Table<Integer, String, Character> table = HashBasedTable.create();
table.put(1, "foo", 'a');
table.put(1, "bar", 'b');
table.put(3, "foo", 'c');
return Tables.unmodifiableTable(table).columnMap();
}
@Override
protected Map<String, Map<Integer, Character>> makePopulatedMap() {
Table<Integer, String, String> table = HashBasedTable.create();
table.put(1, "foo", "apple");
table.put(1, "bar", "banana");
table.put(3, "foo", "cat");
return Tables.transformValues(table, FIRST_CHARACTER).columnMap();
}
@Override
protected Map<String, Map<Integer, Character>> makePopulatedMap() {
Table<String, Integer, Character> table = HashBasedTable.create();
table.put("foo", 1, 'a');
table.put("bar", 1, 'b');
table.put("foo", 3, 'c');
return Tables.unmodifiableTable(table).rowMap();
}
@Override
protected Map<String, Integer> makePopulatedMap() {
Table<String, Character, Integer> table = HashBasedTable.create();
table.put("one", 'a', 1);
table.put("two", 'a', 2);
table.put("three", 'a', 3);
table.put("four", 'b', 4);
return Tables.unmodifiableTable(table).column('a');
}
@Override
protected Map<String, Integer> makePopulatedMap() {
Table<String, Character, Integer> table = HashBasedTable.create();
table.put("one", 'a', 1);
table.put("two", 'a', 2);
table.put("three", 'a', 3);
table.put("four", 'b', 4);
return Tables.transformValues(table, DIVIDE_BY_2).column('a');
}
@Override
protected Map<String, Integer> makePopulatedMap() {
Table<Character, String, Integer> table = HashBasedTable.create();
table.put('a', "one", 1);
table.put('a', "two", 2);
table.put('a', "three", 3);
table.put('b', "four", 4);
return Tables.unmodifiableTable(table).row('a');
}
@Override
protected Map<String, Integer> makePopulatedMap() {
Table<Character, String, Integer> table = HashBasedTable.create();
table.put('a', "one", 2);
table.put('a', "two", 4);
table.put('a', "three", 6);
table.put('b', "four", 8);
return Tables.transformValues(table, DIVIDE_BY_2).row('a');
}
@Test
public void testTable() {
HashBasedTable<Integer, Integer, Integer> table = HashBasedTable.create();
table.put(1, 1, 1);
table.put(1, 2, 2);
table.put(1, 3, 3);
table.put(2, 1, 4);
table.put(2, 2, 5);
table.put(2, 3, 6);
assert table.containsRow(1);
assert table.containsColumn(2);
assert table.row(1).get(3) == 3;
}
@Test
public void whenCreateTable_thenCreated() {
final Table<String, String, Integer> distance = HashBasedTable.create();
distance.put("London", "Paris", 340);
distance.put("New York", "Los Angeles", 3940);
distance.put("London", "New York", 5576);
assertEquals(3940, distance.get("New York", "Los Angeles").intValue());
assertThat(distance.columnKeySet(), containsInAnyOrder("Paris", "New York", "Los Angeles"));
assertThat(distance.rowKeySet(), containsInAnyOrder("London", "New York"));
}
@Test
public void whenTransposeTable_thenCorrect() {
final Table<String, String, Integer> distance = HashBasedTable.create();
distance.put("London", "Paris", 340);
distance.put("New York", "Los Angeles", 3940);
distance.put("London", "New York", 5576);
final Table<String, String, Integer> transposed = Tables.transpose(distance);
assertThat(transposed.rowKeySet(), containsInAnyOrder("Paris", "New York", "Los Angeles"));
assertThat(transposed.columnKeySet(), containsInAnyOrder("London", "New York"));
}
private static class ProductAssociativityGraph {
private final Table<Vertex, Vertex, Edge> graph = HashBasedTable.create();
public static ProductAssociativityGraph create() {
return new ProductAssociativityGraph();
}
public void addAssociation(Vertex v1, Vertex v2, int edgeWeight) {
if (containsAssociation(v1, v2)) {
Edge edge = getAssociationWeight(v1, v2);
edge.addWeight(edgeWeight);
} else {
graph.put(v1, v2, new Edge(edgeWeight));
}
}
public Edge getAssociationWeight(Vertex v1, Vertex v2) {
Edge edge = graph.get(v1, v2);
if (edge == null) {
edge = graph.get(v2, v1);
}
return edge;
}
public List<Vertex> getProductAssociations(Vertex v) {
Map<Vertex, Edge> adjacent = Maps.newHashMap(graph.row(v));
adjacent.putAll(graph.column(v));
return adjacent
.entrySet()
.stream()
.sorted((e1, e2) -> e2.getValue().weight - e1.getValue().weight)
.map(Map.Entry::getKey)
.collect(Collectors.toList());
}
public boolean containsAssociation(Vertex v1, Vertex v2) {
return graph.contains(v1, v2) || graph.contains(v2, v1);
}
public void clear() {
graph.clear();
}
@Override
public String toString() {
return "ProductAssociativityGraph{" + "graph=" + graph + '}';
}
}
public void testCreateCopyHashBasedTable() {
Table<String, Integer, Character> original = HashBasedTable.create();
original.put("foo", 1, 'a');
original.put("bar", 1, 'b');
original.put("foo", 3, 'c');
Table<String, Integer, Character> copy = ArrayTable.create(original);
assertEquals(4, copy.size());
assertEquals((Character) 'a', copy.get("foo", 1));
assertEquals((Character) 'b', copy.get("bar", 1));
assertEquals((Character) 'c', copy.get("foo", 3));
assertNull(copy.get("bar", 3));
original.put("foo", 1, 'd');
assertEquals((Character) 'd', original.get("foo", 1));
assertEquals((Character) 'a', copy.get("foo", 1));
assertEquals(copy.rowKeySet(), ImmutableSet.of("foo", "bar"));
assertEquals(copy.columnKeySet(), ImmutableSet.of(1, 3));
}
@Override
public void testEquals() {
table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
Table<String, Integer, Character> hashCopy = HashBasedTable.create();
hashCopy.put("foo", 1, 'a');
hashCopy.put("bar", 1, 'b');
hashCopy.put("foo", 3, 'c');
Table<String, Integer, Character> reordered =
create("foo", 3, 'c', "foo", 1, 'a', "bar", 1, 'b');
Table<String, Integer, Character> smaller = create("foo", 1, 'a', "bar", 1, 'b');
Table<String, Integer, Character> swapOuter =
create("bar", 1, 'a', "foo", 1, 'b', "bar", 3, 'c');
Table<String, Integer, Character> swapValues =
create("foo", 1, 'c', "bar", 1, 'b', "foo", 3, 'a');
new EqualsTester()
.addEqualityGroup(table, reordered)
.addEqualityGroup(hashCopy)
.addEqualityGroup(smaller)
.addEqualityGroup(swapOuter)
.addEqualityGroup(swapValues)
.testEquals();
}
public Builder() {
subDocuments = HashBasedTable.create();
structures = HashMultimap.create();
indexBySubDoc = Maps.newHashMap();
build = false;
}
@Override
Table<String, Character, Integer> makeTable() {
Table<String, Character, Integer> table = HashBasedTable.create();
return Tables.transformValues(table, DIVIDE_BY_2);
}
@Override
Table<String, Character, Integer> makeTable() {
Table<String, Character, Integer> table = HashBasedTable.create();
return Tables.unmodifiableTable(table);
}
@Override
Table<Integer, String, Character> makeTable() {
return HashBasedTable.create();
}
@Override
Table<Integer, String, Character> makeTable() {
Table<Integer, String, String> original = HashBasedTable.create();
return Tables.transformValues(original, FIRST_CHARACTER);
}
@Override
Table<Integer, String, Character> makeTable() {
Table<Integer, String, Character> original = HashBasedTable.create();
return Tables.unmodifiableTable(original);
}
