Examples with TestStringSetGenerator com.google.common.collect.testing.TestStringSetGenerator used on opensource projects

Example 6 with TestStringSetGenerator

use of com.google.common.collect.testing.TestStringSetGenerator in project guava by hceylan.

the class ForwardingSetTest method suite.

public static Test suite() {
    TestSuite suite = new TestSuite();
    suite.addTestSuite(ForwardingSetTest.class);
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {

        @Override
        protected Set<String> create(String[] elements) {
            return new StandardImplForwardingSet<String>(Sets.newLinkedHashSet(asList(elements)));
        }
    }).named("ForwardingSet[LinkedHashSet] with standard implementations").withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_VALUES, CollectionFeature.GENERAL_PURPOSE).createTestSuite());
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {

        @Override
        protected Set<String> create(String[] elements) {
            return new StandardImplForwardingSet<String>(MinimalSet.of(elements));
        }
    }).named("ForwardingSet[MinimalSet] with standard implementations").withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_VALUES).createTestSuite());
    return suite;
}

Example 7 with TestStringSetGenerator

use of com.google.common.collect.testing.TestStringSetGenerator in project guava by hceylan.

the class ForwardingSortedSetTest method suite.

public static Test suite() {
    TestSuite suite = new TestSuite();
    suite.addTestSuite(ForwardingSortedSetTest.class);
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {

        @Override
        protected Set<String> create(String[] elements) {
            return new StandardImplForwardingSortedSet<String>(new SafeTreeSet<String>(Arrays.asList(elements)));
        }

        @Override
        public List<String> order(List<String> insertionOrder) {
            return Lists.newArrayList(Sets.newTreeSet(insertionOrder));
        }
    }).named("ForwardingSortedSet[SafeTreeSet] with standard implementations").withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, CollectionFeature.GENERAL_PURPOSE).createTestSuite());
    return suite;
}

Example 8 with TestStringSetGenerator

use of com.google.common.collect.testing.TestStringSetGenerator in project guava by google.

the class TableCollectionTest method suite.

// suite
@GwtIncompatible
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;
}

Example 9 with TestStringSetGenerator

use of com.google.common.collect.testing.TestStringSetGenerator in project guava by google.

the class TreeMultimapNaturalTest method suite.

