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

Example 1 with TestStringListGenerator

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

the class ImmutableMultisetTest method suite.

// suite // TODO(cpovirk): add to collect/gwt/suites
@GwtIncompatible
public static Test suite() {
    TestSuite suite = new TestSuite();
    suite.addTestSuite(ImmutableMultisetTest.class);
    suite.addTestSuite(FloodingTest.class);
    suite.addTest(MultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() {

        @Override
        protected Multiset<String> create(String[] elements) {
            return ImmutableMultiset.copyOf(elements);
        }
    }).named("ImmutableMultiset").withFeatures(CollectionSize.ANY, CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS, CollectionFeature.ALLOWS_NULL_QUERIES).createTestSuite());
    suite.addTest(MultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() {

        @Override
        protected Multiset<String> create(String[] elements) {
            return ImmutableMultiset.<String>builder().add(elements).buildJdkBacked();
        }
    }).named("ImmutableMultiset [JDK backed]").withFeatures(CollectionSize.ANY, CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS, CollectionFeature.ALLOWS_NULL_QUERIES).createTestSuite());
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {

        @Override
        protected Set<String> create(String[] elements) {
            return ImmutableMultiset.copyOf(elements).elementSet();
        }
    }).named("ImmutableMultiset, element set").withFeatures(CollectionSize.ANY, CollectionFeature.SERIALIZABLE, CollectionFeature.ALLOWS_NULL_QUERIES).createTestSuite());
    suite.addTest(ListTestSuiteBuilder.using(new TestStringListGenerator() {

        @Override
        protected List<String> create(String[] elements) {
            return ImmutableMultiset.copyOf(elements).asList();
        }

        @Override
        public List<String> order(List<String> insertionOrder) {
            List<String> order = new ArrayList<>();
            for (String s : insertionOrder) {
                int index = order.indexOf(s);
                if (index == -1) {
                    order.add(s);
                } else {
                    order.add(index, s);
                }
            }
            return order;
        }
    }).named("ImmutableMultiset.asList").withFeatures(CollectionSize.ANY, CollectionFeature.SERIALIZABLE, CollectionFeature.ALLOWS_NULL_QUERIES).createTestSuite());
    suite.addTest(ListTestSuiteBuilder.using(new TestStringListGenerator() {

        @Override
        protected List<String> create(String[] elements) {
            Set<String> set = new HashSet<>();
            ImmutableMultiset.Builder<String> builder = ImmutableMultiset.builder();
            for (String s : elements) {
                checkArgument(set.add(s));
                builder.addCopies(s, 2);
            }
            ImmutableSet<String> elementSet = (ImmutableSet<String>) builder.build().elementSet();
            return elementSet.asList();
        }
    }).named("ImmutableMultiset.elementSet.asList").withFeatures(CollectionSize.ANY, CollectionFeature.REJECTS_DUPLICATES_AT_CREATION, CollectionFeature.SERIALIZABLE, CollectionFeature.ALLOWS_NULL_QUERIES).createTestSuite());
    return suite;
}

Example 2 with TestStringListGenerator

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

the class ForwardingListTest method suite.

public static Test suite() {
    TestSuite suite = new TestSuite();
    suite.addTestSuite(ForwardingListTest.class);
    suite.addTest(ListTestSuiteBuilder.using(new TestStringListGenerator() {

        @Override
        protected List<String> create(String[] elements) {
            return new StandardImplForwardingList<String>(Lists.newArrayList(elements));
        }
    }).named("ForwardingList[ArrayList] with standard implementations").withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_VALUES, ListFeature.GENERAL_PURPOSE).createTestSuite());
    suite.addTest(ListTestSuiteBuilder.using(new TestStringListGenerator() {

        @Override
        protected List<String> create(String[] elements) {
            return new StandardImplForwardingList<String>(ImmutableList.copyOf(elements));
        }
    }).named("ForwardingList[ImmutableList] with standard implementations").withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_QUERIES).createTestSuite());
    return suite;
}

Example 3 with TestStringListGenerator

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

