Examples of com.google.common.collect.testing.TestStringSetGenerator

Package com.google.common.collect.testing

Examples of com.google.common.collect.testing.TestStringSetGenerator

com.google.common.collect.testing.TestStringSetGenerator
Create string sets for collection tests.
This class is GWT compatible. @author Kevin Bourrillion

@GwtCompatible
public class SetOperationsTest extends TestCase {
  public static Test suite() {
    TestSuite suite = new TestSuite();


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            return Sets.union(
                Sets.<String>newHashSet(), Sets.<String>newHashSet());
          }
        })
        .named("empty U empty")
        .withFeatures(CollectionSize.ZERO, CollectionFeature.NONE,
            CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            checkArgument(elements.length == 1);
            return Sets.union(
                Sets.<String>newHashSet(elements), Sets.newHashSet(elements));
          }
        })
        .named("singleton U itself")
        .withFeatures(CollectionSize.ONE, CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            return Sets.union(
                Sets.<String>newHashSet(), Sets.newHashSet(elements));
          }
        })
        .named("empty U set")
        .withFeatures(CollectionSize.ONE, CollectionSize.SEVERAL,
            CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            return Sets.union(
                Sets.newHashSet(elements), Sets.<String>newHashSet());
          }
        })
        .named("set U empty")
        .withFeatures(CollectionSize.ONE, CollectionSize.SEVERAL,
            CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            checkArgument(elements.length == 3);
            // Put the sets in different orders for the hell of it
            return Sets.union(
                Sets.newLinkedHashSet(asList(elements)),
                Sets.newLinkedHashSet(
                    asList(elements[1], elements[0], elements[2])));
          }
        })
        .named("set U itself")
        .withFeatures(CollectionSize.SEVERAL,
            CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            checkArgument(elements.length == 3);
            return Sets.union(
                Sets.newHashSet(elements[0]),
                Sets.newHashSet(elements[1], elements[2]));
          }
        })
        .named("union of disjoint")
        .withFeatures(CollectionSize.SEVERAL,
            CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            return Sets.union(
                Sets.<String>newHashSet(elements[0], elements[1]),
                Sets.newHashSet(elements[1], elements[2]));
          }
        })
        .named("venn")
        .withFeatures(CollectionSize.SEVERAL,
            CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            return Sets.intersection(
                Sets.<String>newHashSet(), Sets.<String>newHashSet());
          }
        })
        .named("empty & empty")
        .withFeatures(CollectionSize.ZERO, CollectionFeature.NONE,
            CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            return Sets.intersection(
                Sets.<String>newHashSet(), Sets.newHashSet((String) null));
          }
        })
        .named("empty & singleton")
        .withFeatures(CollectionSize.ZERO, CollectionFeature.NONE,
            CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            return Sets.intersection(
                Sets.newHashSet("a", "b"), Sets.newHashSet("c", "d"));
          }
        })
        .named("intersection of disjoint")
        .withFeatures(CollectionSize.ZERO, CollectionFeature.NONE,
            CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            return Sets.intersection(
                Sets.newHashSet(elements), Sets.newHashSet(elements));
          }
        })
        .named("set & itself")
        .withFeatures(CollectionSize.ONE, CollectionSize.SEVERAL,
            CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            return Sets.intersection(
                Sets.newHashSet("a", elements[0], "b"),
                Sets.newHashSet("c", elements[0], "d"));
          }
        })
        .named("intersection with overlap of one")
        .withFeatures(CollectionSize.ONE, CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            return Sets.difference(
                Sets.<String>newHashSet(), Sets.<String>newHashSet());
          }
        })
        .named("empty - empty")
        .withFeatures(CollectionSize.ZERO, CollectionFeature.NONE,
            CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            return Sets.difference(Sets.newHashSet("a"), Sets.newHashSet("a"));
          }
        })
        .named("singleton - itself")
        .withFeatures(CollectionSize.ZERO, CollectionFeature.NONE,
            CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            Set<String> set = Sets.newHashSet("b", "c");
            Set<String> other = Sets.newHashSet("a", "b", "c", "d");
            return Sets.difference(set, other);
          }
        })
        .named("set - superset")
        .withFeatures(CollectionSize.ZERO, CollectionFeature.NONE,
            CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            Set<String> set = Sets.newHashSet(elements);
            Set<String> other = Sets.newHashSet("wz", "xq");
            set.addAll(other);
            other.add("pq");
            return Sets.difference(set, other);
          }
        })
        .named("set - set")
        .withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_VALUES,
            CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            return Sets.difference(
                Sets.newHashSet(elements), Sets.newHashSet());
          }
        })
        .named("set - empty")
        .withFeatures(CollectionSize.ONE, CollectionSize.SEVERAL,
            CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            return Sets.difference(
                Sets.<String>newHashSet(elements), Sets.newHashSet("xx", "xq"));
          }
        })