// suite
@GwtIncompatible
public static Test suite() {
    TestSuite suite = new TestSuite();
    // TODO(lowasser): should we force TreeMultimap to be more thorough about checking nulls?
    suite.addTest(SortedSetMultimapTestSuiteBuilder.using(new TestStringSetMultimapGenerator() {

        @Override
        protected SetMultimap<String, String> create(Entry<String, String>[] entries) {
            SetMultimap<String, String> multimap = TreeMultimap.create(Ordering.natural().nullsFirst(), Ordering.natural().nullsFirst());
            for (Entry<String, String> entry : entries) {
                multimap.put(entry.getKey(), entry.getValue());
            }
            return multimap;
        }

        @Override
        public Iterable<Entry<String, String>> order(List<Entry<String, String>> insertionOrder) {
            return new Ordering<Entry<String, String>>() {

                @Override
                public int compare(Entry<String, String> left, Entry<String, String> right) {
                    return ComparisonChain.start().compare(left.getKey(), right.getKey(), Ordering.natural().nullsFirst()).compare(left.getValue(), right.getValue(), Ordering.natural().nullsFirst()).result();
                }
            }.sortedCopy(insertionOrder);
        }
    }).named("TreeMultimap nullsFirst").withFeatures(MapFeature.ALLOWS_NULL_KEYS, MapFeature.ALLOWS_NULL_VALUES, MapFeature.ALLOWS_ANY_NULL_QUERIES, MapFeature.GENERAL_PURPOSE, MapFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION, CollectionFeature.SUPPORTS_ITERATOR_REMOVE, CollectionFeature.KNOWN_ORDER, CollectionFeature.SERIALIZABLE, CollectionSize.ANY).createTestSuite());
    suite.addTest(NavigableSetTestSuiteBuilder.using(new TestStringSortedSetGenerator() {

        @Override
        protected NavigableSet<String> create(String[] elements) {
            TreeMultimap<String, Integer> multimap = TreeMultimap.create(Ordering.natural().nullsFirst(), Ordering.natural());
            for (int i = 0; i < elements.length; i++) {
                multimap.put(elements[i], i);
            }
            return multimap.keySet();
        }

        @Override
        public List<String> order(List<String> insertionOrder) {
            return Ordering.natural().nullsFirst().sortedCopy(insertionOrder);
        }
    }).named("TreeMultimap.keySet").withFeatures(CollectionFeature.ALLOWS_NULL_VALUES, CollectionFeature.REMOVE_OPERATIONS, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY).createTestSuite());
    suite.addTest(NavigableMapTestSuiteBuilder.using(new TestSortedMapGenerator<String, Collection<String>>() {

        @Override
        public String[] createKeyArray(int length) {
            return new String[length];
        }

        @SuppressWarnings("unchecked")
        @Override
        public Collection<String>[] createValueArray(int length) {
            return new Collection[length];
        }

        @Override
        public SampleElements<Entry<String, Collection<String>>> samples() {
            return new SampleElements<>(Helpers.mapEntry("a", (Collection<String>) ImmutableSortedSet.of("alex")), Helpers.mapEntry("b", (Collection<String>) ImmutableSortedSet.of("bob", "bagel")), Helpers.mapEntry("c", (Collection<String>) ImmutableSortedSet.of("carl", "carol")), Helpers.mapEntry("d", (Collection<String>) ImmutableSortedSet.of("david", "dead")), Helpers.mapEntry("e", (Collection<String>) ImmutableSortedSet.of("eric", "elaine")));
        }

        @SuppressWarnings("unchecked")
        @Override
        public Entry<String, Collection<String>>[] createArray(int length) {
            return new Entry[length];
        }

        @Override
        public Iterable<Entry<String, Collection<String>>> order(List<Entry<String, Collection<String>>> insertionOrder) {
            return new Ordering<Entry<String, ?>>() {

                @Override
                public int compare(Entry<String, ?> left, Entry<String, ?> right) {
                    return left.getKey().compareTo(right.getKey());
                }
            }.sortedCopy(insertionOrder);
        }

        @Override
        public NavigableMap<String, Collection<String>> create(Object... elements) {
            TreeMultimap<String, String> multimap = TreeMultimap.create();
            for (Object o : elements) {
                @SuppressWarnings("unchecked") Entry<String, Collection<String>> entry = (Entry<String, Collection<String>>) o;
                checkArgument(!multimap.containsKey(entry.getKey()));
                multimap.putAll(entry.getKey(), entry.getValue());
            }
            return multimap.asMap();
        }

        @Override
        public Entry<String, Collection<String>> belowSamplesLesser() {
            return Helpers.mapEntry("-- a", (Collection<String>) ImmutableSortedSet.of("--below"));
        }

        @Override
        public Entry<String, Collection<String>> belowSamplesGreater() {
            return Helpers.mapEntry("-- b", (Collection<String>) ImmutableSortedSet.of("--below"));
        }

        @Override
        public Entry<String, Collection<String>> aboveSamplesLesser() {
            return Helpers.mapEntry("~~ b", (Collection<String>) ImmutableSortedSet.of("~above"));
        }

        @Override
        public Entry<String, Collection<String>> aboveSamplesGreater() {
            return Helpers.mapEntry("~~ c", (Collection<String>) ImmutableSortedSet.of("~above"));
        }
    }).named("TreeMultimap.asMap").withFeatures(MapFeature.SUPPORTS_REMOVE, MapFeature.REJECTS_DUPLICATES_AT_CREATION, CollectionFeature.SUPPORTS_ITERATOR_REMOVE, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY).createTestSuite());
    suite.addTest(NavigableSetTestSuiteBuilder.using(new TestStringSetGenerator() {

        @Override
        protected Set<String> create(String[] elements) {
            TreeMultimap<Integer, String> multimap = TreeMultimap.create(Ordering.natural(), Ordering.natural().nullsFirst());
            multimap.putAll(1, Arrays.asList(elements));
            return multimap.get(1);
        }

        @Override
        public List<String> order(List<String> insertionOrder) {
            return Ordering.natural().nullsFirst().sortedCopy(insertionOrder);
        }
    }).named("TreeMultimap.get").withFeatures(CollectionFeature.ALLOWS_NULL_VALUES, CollectionFeature.GENERAL_PURPOSE, CollectionFeature.KNOWN_ORDER, CollectionSize.ANY).createTestSuite());
    suite.addTest(NavigableSetTestSuiteBuilder.using(new TestStringSetGenerator() {

        @Override
        protected Set<String> create(String[] elements) {
            TreeMultimap<Integer, String> multimap = TreeMultimap.create(Ordering.natural(), Ordering.natural().nullsFirst());
            multimap.putAll(1, Arrays.asList(elements));
            return (Set<String>) multimap.asMap().entrySet().iterator().next().getValue();
        }

        @Override
        public List<String> order(List<String> insertionOrder) {
            return Ordering.natural().nullsFirst().sortedCopy(insertionOrder);
        }
    }).named("TreeMultimap.asMap.entrySet collection").withFeatures(CollectionFeature.ALLOWS_NULL_VALUES, CollectionFeature.GENERAL_PURPOSE, CollectionFeature.KNOWN_ORDER, CollectionSize.ONE, CollectionSize.SEVERAL).createTestSuite());
    suite.addTestSuite(TreeMultimapNaturalTest.class);
    return suite;
}