the class MultimapCollectionTest method suite.

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

        @Override
        protected Set<String> create(String[] elements) {
            SetMultimap<Integer, String> multimap = HashMultimap.create();
            populateMultimapForGet(multimap, elements);
            return multimap.get(3);
        }
    }).named("HashMultimap.get").withFeatures(COLLECTION_FEATURES).createTestSuite());
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {

        @Override
        protected Set<String> create(String[] elements) {
            SetMultimap<Integer, String> multimap = LinkedHashMultimap.create();
            populateMultimapForGet(multimap, elements);
            return multimap.get(3);
        }
    }).named("LinkedHashMultimap.get").withFeatures(COLLECTION_FEATURES_ORDER).createTestSuite());
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSortedSetGenerator() {

        @Override
        protected SortedSet<String> create(String[] elements) {
            SortedSetMultimap<Integer, String> multimap = TreeMultimap.create(Ordering.natural().nullsFirst(), Ordering.natural().nullsLast());
            populateMultimapForGet(multimap, elements);
            return multimap.get(3);
        }
    }).named("TreeMultimap.get").withFeatures(COLLECTION_FEATURES_ORDER).createTestSuite());
    suite.addTest(ListTestSuiteBuilder.using(new TestStringListGenerator() {

        @Override
        protected List<String> create(String[] elements) {
            ListMultimap<Integer, String> multimap = ArrayListMultimap.create();
            populateMultimapForGet(multimap, elements);
            return multimap.get(3);
        }
    }).named("ArrayListMultimap.get").withFeatures(LIST_FEATURES).createTestSuite());
    suite.addTest(ListTestSuiteBuilder.using(new TestStringListGenerator() {

        @Override
        protected List<String> create(String[] elements) {
            ListMultimap<Integer, String> multimap = Multimaps.synchronizedListMultimap(ArrayListMultimap.<Integer, String>create());
            populateMultimapForGet(multimap, elements);
            return multimap.get(3);
        }
    }).named("synchronized ArrayListMultimap.get").withFeatures(LIST_FEATURES).createTestSuite());
    suite.addTest(ListTestSuiteBuilder.using(new TestStringListGenerator() {

        @Override
        protected List<String> create(String[] elements) {
            ListMultimap<Integer, String> multimap = LinkedListMultimap.create();
            populateMultimapForGet(multimap, elements);
            return multimap.get(3);
        }
    }).named("LinkedListMultimap.get").withFeatures(LIST_FEATURES).createTestSuite());
    suite.addTest(ListTestSuiteBuilder.using(new TestStringListGenerator() {

        @Override
        protected List<String> create(String[] elements) {
            ImmutableListMultimap.Builder<Integer, String> builder = ImmutableListMultimap.builder();
            ListMultimap<Integer, String> multimap = builder.put(2, "foo").putAll(3, elements).build();
            return multimap.get(3);
        }
    }).named("ImmutableListMultimap.get").withFeatures(CollectionSize.ANY).createTestSuite());
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {

        @Override
        protected Set<String> create(String[] elements) {
            PopulatableMapAsMultimap<Integer, String> multimap = PopulatableMapAsMultimap.create();
            populateMultimapForGet(multimap, elements);
            return multimap.build().get(3);
        }
    }).named("Multimaps.forMap.get").withFeatures(FOR_MAP_FEATURES_ONE).createTestSuite());
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {

        @Override
        protected Set<String> create(String[] elements) {
            SetMultimap<Integer, String> multimap = LinkedHashMultimap.create();
            populateMultimapForGet(multimap, elements);
            multimap.put(3, "badvalue");
            multimap.put(55556, "foo");
            return (Set<String>) Multimaps.filterEntries(multimap, FILTER_GET_PREDICATE).get(3);
        }
    }).named("Multimaps.filterEntries.get").withFeatures(COLLECTION_FEATURES_ORDER).suppressing(CollectionIteratorTester.getIteratorKnownOrderRemoveSupportedMethod()).createTestSuite());
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {

        @Override
        protected Set<String> create(String[] elements) {
            Multimap<String, Integer> multimap = HashMultimap.create();
            populateMultimapForKeySet(multimap, elements);
            return multimap.keySet();
        }
    }).named("HashMultimap.keySet").withFeatures(COLLECTION_FEATURES_REMOVE).createTestSuite());
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {

        @Override
        protected Set<String> create(String[] elements) {
            Multimap<String, Integer> multimap = LinkedHashMultimap.create();
            populateMultimapForKeySet(multimap, elements);
            return multimap.keySet();
        }
    }).named("LinkedHashMultimap.keySet").withFeatures(COLLECTION_FEATURES_REMOVE_ORDER).createTestSuite());
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSortedSetGenerator() {

        @Override
        protected SortedSet<String> create(String[] elements) {
            TreeMultimap<String, Integer> multimap = TreeMultimap.create(Ordering.natural().nullsFirst(), Ordering.natural().nullsLast());
            populateMultimapForKeySet(multimap, elements);
            return multimap.keySet();
        }
    }).named("TreeMultimap.keySet").withFeatures(COLLECTION_FEATURES_REMOVE_ORDER).createTestSuite());
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {

        @Override
        protected Set<String> create(String[] elements) {
            Multimap<String, Integer> multimap = ArrayListMultimap.create();
            populateMultimapForKeySet(multimap, elements);
            return multimap.keySet();
        }
    }).named("ArrayListMultimap.keySet").withFeatures(COLLECTION_FEATURES_REMOVE).createTestSuite());
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {

        @Override
        protected Set<String> create(String[] elements) {
            Multimap<String, Integer> multimap = LinkedListMultimap.create();
            populateMultimapForKeySet(multimap, elements);
            return multimap.keySet();
        }
    }).named("LinkedListMultimap.keySet").withFeatures(COLLECTION_FEATURES_REMOVE_ORDER).createTestSuite());
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {

        @Override
        protected Set<String> create(String[] elements) {
            ImmutableListMultimap.Builder<String, Integer> builder = ImmutableListMultimap.builder();
            for (String element : elements) {
                builder.put(element, 2);
                builder.put(element, 3);
            }
            Multimap<String, Integer> multimap = builder.build();
            return multimap.keySet();
        }
    }).named("ImmutableListMultimap.keySet").withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER).createTestSuite());
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {

        @Override
        protected Set<String> create(String[] elements) {
            PopulatableMapAsMultimap<String, Integer> multimap = PopulatableMapAsMultimap.create();
            populateMultimapForKeySet(multimap, elements);
            return multimap.build().keySet();
        }
    }).named("Multimaps.forMap.keySet").withFeatures(FOR_MAP_FEATURES_ANY).createTestSuite());
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {

        @Override
        protected Set<String> create(String[] elements) {
            SetMultimap<String, Integer> multimap = LinkedHashMultimap.create();
            populateMultimapForKeySet(multimap, elements);
            multimap.put("badkey", 3);
            multimap.put("a", 55556);
            return Multimaps.filterEntries(multimap, FILTER_KEYSET_PREDICATE).keySet();
        }
    }).named("Multimaps.filterEntries.keySet").withFeatures(COLLECTION_FEATURES_REMOVE_ORDER).suppressing(CollectionIteratorTester.getIteratorKnownOrderRemoveSupportedMethod()).createTestSuite());
    suite.addTest(CollectionTestSuiteBuilder.using(new TestStringCollectionGenerator() {

        @Override
        public Collection<String> create(String[] elements) {
            Multimap<Integer, String> multimap = HashMultimap.create();
            populateMultimapForValues(multimap, elements);
            return multimap.values();
        }
    }).named("HashMultimap.values").withFeatures(COLLECTION_FEATURES_REMOVE).createTestSuite());
    suite.addTest(CollectionTestSuiteBuilder.using(new TestStringCollectionGenerator() {

        @Override
        public Collection<String> create(String[] elements) {
            Multimap<Integer, String> multimap = LinkedHashMultimap.create();
            populateMultimapForValues(multimap, elements);
            return multimap.values();
        }
    }).named("LinkedHashMultimap.values").withFeatures(COLLECTION_FEATURES_REMOVE_ORDER).createTestSuite());
    suite.addTest(CollectionTestSuiteBuilder.using(new TestStringCollectionGenerator() {

        @Override
        public Collection<String> create(String[] elements) {
            Multimap<Integer, String> multimap = TreeMultimap.create(Ordering.natural().nullsFirst(), Ordering.natural().nullsLast());
            populateMultimapForValues(multimap, elements);
            return multimap.values();
        }
    }).named("TreeMultimap.values").withFeatures(COLLECTION_FEATURES_REMOVE).createTestSuite());
    suite.addTest(CollectionTestSuiteBuilder.using(new TestStringCollectionGenerator() {

        @Override
        public Collection<String> create(String[] elements) {
            Multimap<Integer, String> multimap = ArrayListMultimap.create();
            populateMultimapForValues(multimap, elements);
            return multimap.values();
        }
    }).named("ArrayListMultimap.values").withFeatures(COLLECTION_FEATURES_REMOVE).createTestSuite());
    suite.addTest(ListTestSuiteBuilder.using(new TestStringListGenerator() {

        @Override
        public List<String> create(String[] elements) {
            LinkedListMultimap<Integer, String> multimap = LinkedListMultimap.create();
            populateMultimapForValues(multimap, elements);
            return multimap.values();
        }
    }).named("LinkedListMultimap.values").withFeatures(LIST_FEATURES_REMOVE_SET).createTestSuite());
    suite.addTest(CollectionTestSuiteBuilder.using(new TestStringCollectionGenerator() {

        @Override
        public Collection<String> create(String[] elements) {
            ImmutableListMultimap.Builder<Integer, String> builder = ImmutableListMultimap.builder();
            for (int i = 0; i < elements.length; i++) {
                builder.put(i % 2, elements[i]);
            }
            return builder.build().values();
        }
    }).named("ImmutableListMultimap.values").withFeatures(CollectionSize.ANY).createTestSuite());
    suite.addTest(CollectionTestSuiteBuilder.using(new TestStringCollectionGenerator() {

        @Override
        public Collection<String> create(String[] elements) {
            Multimap<Integer, String> multimap = LinkedHashMultimap.create();
            populateMultimapForValues(multimap, elements);
            multimap.put(3, "badvalue");
            multimap.put(55556, "foo");
            return Multimaps.filterEntries(multimap, FILTER_GET_PREDICATE).values();
        }
    }).named("Multimaps.filterEntries.values").withFeatures(COLLECTION_FEATURES_REMOVE_ORDER).suppressing(CollectionIteratorTester.getIteratorKnownOrderRemoveSupportedMethod()).createTestSuite());
    // TODO: use collection testers on Multimaps.forMap.values
    suite.addTest(MultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() {

        @Override
        protected Multiset<String> create(String[] elements) {
            Multimap<String, Integer> multimap = HashMultimap.create();
            populateMultimapForKeys(multimap, elements);
            return multimap.keys();
        }
    }).named("HashMultimap.keys").withFeatures(COLLECTION_FEATURES_REMOVE).createTestSuite());
    suite.addTest(MultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() {

        @Override
        protected Multiset<String> create(String[] elements) {
            Multimap<String, Integer> multimap = LinkedHashMultimap.create();
            populateMultimapForKeys(multimap, elements);
            return multimap.keys();
        }
    }).named("LinkedHashMultimap.keys").withFeatures(COLLECTION_FEATURES_REMOVE_ORDER).createTestSuite());
    suite.addTest(MultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() {

        @Override
        protected Multiset<String> create(String[] elements) {
            Multimap<String, Integer> multimap = TreeMultimap.create(Ordering.natural().nullsFirst(), Ordering.natural().nullsLast());
            populateMultimapForKeys(multimap, elements);
            return multimap.keys();
        }

        @Override
        public List<String> order(List<String> insertionOrder) {
            Collections.sort(insertionOrder, Ordering.natural().nullsFirst());
            return insertionOrder;
        }
    }).named("TreeMultimap.keys").withFeatures(COLLECTION_FEATURES_REMOVE_ORDER).createTestSuite());
    suite.addTest(MultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() {

        @Override
        protected Multiset<String> create(String[] elements) {
            Multimap<String, Integer> multimap = ArrayListMultimap.create();
            populateMultimapForKeys(multimap, elements);
            return multimap.keys();
        }
    }).named("ArrayListMultimap.keys").withFeatures(COLLECTION_FEATURES_REMOVE).createTestSuite());
    suite.addTest(MultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() {

        @Override
        protected Multiset<String> create(String[] elements) {
            Multimap<String, Integer> multimap = Multimaps.synchronizedListMultimap(ArrayListMultimap.<String, Integer>create());
            populateMultimapForKeys(multimap, elements);
            return multimap.keys();
        }
    }).named("synchronized ArrayListMultimap.keys").withFeatures(COLLECTION_FEATURES_REMOVE).createTestSuite());
    suite.addTest(MultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() {

        @Override
        protected Multiset<String> create(String[] elements) {
            Multimap<String, Integer> multimap = LinkedListMultimap.create();
            populateMultimapForKeys(multimap, elements);
            return multimap.keys();
        }
    }).named("LinkedListMultimap.keys").withFeatures(COLLECTION_FEATURES_REMOVE_ORDER).createTestSuite());
    suite.addTest(MultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() {

        @Override
        protected Multiset<String> create(String[] elements) {
            ImmutableListMultimap.Builder<String, Integer> builder = ImmutableListMultimap.builder();
            for (int i = 0; i < elements.length; i++) {
                builder.put(elements[i], i);
            }
            Multimap<String, Integer> multimap = builder.build();
            return multimap.keys();
        }
    }).named("ImmutableListMultimap.keys").withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER).createTestSuite());
    suite.addTest(MultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() {

        @Override
        protected Multiset<String> create(String[] elements) {
            PopulatableMapAsMultimap<String, Integer> multimap = PopulatableMapAsMultimap.create();
            populateMultimapForKeys(multimap, elements);
            return multimap.build().keys();
        }
    }).named("Multimaps.forMap.keys").withFeatures(FOR_MAP_FEATURES_ANY).suppressing(getReadsDuplicateInitializingMethods()).suppressing(getSetCountDuplicateInitializingMethods()).suppressing(getIteratorDuplicateInitializingMethods()).createTestSuite());
    suite.addTest(MultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() {

        @Override
        protected Multiset<String> create(String[] elements) {
            SetMultimap<String, Integer> multimap = LinkedHashMultimap.create();
            populateMultimapForKeys(multimap, elements);
            multimap.put("badkey", 3);
            multimap.put("a", 55556);
            return Multimaps.filterEntries(multimap, FILTER_KEYSET_PREDICATE).keys();
        }
    }).named("Multimaps.filterEntries.keys").withFeatures(COLLECTION_FEATURES_REMOVE_ORDER).suppressing(CollectionIteratorTester.getIteratorKnownOrderRemoveSupportedMethod()).suppressing(MultisetWritesTester.getEntrySetIteratorMethod()).suppressing(getIteratorDuplicateInitializingMethods()).createTestSuite());
    suite.addTest(CollectionTestSuiteBuilder.using(new TestEntrySetGenerator() {

        @Override
        SetMultimap<String, Integer> createMultimap() {
            return HashMultimap.create();
        }
    }).named("HashMultimap.entries").withFeatures(CollectionSize.ANY, CollectionFeature.REMOVE_OPERATIONS).createTestSuite());
    suite.addTest(CollectionTestSuiteBuilder.using(new TestEntrySetGenerator() {

        @Override
        SetMultimap<String, Integer> createMultimap() {
            return LinkedHashMultimap.create();
        }
    }).named("LinkedHashMultimap.entries").withFeatures(CollectionSize.ANY, CollectionFeature.REMOVE_OPERATIONS, CollectionFeature.KNOWN_ORDER).createTestSuite());
    suite.addTest(CollectionTestSuiteBuilder.using(new TestEntrySetGenerator() {

        @Override
        SetMultimap<String, Integer> createMultimap() {
            return TreeMultimap.create(Ordering.natural().nullsFirst(), Ordering.natural().nullsLast());
        }
    }).named("TreeMultimap.entries").withFeatures(CollectionSize.ANY, CollectionFeature.REMOVE_OPERATIONS, CollectionFeature.KNOWN_ORDER).createTestSuite());
    suite.addTest(CollectionTestSuiteBuilder.using(new TestEntriesGenerator() {

        @Override
        Multimap<String, Integer> createMultimap() {
            return ArrayListMultimap.create();
        }
    }).named("ArrayListMultimap.entries").withFeatures(CollectionSize.ANY, CollectionFeature.REMOVE_OPERATIONS).createTestSuite());
    suite.addTest(CollectionTestSuiteBuilder.using(new TestEntriesGenerator() {

        @Override
        Multimap<String, Integer> createMultimap() {
            return Multimaps.synchronizedListMultimap(ArrayListMultimap.<String, Integer>create());
        }
    }).named("synchronized ArrayListMultimap.entries").withFeatures(CollectionSize.ANY, CollectionFeature.REMOVE_OPERATIONS).createTestSuite());
    suite.addTest(ListTestSuiteBuilder.using(new TestEntriesListGenerator() {

        @Override
        Multimap<String, Integer> createMultimap() {
            return LinkedListMultimap.create();
        }
    }).named("LinkedListMultimap.entries").withFeatures(CollectionSize.ANY, ListFeature.REMOVE_OPERATIONS, CollectionFeature.KNOWN_ORDER).createTestSuite());
    suite.addTest(CollectionTestSuiteBuilder.using(new TestEntriesGenerator() {

        @Override
        Multimap<String, Integer> createMultimap() {
            return ImmutableListMultimap.of();
        }

        @Override
        public Collection<Entry<String, Integer>> create(Object... elements) {
            ImmutableListMultimap.Builder<String, Integer> builder = ImmutableListMultimap.builder();
            for (Object element : elements) {
                @SuppressWarnings("unchecked") Entry<String, Integer> entry = (Entry<String, Integer>) element;
                builder.put(entry.getKey(), entry.getValue());
            }
            return builder.build().entries();
        }
    }).named("ImmutableListMultimap.entries").withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER).createTestSuite());
    suite.addTest(CollectionTestSuiteBuilder.using(new TestEntriesGenerator() {

        @Override
        Multimap<String, Integer> createMultimap() {
            Multimap<String, Integer> multimap = LinkedHashMultimap.create();
            multimap.put("badkey", 3);
            multimap.put("a", 55556);
            return Multimaps.filterEntries(multimap, FILTER_KEYSET_PREDICATE);
        }
    }).named("Multimap.filterEntries.entries").withFeatures(CollectionSize.ANY, CollectionFeature.REMOVE_OPERATIONS, CollectionFeature.KNOWN_ORDER).suppressing(CollectionIteratorTester.getIteratorKnownOrderRemoveSupportedMethod()).createTestSuite());
    suite.addTest(ListTestSuiteBuilder.using(new TestStringListGenerator() {

        @Override
        protected List<String> create(String[] elements) {
            ListMultimap<Integer, String> multimap = ArrayListMultimap.create();
            populateMultimapForGet(multimap, elements);
            return Multimaps.transformValues(multimap, Functions.<String>identity()).get(3);
        }
    }).named("Multimaps.transformValues[ListMultimap].get").withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_VALUES, CollectionFeature.REMOVE_OPERATIONS, ListFeature.SUPPORTS_REMOVE_WITH_INDEX).createTestSuite());
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {

        @Override
        protected Set<String> create(String[] elements) {
            ListMultimap<String, Integer> multimap = ArrayListMultimap.create();
            populateMultimapForKeySet(multimap, elements);
            return Multimaps.transformValues(multimap, Functions.<Integer>identity()).keySet();
        }
    }).named("Multimaps.transformValues[ListMultimap].keySet").withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_VALUES, CollectionFeature.REMOVE_OPERATIONS).createTestSuite());
    suite.addTest(MultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() {

        @Override
        protected Multiset<String> create(String[] elements) {
            ListMultimap<String, Integer> multimap = ArrayListMultimap.create();
            populateMultimapForKeys(multimap, elements);
            return Multimaps.transformValues(multimap, Functions.<Integer>identity()).keys();
        }
    }).named("Multimaps.transform[ListMultimap].keys").withFeatures(COLLECTION_FEATURES_REMOVE).createTestSuite());
    suite.addTest(CollectionTestSuiteBuilder.using(new TestStringCollectionGenerator() {

        @Override
        public Collection<String> create(String[] elements) {
            ListMultimap<Integer, String> multimap = ArrayListMultimap.create();
            populateMultimapForValues(multimap, elements);
            return Multimaps.transformValues(multimap, Functions.<String>identity()).values();
        }
    }).named("Multimaps.transformValues[ListMultimap].values").withFeatures(COLLECTION_FEATURES_REMOVE).createTestSuite());
    suite.addTest(CollectionTestSuiteBuilder.using(new TestEntriesGenerator() {

        @Override
        public Collection<Entry<String, Integer>> create(Object... elements) {
            ListMultimap<String, Integer> multimap = ArrayListMultimap.create();
            for (Object element : elements) {
                @SuppressWarnings("unchecked") Entry<String, Integer> entry = (Entry<String, Integer>) element;
                multimap.put(entry.getKey(), entry.getValue());
            }
            return Multimaps.transformValues(multimap, Functions.<Integer>identity()).entries();
        }

        @Override
        Multimap<String, Integer> createMultimap() {
            return Multimaps.transformValues(ArrayListMultimap.<String, Integer>create(), Functions.<Integer>identity());
        }
    }).named("Multimaps.transformValues[ListMultimap].entries").withFeatures(CollectionSize.ANY, CollectionFeature.REMOVE_OPERATIONS).createTestSuite());
    suite.addTest(CollectionTestSuiteBuilder.using(new TestStringCollectionGenerator() {

        @Override
        protected Collection<String> create(String[] elements) {
            Multimap<Integer, String> multimap = ArrayListMultimap.create();
            populateMultimapForGet(multimap, elements);
            return Multimaps.transformValues(multimap, Functions.<String>identity()).get(3);
        }
    }).named("Multimaps.transformValues[Multimap].get").withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_VALUES, CollectionFeature.REMOVE_OPERATIONS).createTestSuite());
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {

        @Override
        protected Set<String> create(String[] elements) {
            Multimap<String, Integer> multimap = ArrayListMultimap.create();
            populateMultimapForKeySet(multimap, elements);
            return Multimaps.transformValues(multimap, Functions.<Integer>identity()).keySet();
        }
    }).named("Multimaps.transformValues[Multimap].keySet").withFeatures(COLLECTION_FEATURES_REMOVE).createTestSuite());
    suite.addTest(MultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() {

        @Override
        protected Multiset<String> create(String[] elements) {
            Multimap<String, Integer> multimap = ArrayListMultimap.create();
            populateMultimapForKeys(multimap, elements);
            return Multimaps.transformValues(multimap, Functions.<Integer>identity()).keys();
        }
    }).named("Multimaps.transformValues[Multimap].keys").withFeatures(COLLECTION_FEATURES_REMOVE).createTestSuite());
    suite.addTest(CollectionTestSuiteBuilder.using(new TestStringCollectionGenerator() {

        @Override
        public Collection<String> create(String[] elements) {
            Multimap<Integer, String> multimap = ArrayListMultimap.create();
            populateMultimapForValues(multimap, elements);
            return Multimaps.transformValues(multimap, Functions.<String>identity()).values();
        }
    }).named("Multimaps.transformValues[Multimap].values").withFeatures(COLLECTION_FEATURES_REMOVE).createTestSuite());
    suite.addTest(CollectionTestSuiteBuilder.using(new TestEntriesGenerator() {

        @Override
        public Collection<Entry<String, Integer>> create(Object... elements) {
            Multimap<String, Integer> multimap = ArrayListMultimap.create();
            for (Object element : elements) {
                @SuppressWarnings("unchecked") Entry<String, Integer> entry = (Entry<String, Integer>) element;
                multimap.put(entry.getKey(), entry.getValue());
            }
            return Multimaps.transformValues(multimap, Functions.<Integer>identity()).entries();
        }

        @Override
        Multimap<String, Integer> createMultimap() {
            return Multimaps.transformValues((Multimap<String, Integer>) ArrayListMultimap.<String, Integer>create(), Functions.<Integer>identity());
        }
    }).named("Multimaps.transformValues[Multimap].entries").withFeatures(CollectionSize.ANY, CollectionFeature.REMOVE_OPERATIONS).createTestSuite());
    return suite;
}

