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

        })
        .named("ImmutableMultiset, reserialized")
        .withFeatures(CollectionSize.ANY)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            return SerializableTester.reserialize(
                ImmutableMultiset.of(elements).elementSet());
          }
        })

View Full Code Here

 */
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

      }
    };
  }


  static TestStringSetGenerator keySetGenerator() {
    return new TestStringSetGenerator() {
      @Override protected Set<String> create(String[] elements) {
        Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder();
        for (String key : elements) {
          builder.put(key, key.length());
        }

View Full Code Here

      }
    };
  }


  static TestStringSetGenerator headMapKeySetGenerator() {
    return new TestStringSetGenerator() {
      @Override protected Set<String> create(String[] elements) {
        Builder<String, Integer> builder = ImmutableSortedMap.naturalOrder();
        builder.put(AFTER_LAST, -1);
        for (String key : elements) {
          builder.put(key, key.length());

View Full Code Here

      }
    };
  }


  static TestStringSetGenerator keySetGenerator() {
    return new TestStringSetGenerator() {
      @Override protected Set<String> create(String[] elements) {
        Builder<String, Integer> builder = ImmutableMap.builder();
        for (String key : elements) {
          builder.put(key, key.length());
        }

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

View Full Code Here

 */
public class BiMapCollectionTest extends TestCase {


  public static Test suite() {
    TestSuite suite = new TestSuite();
    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            BiMap<String, Integer> bimap = HashBiMap.create();
            for (int i = 0; i < elements.length; i++) {
              bimap.put(elements[i], i);
            }
            return bimap.keySet();
          }
        })
        .named("HashBiMap.keySet")
        .withFeatures(CollectionSize.ANY,
            CollectionFeature.ALLOWS_NULL_VALUES,
            CollectionFeature.REMOVE_OPERATIONS)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            BiMap<Integer, String> bimap = HashBiMap.create();
            for (int i = 0; i < elements.length; i++) {
              bimap.put(i, elements[i]);
            }

View Full Code Here

public class ImmutableSetCollectionTest extends TestCase {


  public static Test suite() {
    TestSuite suite = new TestSuite();


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            return ImmutableSet.of(elements);
          }
        })
        .named(ImmutableSetTest.class.getName())
        .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            Set<String> set = ImmutableSet.of(elements);
            return SerializableTester.reserialize(set);
          }
        })
        .named(ImmutableSetTest.class.getName() + ", reserialized")
        .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestCollidingSetGenerator() {
          public Set<Object> create(Object... elements) {
            return ImmutableSet.of(elements);
          }
        })
        .named(ImmutableSetTest.class.getName() + ", with bad hashes")
        .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          // Make sure we get what we think we're getting, or else this test
          // is pointless
          @SuppressWarnings("cast")
          @Override protected Set<String> create(String[] elements) {
            return (ImmutableSet<String>)
                ImmutableSet.of(elements[0], elements[0]);
          }
        })
        .named(ImmutableSetTest.class.getName() + ", degenerate")
        .withFeatures(CollectionSize.ONE, CollectionFeature.KNOWN_ORDER)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(
        new TestStringSortedSetGenerator() {
          @Override protected SortedSet<String> create(String[] elements) {
            return ImmutableSortedSet.of(elements);
          }
        })
        .named(ImmutableSortedSetTest.class.getName())
        .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(
        new TestStringSortedSetGenerator() {
          @Override protected SortedSet<String> create(String[] elements) {
            SortedSet<String> set = ImmutableSortedSet.of(elements);
            return SerializableTester.reserialize(set);
          }
        })
        .named(ImmutableSortedSetTest.class.getName() + ", reserialized")
        .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(
        new TestStringSortedSetGenerator() {
          @Override protected SortedSet<String> create(String[] elements) {
            List<String> list = Lists.newArrayList(elements);
            list.add("zzz");
            return ImmutableSortedSet.copyOf(list)
                .headSet("zzy");
          }
        })
        .named(ImmutableSortedSetTest.class.getName() + ", headset")
        .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(
        new TestStringSortedSetGenerator() {
          @Override protected SortedSet<String> create(String[] elements) {
            List<String> list = Lists.newArrayList(elements);
            list.add("\0");
            return ImmutableSortedSet.copyOf(list)
                .tailSet("\0\0");
          }
        })
        .named(ImmutableSortedSetTest.class.getName() + ", tailset")
        .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(
        new TestStringSortedSetGenerator() {
          @Override protected SortedSet<String> create(String[] elements) {
            List<String> list = Lists.newArrayList(elements);
            list.add("\0");
            list.add("zzz");
            return ImmutableSortedSet.copyOf(list)
                .subSet("\0\0", "zzy");
          }
        })
        .named(ImmutableSortedSetTest.class.getName() + ", subset")
        .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(
        new TestStringSortedSetGenerator() {
          @Override protected SortedSet<String> create(String[] elements) {
            List<String> list = Lists.newArrayList(elements);
            list.add("zzz");
            return SerializableTester.reserialize(
                ImmutableSortedSet.copyOf(list).headSet("zzy"));
          }
        })
        .named(
            ImmutableSortedSetTest.class.getName() + ", headset, reserialized")
        .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(
        new TestStringSortedSetGenerator() {
          @Override protected SortedSet<String> create(String[] elements) {
            List<String> list = Lists.newArrayList(elements);
            list.add("\0");
            return SerializableTester.reserialize(
                ImmutableSortedSet.copyOf(list).tailSet("\0\0"));
          }
        })
        .named(
            ImmutableSortedSetTest.class.getName() + ", tailset, reserialized")
        .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(
        new TestStringSortedSetGenerator() {
          @Override protected SortedSet<String> create(String[] elements) {
            List<String> list = Lists.newArrayList(elements);
            list.add("\0");
            list.add("zzz");
            return SerializableTester.reserialize(
                ImmutableSortedSet.copyOf(list).subSet("\0\0", "zzy"));
          }
        })
        .named(
            ImmutableSortedSetTest.class.getName() + ", subset, reserialized")
        .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER)
        .createTestSuite());


    final Comparator<String> stringReversed = Collections.reverseOrder();


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected SortedSet<String> create(String[] elements) {
            return ImmutableSortedSet.orderedBy(stringReversed)
                .add(elements)
                .build();
          }


          @Override public List<String> order(List<String> insertionOrder) {
            Collections.sort(insertionOrder, Collections.reverseOrder());
            return insertionOrder;
          }
        })
        .named(ImmutableSortedSetTest.class.getName()
            + ", explicit comparator, vararg")
        .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER)
        .createTestSuite());


    final Comparator<Comparable<?>> comparableReversed
        = Collections.reverseOrder();


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected SortedSet<String> create(String[] elements) {
            return new ImmutableSortedSet.Builder<String>(comparableReversed)
                .add(elements)
                .build();
          }


          @Override public List<String> order(List<String> insertionOrder) {
            Collections.sort(insertionOrder, Collections.reverseOrder());
            return insertionOrder;
          }
        })
        .named(ImmutableSortedSetTest.class.getName()
            + ", explicit superclass comparator, iterable")
        .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER)
        .createTestSuite());


    suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected SortedSet<String> create(String[] elements) {
            return ImmutableSortedSet.<String>reverseOrder()
                .addAll(
                    Arrays.asList(elements).iterator())
                .build();

View Full Code Here

      }
    };
  }


  private static TestStringSetGenerator keySetGenerator() {
    return new TestStringSetGenerator() {
      @Override protected Set<String> create(String[] elements) {
        Map<String, Integer> map = Maps.newLinkedHashMap();
        for (int i = 0; i < elements.length; i++) {
          map.put(elements[i], i);
        }

View Full Code Here

      }
    };
  }


  private static TestStringSetGenerator valuesGenerator() {
    return new TestStringSetGenerator() {
      @Override protected Set<String> create(String[] elements) {
        Map<Integer, String> map = Maps.newLinkedHashMap();
        for (int i = 0; i < elements.length; i++) {
          map.put(i, elements[i]);
        }

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.