Example 10 with TestStringSetGenerator

use of com.google.common.collect.testing.TestStringSetGenerator in project guava by google.

the class TreeMultisetTest method suite.

// suite
@GwtIncompatible
public static Test suite() {
    TestSuite suite = new TestSuite();
    suite.addTest(SortedMultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() {

        @Override
        protected Multiset<String> create(String[] elements) {
            return TreeMultiset.create(Arrays.asList(elements));
        }

        @Override
        public List<String> order(List<String> insertionOrder) {
            return Ordering.natural().sortedCopy(insertionOrder);
        }
    }).withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, CollectionFeature.GENERAL_PURPOSE, CollectionFeature.SERIALIZABLE, CollectionFeature.ALLOWS_NULL_QUERIES, MultisetFeature.ENTRIES_ARE_VIEWS).named("TreeMultiset, Ordering.natural").createTestSuite());
    suite.addTest(SortedMultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() {

        @Override
        protected Multiset<String> create(String[] elements) {
            Multiset<String> result = TreeMultiset.create(NullsBeforeB.INSTANCE);
            Collections.addAll(result, elements);
            return result;
        }

        @Override
        public List<String> order(List<String> insertionOrder) {
            sort(insertionOrder, NullsBeforeB.INSTANCE);
            return insertionOrder;
        }
    }).withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER, CollectionFeature.GENERAL_PURPOSE, CollectionFeature.SERIALIZABLE, CollectionFeature.ALLOWS_NULL_VALUES, MultisetFeature.ENTRIES_ARE_VIEWS).named("TreeMultiset, NullsBeforeB").createTestSuite());
    suite.addTest(NavigableSetTestSuiteBuilder.using(new TestStringSetGenerator() {

        @Override
        protected Set<String> create(String[] elements) {
            return TreeMultiset.create(Arrays.asList(elements)).elementSet();
        }

        @Override
        public List<String> order(List<String> insertionOrder) {
            return Lists.newArrayList(Sets.newTreeSet(insertionOrder));
        }
    }).named("TreeMultiset[Ordering.natural].elementSet").withFeatures(CollectionSize.ANY, CollectionFeature.REMOVE_OPERATIONS, CollectionFeature.ALLOWS_NULL_QUERIES).createTestSuite());
    suite.addTestSuite(TreeMultisetTest.class);
    return suite;
}