Example 4 with TestStringListGenerator

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

the class ImmutableSortedMultisetTest method suite.

public static Test suite() {
    TestSuite suite = new TestSuite();
    suite.addTestSuite(ImmutableSortedMultisetTest.class);
    suite.addTest(SortedMultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() {

        @Override
        protected Multiset<String> create(String[] elements) {
            return ImmutableSortedMultiset.copyOf(elements);
        }

        @Override
        public List<String> order(List<String> insertionOrder) {
            return Ordering.natural().sortedCopy(insertionOrder);
        }
    }).named("ImmutableSortedMultiset").withFeatures(CollectionSize.ANY, CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS, CollectionFeature.ALLOWS_NULL_QUERIES).createTestSuite());
    suite.addTest(ListTestSuiteBuilder.using(new TestStringListGenerator() {

        @Override
        protected List<String> create(String[] elements) {
            return ImmutableSortedMultiset.copyOf(elements).asList();
        }

        @Override
        public List<String> order(List<String> insertionOrder) {
            return Ordering.natural().sortedCopy(insertionOrder);
        }
    }).named("ImmutableSortedMultiset.asList").withFeatures(CollectionSize.ANY, CollectionFeature.SERIALIZABLE, CollectionFeature.ALLOWS_NULL_QUERIES).createTestSuite());
    suite.addTest(ListTestSuiteBuilder.using(new TestStringListGenerator() {

        @Override
        protected List<String> create(String[] elements) {
            Set<String> set = Sets.newHashSet();
            ImmutableSortedMultiset.Builder<String> builder = ImmutableSortedMultiset.naturalOrder();
            for (String s : elements) {
                checkArgument(set.add(s));
                builder.addCopies(s, 2);
            }
            return builder.build().elementSet().asList();
        }

        @Override
        public List<String> order(List<String> insertionOrder) {
            return Ordering.natural().sortedCopy(insertionOrder);
        }
    }).named("ImmutableSortedMultiset.elementSet.asList").withFeatures(CollectionSize.ANY, CollectionFeature.REJECTS_DUPLICATES_AT_CREATION, CollectionFeature.SERIALIZABLE, CollectionFeature.ALLOWS_NULL_QUERIES).createTestSuite());
    return suite;
}

Example 5 with TestStringListGenerator

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

the class ForwardingListTest method suite.

public static Test suite() {
    TestSuite suite = new TestSuite();
    suite.addTestSuite(ForwardingListTest.class);
    suite.addTest(ListTestSuiteBuilder.using(new TestStringListGenerator() {

        @Override
        protected List<String> create(String[] elements) {
            return new StandardImplForwardingList<>(Lists.newArrayList(elements));
        }
    }).named("ForwardingList[ArrayList] with standard implementations").withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_VALUES, ListFeature.GENERAL_PURPOSE).createTestSuite());
    suite.addTest(ListTestSuiteBuilder.using(new TestStringListGenerator() {

        @Override
        protected List<String> create(String[] elements) {
            return new StandardImplForwardingList<>(ImmutableList.copyOf(elements));
        }
    }).named("ForwardingList[ImmutableList] with standard implementations").withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_QUERIES).createTestSuite());
    return suite;
}