View Full Code Here

  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(

View Full Code Here

  @GwtIncompatible("suite")
  public static Test suite() {
    TestSuite suite = new TestSuite();
    suite.addTestSuite(SetsTest.class);


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            return Sets.newConcurrentHashSet(Arrays.asList(elements));
          }
        })
        .named("Sets.newConcurrentHashSet")
        .withFeatures(CollectionSize.ANY, SetFeature.GENERAL_PURPOSE)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            int size = elements.length;
            // Remove last element, if size > 1
            Set<String> set1 = (size > 1)
                ? Sets.newHashSet(
                    Arrays.asList(elements).subList(0, size - 1))
                : Sets.newHashSet(elements);
            // Remove first element, if size > 0
            Set<String> set2 = (size > 0)
                ? Sets.newHashSet(
                    Arrays.asList(elements).subList(1, size))
                : Sets.<String>newHashSet();
            return Sets.union(set1, set2);
          }
        })
        .named("Sets.union")
        .withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            Set<String> set1 = Sets.newHashSet(elements);
            set1.add(samples().e3());
            Set<String> set2 = Sets.newHashSet(elements);
            set2.add(samples().e4());
            return Sets.intersection(set1, set2);
          }
        })
        .named("Sets.intersection")
        .withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            Set<String> set1 = Sets.newHashSet(elements);
            set1.add(samples().e3());
            Set<String> set2 = Sets.newHashSet(samples().e3());
            return Sets.difference(set1, set2);
          }
        })
        .named("Sets.difference")
        .withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_VALUES)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestEnumSetGenerator() {
          @Override protected Set<AnEnum> create(AnEnum[] elements) {
            AnEnum[] otherElements = new AnEnum[elements.length - 1];
            System.arraycopy(
                elements, 1, otherElements, 0, otherElements.length);
            return Sets.immutableEnumSet(elements[0], otherElements);
          }
        })
        .named("Sets.immutableEnumSet")
        .withFeatures(CollectionSize.ONE, CollectionSize.SEVERAL,
            CollectionFeature.ALLOWS_NULL_QUERIES)
        .createTestSuite());


    suite.addTest(NavigableSetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            SafeTreeSet<String> set = new SafeTreeSet<String>(Arrays.asList(elements));
            return Sets.unmodifiableNavigableSet(set);
          }

View Full Code Here

    return suite;
  }


  @GwtIncompatible("suite")
  private static Test testsForFilter() {
    return SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override public Set<String> create(String[] elements) {
            Set<String> unfiltered = Sets.newLinkedHashSet();
            unfiltered.add("yyy");
            Collections.addAll(unfiltered, elements);
            unfiltered.add("zzz");

View Full Code Here

  }


  @GwtIncompatible("suite")
  private static Test testsForFilterNoNulls() {
    TestSuite suite = new TestSuite();
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override public Set<String> create(String[] elements) {
            Set<String> unfiltered = Sets.newLinkedHashSet();
            unfiltered.add("yyy");
            unfiltered.addAll(ImmutableList.copyOf(elements));
            unfiltered.add("zzz");
            return Sets.filter(unfiltered, Collections2Test.LENGTH_1);
          }
        })
        .named("Sets.filter, no nulls")
        .withFeatures(
            CollectionFeature.SUPPORTS_ADD,
            CollectionFeature.SUPPORTS_REMOVE,
            CollectionFeature.KNOWN_ORDER,
            CollectionSize.ANY,
            CollectionFeature.ALLOWS_NULL_QUERIES)
        .createTestSuite());
    suite.addTest(NavigableSetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override public NavigableSet<String> create(String[] elements) {
            NavigableSet<String> unfiltered = Sets.newTreeSet();
            unfiltered.add("yyy");
            unfiltered.addAll(ImmutableList.copyOf(elements));
            unfiltered.add("zzz");

View Full Code Here

    return suite;
  }


  @GwtIncompatible("suite")
  private static Test testsForFilterFiltered() {
    return SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override public Set<String> create(String[] elements) {
            Set<String> unfiltered = Sets.newLinkedHashSet();
            unfiltered.add("yyy");
            unfiltered.addAll(ImmutableList.copyOf(elements));
            unfiltered.add("zzz");

View Full Code Here

public class SynchronizedSetTest extends TestCase {
  
  public static final Object MUTEX = new Integer(1); // something Serializable
  
  public static Test suite() {
    return SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override
          protected Set<String> create(String[] elements) {
            TestSet<String> inner = new TestSet<String>(new HashSet<String>(), MUTEX);
            Set<String> outer = Synchronized.set(inner, inner.mutex);
            Collections.addAll(outer, elements);

View Full Code Here

        .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")

View Full Code Here

  };


  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();

View Full Code Here

  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)));
          }

View Full Code Here

0 1 2 3 4

TOP

Related Classes of com.google.common.collect.testing.TestStringSetGenerator

com.google.common.collect.BiMapCollectionTest

com.google.common.collect.ForwardingMultisetTest

com.google.common.collect.ForwardingNavigableSetTest

com.google.common.collect.ForwardingSetTest

com.google.common.collect.ForwardingSortedSetTest

com.google.common.collect.ImmutableBiMapTest

com.google.common.collect.ImmutableMapTest

com.google.common.collect.ImmutableMultisetTest

com.google.common.collect.ImmutableSetCollectionTest

com.google.common.collect.ImmutableSortedMapTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.