| /* |
| * Copyright (C) 2008 The Guava Authors |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.google.common.collect; |
| |
| import com.google.common.annotations.GwtCompatible; |
| import com.google.common.base.Function; |
| import com.google.common.collect.Table.Cell; |
| import com.google.common.collect.testing.MapInterfaceTest; |
| import com.google.common.collect.testing.SampleElements; |
| import com.google.common.collect.testing.TestSetGenerator; |
| import com.google.common.collect.testing.features.CollectionFeature; |
| import com.google.common.collect.testing.features.CollectionSize; |
| import com.google.common.collect.testing.features.Feature; |
| |
| import junit.framework.TestCase; |
| |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.SortedMap; |
| |
| /** |
| * Collection tests for {@link Table} implementations. |
| * |
| * @author Jared Levy |
| * @author Louis Wasserman |
| */ |
| @GwtCompatible(emulated = true) |
| public class TableCollectionTest extends TestCase { |
| |
| private static final Feature<?>[] COLLECTION_FEATURES = { |
| CollectionSize.ANY, |
| CollectionFeature.ALLOWS_NULL_QUERIES |
| }; |
| |
| private static final Feature<?>[] COLLECTION_FEATURES_ORDER = { |
| CollectionSize.ANY, |
| CollectionFeature.KNOWN_ORDER, |
| CollectionFeature.ALLOWS_NULL_QUERIES |
| }; |
| |
| private static final Feature<?>[] COLLECTION_FEATURES_REMOVE = { |
| CollectionSize.ANY, |
| CollectionFeature.SUPPORTS_REMOVE, |
| CollectionFeature.ALLOWS_NULL_QUERIES |
| }; |
| |
| private static final Feature<?>[] COLLECTION_FEATURES_REMOVE_ORDER = { |
| CollectionSize.ANY, |
| CollectionFeature.KNOWN_ORDER, |
| CollectionFeature.SUPPORTS_REMOVE, |
| CollectionFeature.ALLOWS_NULL_QUERIES |
| }; |
| |
| private static void populateForRowKeySet( |
| Table<String, Integer, Character> table, String[] elements) { |
| for (String row : elements) { |
| table.put(row, 1, 'a'); |
| table.put(row, 2, 'b'); |
| } |
| } |
| |
| private static void populateForColumnKeySet( |
| Table<Integer, String, Character> table, String[] elements) { |
| for (String column : elements) { |
| table.put(1, column, 'a'); |
| table.put(2, column, 'b'); |
| } |
| } |
| |
| private static void populateForValues( |
| Table<Integer, Character, String> table, String[] elements) { |
| for (int i = 0; i < elements.length; i++) { |
| table.put(i, 'a', elements[i]); |
| } |
| } |
| |
| private static abstract class TestCellSetGenerator |
| implements TestSetGenerator<Cell<String, Integer, Character>> { |
| @Override |
| public SampleElements<Cell<String, Integer, Character>> samples() { |
| return new SampleElements<Cell<String, Integer, Character>>( |
| Tables.immutableCell("bar", 1, 'a'), |
| Tables.immutableCell("bar", 2, 'b'), |
| Tables.immutableCell("foo", 3, 'c'), |
| Tables.immutableCell("bar", 1, 'b'), |
| Tables.immutableCell("cat", 2, 'b')); |
| } |
| |
| @Override |
| public Set<Cell<String, Integer, Character>> create( |
| Object... elements) { |
| Table<String, Integer, Character> table = createTable(); |
| for (Object element : elements) { |
| @SuppressWarnings("unchecked") |
| Cell<String, Integer, Character> cell |
| = (Cell<String, Integer, Character>) element; |
| table.put(cell.getRowKey(), cell.getColumnKey(), cell.getValue()); |
| } |
| return table.cellSet(); |
| } |
| |
| abstract Table<String, Integer, Character> createTable(); |
| |
| @Override |
| @SuppressWarnings("unchecked") |
| public Cell<String, Integer, Character>[] createArray(int length) { |
| return (Cell<String, Integer, Character>[]) new Cell<?, ?, ?>[length]; |
| } |
| |
| @Override |
| public List<Cell<String, Integer, Character>> order( |
| List<Cell<String, Integer, Character>> insertionOrder) { |
| return insertionOrder; |
| } |
| } |
| |
| private static abstract class MapTests |
| extends MapInterfaceTest<String, Integer> { |
| |
| MapTests(boolean allowsNullValues, boolean supportsPut, boolean supportsRemove, |
| boolean supportsClear, boolean supportsIteratorRemove) { |
| super(false, allowsNullValues, supportsPut, supportsRemove, supportsClear, |
| supportsIteratorRemove); |
| } |
| |
| @Override protected String getKeyNotInPopulatedMap() { |
| return "four"; |
| } |
| |
| @Override protected Integer getValueNotInPopulatedMap() { |
| return 4; |
| } |
| } |
| |
| private static abstract class RowTests extends MapTests { |
| RowTests(boolean allowsNullValues, boolean supportsPut, boolean supportsRemove, |
| boolean supportsClear, boolean supportsIteratorRemove) { |
| super(allowsNullValues, supportsPut, supportsRemove, supportsClear, |
| supportsIteratorRemove); |
| } |
| |
| abstract Table<Character, String, Integer> makeTable(); |
| |
| @Override protected Map<String, Integer> makeEmptyMap() { |
| return makeTable().row('a'); |
| } |
| |
| @Override protected Map<String, Integer> makePopulatedMap() { |
| Table<Character, String, Integer> table = makeTable(); |
| table.put('a', "one", 1); |
| table.put('a', "two", 2); |
| table.put('a', "three", 3); |
| table.put('b', "four", 4); |
| return table.row('a'); |
| } |
| } |
| |
| public static class HashRowTests extends RowTests { |
| public HashRowTests() { |
| super(false, true, true, true, true); |
| } |
| |
| @Override Table<Character, String, Integer> makeTable() { |
| return HashBasedTable.create(); |
| } |
| } |
| |
| public static class TreeRowTests extends RowTests { |
| public TreeRowTests() { |
| super(false, true, true, true, true); |
| } |
| |
| @Override Table<Character, String, Integer> makeTable() { |
| return TreeBasedTable.create(); |
| } |
| } |
| |
| public static class TransposeRowTests extends RowTests { |
| public TransposeRowTests() { |
| super(false, true, true, true, false); |
| } |
| |
| @Override Table<Character, String, Integer> makeTable() { |
| Table<String, Character, Integer> original = TreeBasedTable.create(); |
| return Tables.transpose(original); |
| } |
| } |
| |
| private static final Function<Integer, Integer> DIVIDE_BY_2 |
| = new Function<Integer, Integer>() { |
| @Override public Integer apply(Integer input) { |
| return (input == null) ? null : input / 2; |
| } |
| }; |
| |
| public static class TransformValueRowTests extends RowTests { |
| public TransformValueRowTests() { |
| super(false, false, true, true, true); |
| } |
| |
| @Override Table<Character, String, Integer> makeTable() { |
| Table<Character, String, Integer> table = HashBasedTable.create(); |
| return Tables.transformValues(table, DIVIDE_BY_2); |
| } |
| |
| @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'); |
| } |
| } |
| |
| public static class UnmodifiableHashRowTests extends RowTests { |
| public UnmodifiableHashRowTests() { |
| super(false, false, false, false, false); |
| } |
| |
| @Override Table<Character, String, Integer> makeTable() { |
| Table<Character, String, Integer> table = HashBasedTable.create(); |
| return Tables.unmodifiableTable(table); |
| } |
| |
| @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'); |
| } |
| } |
| |
| public static class UnmodifiableTreeRowTests extends RowTests { |
| public UnmodifiableTreeRowTests() { |
| super(false, false, false, false, false); |
| } |
| |
| @Override Table<Character, String, Integer> makeTable() { |
| RowSortedTable<Character, String, Integer> table = TreeBasedTable.create(); |
| return Tables.unmodifiableRowSortedTable(table); |
| } |
| |
| @Override protected Map<String, Integer> makePopulatedMap() { |
| RowSortedTable<Character, String, Integer> table = TreeBasedTable.create(); |
| table.put('a', "one", 1); |
| table.put('a', "two", 2); |
| table.put('a', "three", 3); |
| table.put('b', "four", 4); |
| return Tables.unmodifiableRowSortedTable(table).row('a'); |
| } |
| } |
| |
| private static abstract class ColumnTests extends MapTests { |
| ColumnTests(boolean allowsNullValues, boolean supportsPut, boolean supportsRemove, |
| boolean supportsClear, boolean supportsIteratorRemove) { |
| super(allowsNullValues, supportsPut, supportsRemove, supportsClear, |
| supportsIteratorRemove); |
| } |
| |
| abstract Table<String, Character, Integer> makeTable(); |
| |
| @Override protected Map<String, Integer> makeEmptyMap() { |
| return makeTable().column('a'); |
| } |
| |
| @Override protected Map<String, Integer> makePopulatedMap() { |
| Table<String, Character, Integer> table = makeTable(); |
| table.put("one", 'a', 1); |
| table.put("two", 'a', 2); |
| table.put("three", 'a', 3); |
| table.put("four", 'b', 4); |
| return table.column('a'); |
| } |
| } |
| |
| public static class HashColumnTests extends ColumnTests { |
| public HashColumnTests() { |
| super(false, true, true, true, false); |
| } |
| |
| @Override Table<String, Character, Integer> makeTable() { |
| return HashBasedTable.create(); |
| } |
| } |
| |
| public static class TreeColumnTests extends ColumnTests { |
| public TreeColumnTests() { |
| super(false, true, true, true, false); |
| } |
| |
| @Override Table<String, Character, Integer> makeTable() { |
| return TreeBasedTable.create(); |
| } |
| } |
| |
| public static class TransposeColumnTests extends ColumnTests { |
| public TransposeColumnTests() { |
| super(false, true, true, true, true); |
| } |
| |
| @Override Table<String, Character, Integer> makeTable() { |
| Table<Character, String, Integer> original = TreeBasedTable.create(); |
| return Tables.transpose(original); |
| } |
| } |
| |
| public static class TransformValueColumnTests extends ColumnTests { |
| public TransformValueColumnTests() { |
| super(false, false, true, true, false); |
| } |
| |
| @Override Table<String, Character, Integer> makeTable() { |
| Table<String, Character, Integer> table = HashBasedTable.create(); |
| return Tables.transformValues(table, DIVIDE_BY_2); |
| } |
| |
| @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'); |
| } |
| } |
| |
| public static class UnmodifiableHashColumnTests extends ColumnTests { |
| public UnmodifiableHashColumnTests() { |
| super(false, false, false, false, false); |
| } |
| |
| @Override Table<String, Character, Integer> makeTable() { |
| Table<String, Character, Integer> table = HashBasedTable.create(); |
| return Tables.unmodifiableTable(table); |
| } |
| |
| @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'); |
| } |
| } |
| |
| public static class UnmodifiableTreeColumnTests extends ColumnTests { |
| public UnmodifiableTreeColumnTests() { |
| super(false, false, false, false, false); |
| } |
| |
| @Override Table<String, Character, Integer> makeTable() { |
| RowSortedTable<String, Character, Integer> table = TreeBasedTable.create(); |
| return Tables.unmodifiableRowSortedTable(table); |
| } |
| |
| @Override protected Map<String, Integer> makePopulatedMap() { |
| RowSortedTable<String, Character, Integer> table = TreeBasedTable.create(); |
| table.put("one", 'a', 1); |
| table.put("two", 'a', 2); |
| table.put("three", 'a', 3); |
| table.put("four", 'b', 4); |
| return Tables.unmodifiableRowSortedTable(table).column('a'); |
| } |
| } |
| |
| private static abstract class MapMapTests |
| extends MapInterfaceTest<String, Map<Integer, Character>> { |
| |
| MapMapTests(boolean allowsNullValues, boolean supportsRemove, |
| boolean supportsClear, boolean supportsIteratorRemove) { |
| super(false, allowsNullValues, false, supportsRemove, supportsClear, |
| supportsIteratorRemove); |
| } |
| |
| @Override protected String getKeyNotInPopulatedMap() { |
| return "cat"; |
| } |
| |
| @Override protected Map<Integer, Character> getValueNotInPopulatedMap() { |
| return ImmutableMap.of(); |
| } |
| |
| /** |
| * The version of this test supplied by {@link MapInterfaceTest} fails for |
| * this particular map implementation, because {@code map.get()} returns a |
| * view collection that changes in the course of a call to {@code remove()}. |
| * Thus, the expectation doesn't hold that {@code map.remove(x)} returns the |
| * same value which {@code map.get(x)} did immediately beforehand. |
| */ |
| @Override public void testRemove() { |
| final Map<String, Map<Integer, Character>> map; |
| final String keyToRemove; |
| try { |
| map = makePopulatedMap(); |
| } catch (UnsupportedOperationException e) { |
| return; |
| } |
| keyToRemove = map.keySet().iterator().next(); |
| if (supportsRemove) { |
| int initialSize = map.size(); |
| map.get(keyToRemove); |
| map.remove(keyToRemove); |
| // This line doesn't hold - see the Javadoc comments above. |
| // assertEquals(expectedValue, oldValue); |
| assertFalse(map.containsKey(keyToRemove)); |
| assertEquals(initialSize - 1, map.size()); |
| } else { |
| try { |
| map.remove(keyToRemove); |
| fail("Expected UnsupportedOperationException."); |
| } catch (UnsupportedOperationException e) { |
| // Expected. |
| } |
| } |
| assertInvariants(map); |
| } |
| } |
| |
| private static abstract class RowMapTests extends MapMapTests { |
| RowMapTests(boolean allowsNullValues, boolean supportsRemove, |
| boolean supportsClear, boolean supportsIteratorRemove) { |
| super(allowsNullValues, supportsRemove, supportsClear, |
| supportsIteratorRemove); |
| } |
| |
| abstract Table<String, Integer, Character> makeTable(); |
| |
| @Override protected Map<String, Map<Integer, Character>> |
| makePopulatedMap() { |
| Table<String, Integer, Character> table = makeTable(); |
| populateTable(table); |
| return table.rowMap(); |
| } |
| |
| void populateTable(Table<String, Integer, Character> table) { |
| table.put("foo", 1, 'a'); |
| table.put("bar", 1, 'b'); |
| table.put("foo", 3, 'c'); |
| } |
| |
| @Override protected Map<String, Map<Integer, Character>> makeEmptyMap() { |
| return makeTable().rowMap(); |
| } |
| } |
| |
| public static class HashRowMapTests extends RowMapTests { |
| public HashRowMapTests() { |
| super(false, true, true, true); |
| } |
| |
| @Override Table<String, Integer, Character> makeTable() { |
| return HashBasedTable.create(); |
| } |
| } |
| |
| public static class TreeRowMapTests extends RowMapTests { |
| public TreeRowMapTests() { |
| super(false, true, true, true); |
| } |
| |
| @Override Table<String, Integer, Character> makeTable() { |
| return TreeBasedTable.create(); |
| } |
| } |
| |
| public static class TreeRowMapHeadMapTests extends RowMapTests { |
| public TreeRowMapHeadMapTests() { |
| super(false, true, true, true); |
| } |
| |
| @Override TreeBasedTable<String, Integer, Character> makeTable() { |
| TreeBasedTable<String, Integer, Character> table = |
| TreeBasedTable.create(); |
| table.put("z", 1, 'a'); |
| return table; |
| } |
| |
| @Override protected Map<String, Map<Integer, Character>> |
| makePopulatedMap() { |
| TreeBasedTable<String, Integer, Character> table = makeTable(); |
| populateTable(table); |
| return table.rowMap().headMap("x"); |
| } |
| |
| @Override protected Map<String, Map<Integer, Character>> makeEmptyMap() { |
| return makeTable().rowMap().headMap("x"); |
| } |
| |
| @Override protected String getKeyNotInPopulatedMap() { |
| return "z"; |
| } |
| } |
| |
| public static class TreeRowMapTailMapTests extends RowMapTests { |
| public TreeRowMapTailMapTests() { |
| super(false, true, true, true); |
| } |
| |
| @Override TreeBasedTable<String, Integer, Character> makeTable() { |
| TreeBasedTable<String, Integer, Character> table = |
| TreeBasedTable.create(); |
| table.put("a", 1, 'a'); |
| return table; |
| } |
| |
| @Override protected Map<String, Map<Integer, Character>> |
| makePopulatedMap() { |
| TreeBasedTable<String, Integer, Character> table = makeTable(); |
| populateTable(table); |
| return table.rowMap().tailMap("b"); |
| } |
| |
| @Override protected Map<String, Map<Integer, Character>> makeEmptyMap() { |
| return makeTable().rowMap().tailMap("b"); |
| } |
| |
| @Override protected String getKeyNotInPopulatedMap() { |
| return "a"; |
| } |
| } |
| |
| public static class TreeRowMapSubMapTests extends RowMapTests { |
| public TreeRowMapSubMapTests() { |
| super(false, true, true, true); |
| } |
| |
| @Override TreeBasedTable<String, Integer, Character> makeTable() { |
| TreeBasedTable<String, Integer, Character> table = |
| TreeBasedTable.create(); |
| table.put("a", 1, 'a'); |
| table.put("z", 1, 'a'); |
| return table; |
| } |
| |
| @Override protected Map<String, Map<Integer, Character>> |
| makePopulatedMap() { |
| TreeBasedTable<String, Integer, Character> table = makeTable(); |
| populateTable(table); |
| return table.rowMap().subMap("b", "x"); |
| } |
| |
| @Override protected Map<String, Map<Integer, Character>> makeEmptyMap() { |
| return makeTable().rowMap().subMap("b", "x"); |
| } |
| |
| @Override protected String getKeyNotInPopulatedMap() { |
| return "z"; |
| } |
| } |
| |
| private static final Function<String, Character> FIRST_CHARACTER = |
| new Function<String, Character>() { |
| @Override |
| public Character apply(String input) { |
| return input == null ? null : input.charAt(0); |
| } |
| }; |
| |
| public static class TransformValueRowMapTests extends RowMapTests { |
| public TransformValueRowMapTests() { |
| super(false, true, true, true); |
| } |
| |
| @Override Table<String, Integer, Character> makeTable() { |
| Table<String, Integer, String> original = HashBasedTable.create(); |
| return Tables.transformValues(original, FIRST_CHARACTER); |
| } |
| |
| @Override |
| protected Map<String, Map<Integer, Character>> makePopulatedMap() { |
| Table<String, Integer, String> table = HashBasedTable.create(); |
| table.put("foo", 1, "apple"); |
| table.put("bar", 1, "banana"); |
| table.put("foo", 3, "cat"); |
| return Tables.transformValues(table, FIRST_CHARACTER).rowMap(); |
| } |
| } |
| |
| public static class UnmodifiableHashRowMapTests extends RowMapTests { |
| public UnmodifiableHashRowMapTests() { |
| super(false, false, false, false); |
| } |
| |
| @Override Table<String, Integer, Character> makeTable() { |
| Table<String, Integer, Character> original = HashBasedTable.create(); |
| return Tables.unmodifiableTable(original); |
| } |
| |
| @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(); |
| } |
| } |
| |
| public static class UnmodifiableTreeRowMapTests extends RowMapTests { |
| public UnmodifiableTreeRowMapTests() { |
| super(false, false, false, false); |
| } |
| |
| @Override RowSortedTable<String, Integer, Character> makeTable() { |
| RowSortedTable<String, Integer, Character> original = TreeBasedTable.create(); |
| return Tables.unmodifiableRowSortedTable(original); |
| } |
| |
| @Override |
| protected SortedMap<String, Map<Integer, Character>> makePopulatedMap() { |
| RowSortedTable<String, Integer, Character> table = TreeBasedTable.create(); |
| table.put("foo", 1, 'a'); |
| table.put("bar", 1, 'b'); |
| table.put("foo", 3, 'c'); |
| return Tables.unmodifiableRowSortedTable(table).rowMap(); |
| } |
| } |
| |
| private static abstract class ColumnMapTests extends MapMapTests { |
| ColumnMapTests(boolean allowsNullValues, boolean supportsRemove, |
| boolean supportsClear, boolean supportsIteratorRemove) { |
| super(allowsNullValues, supportsRemove, supportsClear, |
| supportsIteratorRemove); |
| } |
| |
| abstract Table<Integer, String, Character> makeTable(); |
| |
| @Override protected Map<String, Map<Integer, Character>> |
| makePopulatedMap() { |
| Table<Integer, String, Character> table = makeTable(); |
| 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(); |
| } |
| } |
| |
| public static class HashColumnMapTests extends ColumnMapTests { |
| public HashColumnMapTests() { |
| super(false, true, true, false); |
| } |
| |
| @Override Table<Integer, String, Character> makeTable() { |
| return HashBasedTable.create(); |
| } |
| } |
| |
| public static class TreeColumnMapTests extends ColumnMapTests { |
| public TreeColumnMapTests() { |
| super(false, true, true, false); |
| } |
| |
| @Override Table<Integer, String, Character> makeTable() { |
| return TreeBasedTable.create(); |
| } |
| } |
| |
| public static class TransformValueColumnMapTests extends ColumnMapTests { |
| public TransformValueColumnMapTests() { |
| super(false, true, true, false); |
| } |
| |
| @Override Table<Integer, String, Character> makeTable() { |
| Table<Integer, String, String> original = HashBasedTable.create(); |
| return Tables.transformValues(original, FIRST_CHARACTER); |
| } |
| |
| @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(); |
| } |
| } |
| |
| public static class UnmodifiableHashColumnMapTests extends ColumnMapTests { |
| public UnmodifiableHashColumnMapTests() { |
| super(false, false, false, false); |
| } |
| |
| @Override Table<Integer, String, Character> makeTable() { |
| Table<Integer, String, Character> original = HashBasedTable.create(); |
| return Tables.unmodifiableTable(original); |
| } |
| |
| @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(); |
| } |
| } |
| |
| public static class UnmodifiableTreeColumnMapTests extends ColumnMapTests { |
| public UnmodifiableTreeColumnMapTests() { |
| super(false, false, false, false); |
| } |
| |
| @Override Table<Integer, String, Character> makeTable() { |
| RowSortedTable<Integer, String, Character> original = TreeBasedTable.create(); |
| return Tables.unmodifiableRowSortedTable(original); |
| } |
| |
| @Override |
| protected Map<String, Map<Integer, Character>> makePopulatedMap() { |
| RowSortedTable<Integer, String, Character> table = TreeBasedTable.create(); |
| table.put(1, "foo", 'a'); |
| table.put(1, "bar", 'b'); |
| table.put(3, "foo", 'c'); |
| return Tables.unmodifiableRowSortedTable(table).columnMap(); |
| } |
| } |
| } |
| |
