1498 lines
52 KiB
Java
1498 lines
52 KiB
Java
/*
|
|
* 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 static com.google.common.base.Preconditions.checkNotNull;
|
|
|
|
import com.google.common.annotations.GwtCompatible;
|
|
import com.google.common.annotations.GwtIncompatible;
|
|
import com.google.common.base.Function;
|
|
import com.google.common.base.Functions;
|
|
import com.google.common.collect.Table.Cell;
|
|
import com.google.common.collect.testing.CollectionTestSuiteBuilder;
|
|
import com.google.common.collect.testing.MapInterfaceTest;
|
|
import com.google.common.collect.testing.SampleElements;
|
|
import com.google.common.collect.testing.SetTestSuiteBuilder;
|
|
import com.google.common.collect.testing.SortedSetTestSuiteBuilder;
|
|
import com.google.common.collect.testing.TestSetGenerator;
|
|
import com.google.common.collect.testing.TestStringCollectionGenerator;
|
|
import com.google.common.collect.testing.TestStringSetGenerator;
|
|
import com.google.common.collect.testing.TestStringSortedSetGenerator;
|
|
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 java.util.Arrays;
|
|
import java.util.Collection;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import java.util.SortedMap;
|
|
import java.util.SortedSet;
|
|
import junit.framework.Test;
|
|
import junit.framework.TestCase;
|
|
import junit.framework.TestSuite;
|
|
|
|
/**
|
|
* 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
|
|
};
|
|
|
|
@GwtIncompatible // suite
|
|
public static Test suite() {
|
|
TestSuite suite = new TestSuite();
|
|
suite.addTestSuite(ArrayRowTests.class);
|
|
suite.addTestSuite(HashRowTests.class);
|
|
suite.addTestSuite(TreeRowTests.class);
|
|
suite.addTestSuite(TransposeRowTests.class);
|
|
suite.addTestSuite(TransformValueRowTests.class);
|
|
suite.addTestSuite(UnmodifiableHashRowTests.class);
|
|
suite.addTestSuite(UnmodifiableTreeRowTests.class);
|
|
suite.addTestSuite(ArrayColumnTests.class);
|
|
suite.addTestSuite(HashColumnTests.class);
|
|
suite.addTestSuite(TreeColumnTests.class);
|
|
suite.addTestSuite(TransposeColumnTests.class);
|
|
suite.addTestSuite(TransformValueColumnTests.class);
|
|
suite.addTestSuite(UnmodifiableHashColumnTests.class);
|
|
suite.addTestSuite(UnmodifiableTreeColumnTests.class);
|
|
suite.addTestSuite(ArrayRowMapTests.class);
|
|
suite.addTestSuite(HashRowMapTests.class);
|
|
suite.addTestSuite(TreeRowMapTests.class);
|
|
suite.addTestSuite(TreeRowMapHeadMapTests.class);
|
|
suite.addTestSuite(TreeRowMapTailMapTests.class);
|
|
suite.addTestSuite(TreeRowMapSubMapTests.class);
|
|
suite.addTestSuite(TransformValueRowMapTests.class);
|
|
suite.addTestSuite(UnmodifiableHashRowMapTests.class);
|
|
suite.addTestSuite(UnmodifiableTreeRowMapTests.class);
|
|
suite.addTestSuite(ArrayColumnMapTests.class);
|
|
suite.addTestSuite(HashColumnMapTests.class);
|
|
suite.addTestSuite(TreeColumnMapTests.class);
|
|
suite.addTestSuite(TransformValueColumnMapTests.class);
|
|
suite.addTestSuite(UnmodifiableHashColumnMapTests.class);
|
|
suite.addTestSuite(UnmodifiableTreeColumnMapTests.class);
|
|
|
|
// Not testing rowKeySet() or columnKeySet() of Table.transformValues()
|
|
// since the transformation doesn't affect the row and column key sets.
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestStringSetGenerator() {
|
|
@Override
|
|
protected Set<String> create(String[] elements) {
|
|
Table<String, Integer, Character> table =
|
|
ArrayTable.create(ImmutableList.copyOf(elements), ImmutableList.of(1, 2));
|
|
populateForRowKeySet(table, elements);
|
|
return table.rowKeySet();
|
|
}
|
|
})
|
|
.named("ArrayTable.rowKeySet")
|
|
.withFeatures(
|
|
CollectionSize.ONE,
|
|
CollectionSize.SEVERAL,
|
|
CollectionFeature.KNOWN_ORDER,
|
|
CollectionFeature.REJECTS_DUPLICATES_AT_CREATION,
|
|
CollectionFeature.ALLOWS_NULL_QUERIES)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestStringSetGenerator() {
|
|
@Override
|
|
protected Set<String> create(String[] elements) {
|
|
Table<String, Integer, Character> table = HashBasedTable.create();
|
|
populateForRowKeySet(table, elements);
|
|
return table.rowKeySet();
|
|
}
|
|
})
|
|
.named("HashBasedTable.rowKeySet")
|
|
.withFeatures(COLLECTION_FEATURES_REMOVE)
|
|
.withFeatures(CollectionFeature.SUPPORTS_ITERATOR_REMOVE)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SortedSetTestSuiteBuilder.using(
|
|
new TestStringSortedSetGenerator() {
|
|
@Override
|
|
protected SortedSet<String> create(String[] elements) {
|
|
TreeBasedTable<String, Integer, Character> table = TreeBasedTable.create();
|
|
populateForRowKeySet(table, elements);
|
|
return table.rowKeySet();
|
|
}
|
|
|
|
@Override
|
|
public List<String> order(List<String> insertionOrder) {
|
|
Collections.sort(insertionOrder);
|
|
return insertionOrder;
|
|
}
|
|
})
|
|
.named("TreeBasedTable.rowKeySet")
|
|
.withFeatures(COLLECTION_FEATURES_REMOVE_ORDER)
|
|
.withFeatures(CollectionFeature.SUPPORTS_ITERATOR_REMOVE)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestStringSetGenerator() {
|
|
@Override
|
|
protected Set<String> create(String[] elements) {
|
|
Table<String, Integer, Character> table = HashBasedTable.create();
|
|
populateForRowKeySet(table, elements);
|
|
return Tables.unmodifiableTable(table).rowKeySet();
|
|
}
|
|
})
|
|
.named("unmodifiableTable[HashBasedTable].rowKeySet")
|
|
.withFeatures(COLLECTION_FEATURES)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestStringSetGenerator() {
|
|
@Override
|
|
protected Set<String> create(String[] elements) {
|
|
RowSortedTable<String, Integer, Character> table = TreeBasedTable.create();
|
|
populateForRowKeySet(table, elements);
|
|
return Tables.unmodifiableRowSortedTable(table).rowKeySet();
|
|
}
|
|
|
|
@Override
|
|
public List<String> order(List<String> insertionOrder) {
|
|
Collections.sort(insertionOrder);
|
|
return insertionOrder;
|
|
}
|
|
})
|
|
.named("unmodifiableRowSortedTable[TreeBasedTable].rowKeySet")
|
|
.withFeatures(COLLECTION_FEATURES_ORDER)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestStringSetGenerator() {
|
|
@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();
|
|
}
|
|
})
|
|
.named("ArrayTable.columnKeySet")
|
|
.withFeatures(
|
|
CollectionSize.ONE,
|
|
CollectionSize.SEVERAL,
|
|
CollectionFeature.KNOWN_ORDER,
|
|
CollectionFeature.REJECTS_DUPLICATES_AT_CREATION,
|
|
CollectionFeature.ALLOWS_NULL_QUERIES)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestStringSetGenerator() {
|
|
@Override
|
|
protected Set<String> create(String[] elements) {
|
|
Table<Integer, String, Character> table = HashBasedTable.create();
|
|
populateForColumnKeySet(table, elements);
|
|
return table.columnKeySet();
|
|
}
|
|
})
|
|
.named("HashBasedTable.columnKeySet")
|
|
.withFeatures(COLLECTION_FEATURES_REMOVE)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestStringSetGenerator() {
|
|
@Override
|
|
protected Set<String> create(String[] elements) {
|
|
Table<Integer, String, Character> table = TreeBasedTable.create();
|
|
populateForColumnKeySet(table, elements);
|
|
return table.columnKeySet();
|
|
}
|
|
|
|
@Override
|
|
public List<String> order(List<String> insertionOrder) {
|
|
Collections.sort(insertionOrder);
|
|
return insertionOrder;
|
|
}
|
|
})
|
|
.named("TreeBasedTable.columnKeySet")
|
|
.withFeatures(COLLECTION_FEATURES_REMOVE_ORDER)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestStringSetGenerator() {
|
|
@Override
|
|
protected Set<String> create(String[] elements) {
|
|
Table<Integer, String, Character> table = HashBasedTable.create();
|
|
populateForColumnKeySet(table, elements);
|
|
return Tables.unmodifiableTable(table).columnKeySet();
|
|
}
|
|
})
|
|
.named("unmodifiableTable[HashBasedTable].columnKeySet")
|
|
.withFeatures(COLLECTION_FEATURES)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestStringSetGenerator() {
|
|
@Override
|
|
protected Set<String> create(String[] elements) {
|
|
RowSortedTable<Integer, String, Character> table = TreeBasedTable.create();
|
|
populateForColumnKeySet(table, elements);
|
|
return Tables.unmodifiableRowSortedTable(table).columnKeySet();
|
|
}
|
|
|
|
@Override
|
|
public List<String> order(List<String> insertionOrder) {
|
|
Collections.sort(insertionOrder);
|
|
return insertionOrder;
|
|
}
|
|
})
|
|
.named("unmodifiableRowSortedTable[TreeBasedTable].columnKeySet")
|
|
.withFeatures(COLLECTION_FEATURES_ORDER)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
CollectionTestSuiteBuilder.using(
|
|
new TestStringCollectionGenerator() {
|
|
@Override
|
|
protected Collection<String> create(String[] elements) {
|
|
List<Integer> rowKeys = Lists.newArrayList();
|
|
for (int i = 0; i < elements.length; i++) {
|
|
rowKeys.add(i);
|
|
}
|
|
Table<Integer, Character, String> table =
|
|
ArrayTable.create(rowKeys, ImmutableList.of('a'));
|
|
populateForValues(table, elements);
|
|
return table.values();
|
|
}
|
|
})
|
|
.named("ArrayTable.values")
|
|
.withFeatures(
|
|
CollectionSize.ONE,
|
|
CollectionSize.SEVERAL,
|
|
CollectionFeature.ALLOWS_NULL_VALUES,
|
|
CollectionFeature.KNOWN_ORDER)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
CollectionTestSuiteBuilder.using(
|
|
new TestStringCollectionGenerator() {
|
|
@Override
|
|
protected Collection<String> create(String[] elements) {
|
|
Table<Integer, Character, String> table = HashBasedTable.create();
|
|
table.put(1, 'a', "foo");
|
|
table.clear();
|
|
populateForValues(table, elements);
|
|
return table.values();
|
|
}
|
|
})
|
|
.named("HashBasedTable.values")
|
|
.withFeatures(COLLECTION_FEATURES_REMOVE)
|
|
.withFeatures(CollectionFeature.SUPPORTS_ITERATOR_REMOVE)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
CollectionTestSuiteBuilder.using(
|
|
new TestStringCollectionGenerator() {
|
|
@Override
|
|
protected Collection<String> create(String[] elements) {
|
|
Table<Integer, Character, String> table = TreeBasedTable.create();
|
|
table.put(1, 'a', "foo");
|
|
table.clear();
|
|
populateForValues(table, elements);
|
|
return table.values();
|
|
}
|
|
})
|
|
.named("TreeBasedTable.values")
|
|
.withFeatures(COLLECTION_FEATURES_REMOVE_ORDER)
|
|
.withFeatures(CollectionFeature.SUPPORTS_ITERATOR_REMOVE)
|
|
.createTestSuite());
|
|
|
|
final Function<String, String> removeFirstCharacter =
|
|
new Function<String, String>() {
|
|
@Override
|
|
public String apply(String input) {
|
|
return input.substring(1);
|
|
}
|
|
};
|
|
|
|
suite.addTest(
|
|
CollectionTestSuiteBuilder.using(
|
|
new TestStringCollectionGenerator() {
|
|
@Override
|
|
protected Collection<String> create(String[] elements) {
|
|
Table<Integer, Character, String> table = HashBasedTable.create();
|
|
for (int i = 0; i < elements.length; i++) {
|
|
table.put(i, 'a', "x" + checkNotNull(elements[i]));
|
|
}
|
|
return Tables.transformValues(table, removeFirstCharacter).values();
|
|
}
|
|
})
|
|
.named("TransformValues.values")
|
|
.withFeatures(COLLECTION_FEATURES_REMOVE)
|
|
.withFeatures(CollectionFeature.SUPPORTS_ITERATOR_REMOVE)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
CollectionTestSuiteBuilder.using(
|
|
new TestStringCollectionGenerator() {
|
|
@Override
|
|
protected Collection<String> create(String[] elements) {
|
|
Table<Integer, Character, String> table = HashBasedTable.create();
|
|
table.put(1, 'a', "foo");
|
|
table.clear();
|
|
populateForValues(table, elements);
|
|
return Tables.unmodifiableTable(table).values();
|
|
}
|
|
})
|
|
.named("unmodifiableTable[HashBasedTable].values")
|
|
.withFeatures(COLLECTION_FEATURES)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
CollectionTestSuiteBuilder.using(
|
|
new TestStringCollectionGenerator() {
|
|
@Override
|
|
protected Collection<String> create(String[] elements) {
|
|
RowSortedTable<Integer, Character, String> table = TreeBasedTable.create();
|
|
table.put(1, 'a', "foo");
|
|
table.clear();
|
|
populateForValues(table, elements);
|
|
return Tables.unmodifiableRowSortedTable(table).values();
|
|
}
|
|
})
|
|
.named("unmodifiableTable[TreeBasedTable].values")
|
|
.withFeatures(COLLECTION_FEATURES_ORDER)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestCellSetGenerator() {
|
|
@Override
|
|
public SampleElements<Cell<String, Integer, Character>> samples() {
|
|
return new SampleElements<>(
|
|
Tables.immutableCell("bar", 1, 'a'),
|
|
Tables.immutableCell("bar", 2, 'b'),
|
|
Tables.immutableCell("bar", 3, (Character) null),
|
|
Tables.immutableCell("bar", 4, 'b'),
|
|
Tables.immutableCell("bar", 5, 'b'));
|
|
}
|
|
|
|
@Override
|
|
public Set<Cell<String, Integer, Character>> create(Object... elements) {
|
|
List<Integer> columnKeys = Lists.newArrayList();
|
|
for (Object element : elements) {
|
|
@SuppressWarnings("unchecked")
|
|
Cell<String, Integer, Character> cell =
|
|
(Cell<String, Integer, Character>) element;
|
|
columnKeys.add(cell.getColumnKey());
|
|
}
|
|
Table<String, Integer, Character> table =
|
|
ArrayTable.create(ImmutableList.of("bar"), columnKeys);
|
|
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();
|
|
}
|
|
|
|
@Override
|
|
Table<String, Integer, Character> createTable() {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
})
|
|
.named("ArrayTable.cellSet")
|
|
.withFeatures(
|
|
CollectionSize.ONE,
|
|
CollectionSize.SEVERAL,
|
|
CollectionFeature.KNOWN_ORDER,
|
|
CollectionFeature.REJECTS_DUPLICATES_AT_CREATION,
|
|
CollectionFeature.ALLOWS_NULL_QUERIES)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestCellSetGenerator() {
|
|
@Override
|
|
Table<String, Integer, Character> createTable() {
|
|
return HashBasedTable.create();
|
|
}
|
|
})
|
|
.named("HashBasedTable.cellSet")
|
|
.withFeatures(
|
|
CollectionSize.ANY,
|
|
CollectionFeature.REMOVE_OPERATIONS,
|
|
CollectionFeature.ALLOWS_NULL_QUERIES)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestCellSetGenerator() {
|
|
@Override
|
|
Table<String, Integer, Character> createTable() {
|
|
return TreeBasedTable.create();
|
|
}
|
|
})
|
|
.named("TreeBasedTable.cellSet")
|
|
.withFeatures(
|
|
CollectionSize.ANY,
|
|
CollectionFeature.REMOVE_OPERATIONS,
|
|
CollectionFeature.ALLOWS_NULL_QUERIES)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestCellSetGenerator() {
|
|
@Override
|
|
Table<String, Integer, Character> createTable() {
|
|
Table<Integer, String, Character> original = TreeBasedTable.create();
|
|
return Tables.transpose(original);
|
|
}
|
|
})
|
|
.named("TransposedTable.cellSet")
|
|
.withFeatures(
|
|
CollectionSize.ANY,
|
|
CollectionFeature.REMOVE_OPERATIONS,
|
|
CollectionFeature.ALLOWS_NULL_QUERIES)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestCellSetGenerator() {
|
|
@Override
|
|
Table<String, Integer, Character> createTable() {
|
|
return HashBasedTable.create();
|
|
}
|
|
|
|
@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 Tables.transformValues(table, Functions.<Character>identity()).cellSet();
|
|
}
|
|
})
|
|
.named("TransformValues.cellSet")
|
|
.withFeatures(
|
|
CollectionSize.ANY,
|
|
CollectionFeature.ALLOWS_NULL_QUERIES,
|
|
CollectionFeature.REMOVE_OPERATIONS)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestCellSetGenerator() {
|
|
@Override
|
|
Table<String, Integer, Character> createTable() {
|
|
return Tables.unmodifiableTable(
|
|
HashBasedTable.<String, Integer, Character>create());
|
|
}
|
|
|
|
@Override
|
|
public Set<Cell<String, Integer, Character>> create(Object... elements) {
|
|
Table<String, Integer, Character> table = HashBasedTable.create();
|
|
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 Tables.unmodifiableTable(table).cellSet();
|
|
}
|
|
})
|
|
.named("unmodifiableTable[HashBasedTable].cellSet")
|
|
.withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_QUERIES)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestCellSetGenerator() {
|
|
@Override
|
|
RowSortedTable<String, Integer, Character> createTable() {
|
|
return Tables.unmodifiableRowSortedTable(
|
|
TreeBasedTable.<String, Integer, Character>create());
|
|
}
|
|
|
|
@Override
|
|
public Set<Cell<String, Integer, Character>> create(Object... elements) {
|
|
RowSortedTable<String, Integer, Character> table = TreeBasedTable.create();
|
|
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 Tables.unmodifiableRowSortedTable(table).cellSet();
|
|
}
|
|
})
|
|
.named("unmodifiableRowSortedTable[TreeBasedTable].cellSet")
|
|
.withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_QUERIES)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestStringSetGenerator() {
|
|
@Override
|
|
protected Set<String> create(String[] elements) {
|
|
Iterable<String> rowKeys = ImmutableSet.copyOf(elements);
|
|
Iterable<Integer> columnKeys = ImmutableList.of(1, 2, 3);
|
|
Table<String, Integer, Character> table =
|
|
ArrayTable.create(rowKeys, columnKeys);
|
|
populateForRowKeySet(table, elements);
|
|
return table.column(1).keySet();
|
|
}
|
|
})
|
|
.named("ArrayTable.column.keySet")
|
|
.withFeatures(
|
|
CollectionSize.ONE,
|
|
CollectionSize.SEVERAL,
|
|
CollectionFeature.KNOWN_ORDER,
|
|
CollectionFeature.ALLOWS_NULL_QUERIES)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestStringSetGenerator() {
|
|
@Override
|
|
protected Set<String> create(String[] elements) {
|
|
Table<String, Integer, Character> table = HashBasedTable.create();
|
|
populateForRowKeySet(table, elements);
|
|
return table.column(1).keySet();
|
|
}
|
|
})
|
|
.named("HashBasedTable.column.keySet")
|
|
.withFeatures(COLLECTION_FEATURES_REMOVE)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestStringSetGenerator() {
|
|
@Override
|
|
protected Set<String> create(String[] elements) {
|
|
Table<String, Integer, Character> table = TreeBasedTable.create();
|
|
populateForRowKeySet(table, elements);
|
|
return table.column(1).keySet();
|
|
}
|
|
|
|
@Override
|
|
public List<String> order(List<String> insertionOrder) {
|
|
Collections.sort(insertionOrder);
|
|
return insertionOrder;
|
|
}
|
|
})
|
|
.named("TreeBasedTable.column.keySet")
|
|
.withFeatures(COLLECTION_FEATURES_REMOVE_ORDER)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestStringSetGenerator() {
|
|
@Override
|
|
protected Set<String> create(String[] elements) {
|
|
Table<String, Integer, Character> table = HashBasedTable.create();
|
|
populateForRowKeySet(table, elements);
|
|
return Tables.transformValues(table, Functions.toStringFunction())
|
|
.column(1)
|
|
.keySet();
|
|
}
|
|
})
|
|
.named("TransformValues.column.keySet")
|
|
.withFeatures(COLLECTION_FEATURES_REMOVE)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestStringSetGenerator() {
|
|
@Override
|
|
protected Set<String> create(String[] elements) {
|
|
Table<String, Integer, Character> table = HashBasedTable.create();
|
|
populateForRowKeySet(table, elements);
|
|
return Tables.unmodifiableTable(table).column(1).keySet();
|
|
}
|
|
})
|
|
.named("unmodifiableTable[HashBasedTable].column.keySet")
|
|
.withFeatures(COLLECTION_FEATURES)
|
|
.createTestSuite());
|
|
|
|
suite.addTest(
|
|
SetTestSuiteBuilder.using(
|
|
new TestStringSetGenerator() {
|
|
@Override
|
|
protected Set<String> create(String[] elements) {
|
|
RowSortedTable<String, Integer, Character> table = TreeBasedTable.create();
|
|
populateForRowKeySet(table, elements);
|
|
return Tables.unmodifiableRowSortedTable(table).column(1).keySet();
|
|
}
|
|
|
|
@Override
|
|
public List<String> order(List<String> insertionOrder) {
|
|
Collections.sort(insertionOrder);
|
|
return insertionOrder;
|
|
}
|
|
})
|
|
.named("unmodifiableRowSortedTable[TreeBasedTable].column.keySet")
|
|
.withFeatures(COLLECTION_FEATURES_ORDER)
|
|
.createTestSuite());
|
|
|
|
return suite;
|
|
}
|
|
|
|
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 abstract static class TestCellSetGenerator
|
|
implements TestSetGenerator<Cell<String, Integer, Character>> {
|
|
@Override
|
|
public SampleElements<Cell<String, Integer, Character>> samples() {
|
|
return new SampleElements<>(
|
|
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 abstract static 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 abstract static 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');
|
|
}
|
|
}
|
|
|
|
@GwtIncompatible // TODO(hhchan): ArrayTable
|
|
public static class ArrayRowTests extends RowTests {
|
|
public ArrayRowTests() {
|
|
super(true, true, false, false, false);
|
|
}
|
|
|
|
@Override
|
|
protected String getKeyNotInPopulatedMap() {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override
|
|
protected Map<String, Integer> makeEmptyMap() {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override
|
|
protected Table<Character, String, Integer> makeTable() {
|
|
return ArrayTable.create(
|
|
Arrays.asList('a', 'b', 'c'), Arrays.asList("one", "two", "three", "four"));
|
|
}
|
|
}
|
|
|
|
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 abstract static 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');
|
|
}
|
|
}
|
|
|
|
@GwtIncompatible // TODO(hhchan): ArrayTable
|
|
public static class ArrayColumnTests extends ColumnTests {
|
|
public ArrayColumnTests() {
|
|
super(true, true, false, false, false);
|
|
}
|
|
|
|
@Override
|
|
protected String getKeyNotInPopulatedMap() {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override
|
|
protected Map<String, Integer> makeEmptyMap() {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override
|
|
Table<String, Character, Integer> makeTable() {
|
|
return ArrayTable.create(
|
|
Arrays.asList("one", "two", "three", "four"), Arrays.asList('a', 'b', 'c'));
|
|
}
|
|
}
|
|
|
|
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 abstract static 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 expected) {
|
|
}
|
|
}
|
|
assertInvariants(map);
|
|
}
|
|
}
|
|
|
|
private abstract static 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();
|
|
}
|
|
}
|
|
|
|
@GwtIncompatible // TODO(hhchan): ArrayTable
|
|
public static class ArrayRowMapTests extends RowMapTests {
|
|
public ArrayRowMapTests() {
|
|
super(true, false, false, false);
|
|
}
|
|
|
|
@Override
|
|
Table<String, Integer, Character> makeTable() {
|
|
return ArrayTable.create(Arrays.asList("foo", "bar", "dog"), Arrays.asList(1, 2, 3));
|
|
}
|
|
|
|
@Override
|
|
protected Map<String, Map<Integer, Character>> makeEmptyMap() {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
}
|
|
|
|
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 abstract static 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();
|
|
}
|
|
}
|
|
|
|
@GwtIncompatible // TODO(hhchan): ArrayTable
|
|
public static class ArrayColumnMapTests extends ColumnMapTests {
|
|
public ArrayColumnMapTests() {
|
|
super(true, false, false, false);
|
|
}
|
|
|
|
@Override
|
|
Table<Integer, String, Character> makeTable() {
|
|
return ArrayTable.create(Arrays.asList(1, 2, 3), Arrays.asList("foo", "bar", "dog"));
|
|
}
|
|
|
|
@Override
|
|
protected Map<String, Map<Integer, Character>> makeEmptyMap() {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
}
|
|
|
|
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();
|
|
}
|
|
}
|
|
}
|