예제 #1
0
 @Test
 public void properSubsetEqual() {
   MutableSet<String> setA = UnifiedSet.newSetWith("Bertha", null, "Myra");
   MutableSet<String> setB = UnifiedSet.newSetWith("Myra", "Bertha", null);
   Assert.assertFalse(Sets.isProperSubsetOf(setA, setB));
   Assert.assertFalse(Sets.isProperSubsetOf(setB, setA));
 }
예제 #2
0
 @Test
 public void properSubsetNotEmpty() {
   MutableSet<String> singletonSet = UnifiedSet.newSetWith("Bertha");
   MutableSet<String> doubletonSet = UnifiedSet.newSetWith("Bertha", "Myra");
   Assert.assertTrue(Sets.isProperSubsetOf(singletonSet, doubletonSet));
   Assert.assertFalse(Sets.isProperSubsetOf(doubletonSet, singletonSet));
 }
 @Test
 public void flatCollect() {
   Function<Integer, MutableSet<String>> function =
       object -> UnifiedSet.newSetWith(object.toString());
   Verify.assertListsEqual(
       FastList.newListWith("1"), SingletonListTest.newWith(1).flatCollect(function));
   Verify.assertSetsEqual(
       UnifiedSet.newSetWith("1"),
       SingletonListTest.newWith(1).flatCollect(function, UnifiedSet.<String>newSet()));
 }
예제 #4
0
 @Test
 public void fixedSize() {
   FixedSizeSetFactory setFactory = Sets.fixedSize;
   Assert.assertEquals(UnifiedSet.newSet(), setFactory.of());
   Verify.assertInstanceOf(FixedSizeSet.class, setFactory.of());
   Assert.assertEquals(UnifiedSet.newSetWith(1), setFactory.of(1));
   Verify.assertInstanceOf(FixedSizeSet.class, setFactory.of(1));
   Assert.assertEquals(UnifiedSet.newSetWith(1, 2), setFactory.of(1, 2));
   Verify.assertInstanceOf(FixedSizeSet.class, setFactory.of(1, 2));
   Assert.assertEquals(UnifiedSet.newSetWith(1, 2, 3), setFactory.of(1, 2, 3));
   Verify.assertInstanceOf(FixedSizeSet.class, setFactory.of(1, 2, 3));
   Assert.assertEquals(UnifiedSet.newSetWith(1, 2, 3, 4), setFactory.of(1, 2, 3, 4));
   Verify.assertInstanceOf(FixedSizeSet.class, setFactory.of(1, 2, 3, 4));
 }
예제 #5
0
 @Test
 public void cartesianProduct() {
   MutableSet<Integer> set1 = UnifiedSet.newSetWith(1, 2);
   MutableSet<Integer> set2 = UnifiedSet.newSetWith(2, 3, 4);
   MutableBag<Pair<Integer, Integer>> expectedCartesianProduct =
       Bags.mutable.of(
           Tuples.pair(1, 2),
           Tuples.pair(2, 2),
           Tuples.pair(1, 3),
           Tuples.pair(2, 3),
           Tuples.pair(1, 4),
           Tuples.pair(2, 4));
   Assert.assertEquals(expectedCartesianProduct, Sets.cartesianProduct(set1, set2).toBag());
 }
예제 #6
0
 @Test
 public void properSubsetEmpty() {
   MutableSet<String> emptySet = mSet();
   MutableSet<String> singletonSet = UnifiedSet.newSetWith("Bertha");
   Assert.assertTrue(Sets.isProperSubsetOf(emptySet, singletonSet));
   Assert.assertFalse(Sets.isProperSubsetOf(singletonSet, emptySet));
 }
예제 #7
0
 @Test
 public void intersectAllIdentical() {
   MutableSet<String> names =
       Sets.intersectAll(
           this.identicalSets.get(0), this.identicalSets.get(1), this.identicalSets.get(2));
   Assert.assertEquals(UnifiedSet.newSetWith("Tom", "Dick", "Harry", null), names);
 }
예제 #8
0
 @Test
 public void intersectAllOverlapping() {
   MutableSet<String> names =
       Sets.intersectAll(
           this.overlappingSets.get(0), this.overlappingSets.get(1), this.overlappingSets.get(2));
   Assert.assertEquals(UnifiedSet.newSetWith("Dick"), names);
 }
  @Test
  public void newListWithCollection() {
    Verify.assertEmpty(MultiReaderFastList.newList(Lists.fixedSize.of()));
    Verify.assertEmpty(MultiReaderFastList.newList(Sets.fixedSize.of()));
    Verify.assertEmpty(MultiReaderFastList.newList(FastList.newList()));
    Verify.assertEmpty(MultiReaderFastList.newList(FastList.newList(4)));

    MutableList<Integer> setToList =
        MultiReaderFastList.newList(UnifiedSet.newSetWith(1, 2, 3, 4, 5));
    Verify.assertNotEmpty(setToList);
    Verify.assertSize(5, setToList);
    Verify.assertContainsAll(setToList, 1, 2, 3, 4, 5);

    MutableList<Integer> arrayListToList =
        MultiReaderFastList.newList(Lists.fixedSize.of(1, 2, 3, 4, 5));
    Verify.assertNotEmpty(arrayListToList);
    Verify.assertSize(5, arrayListToList);
    Verify.assertStartsWith(arrayListToList, 1, 2, 3, 4, 5);

    MutableList<Integer> fastListToList =
        MultiReaderFastList.newList(FastList.<Integer>newList().with(1, 2, 3, 4, 5));
    Verify.assertNotEmpty(fastListToList);
    Verify.assertSize(5, fastListToList);
    Verify.assertStartsWith(fastListToList, 1, 2, 3, 4, 5);
  }
예제 #10
0
 @Test
 public void unionAllOverlapping() {
   MutableSet<String> names =
       Sets.unionAll(
           this.overlappingSets.get(0), this.overlappingSets.get(1), this.overlappingSets.get(2));
   Assert.assertEquals(
       UnifiedSet.newSetWith("Tom", "Dick", "Harry", "Larry", "Paul", null), names);
 }
예제 #11
0
 @Test
 public void unionAllUnique() {
   MutableSet<String> names =
       Sets.unionAll(this.uniqueSets.get(0), this.uniqueSets.get(1), this.uniqueSets.get(2));
   Assert.assertEquals(
       UnifiedSet.newSetWith(
           "Tom", "Dick", "Harry", "Jane", "Sarah", "Mary", "Fido", "Spike", "Spuds", null),
       names);
 }
예제 #12
0
 @Test
 public void powerSet() {
   MutableSet<Integer> set = UnifiedSet.newSetWith(1, 2, 3);
   MutableSet<MutableSet<Integer>> expectedPowerSet =
       UnifiedSet.<MutableSet<Integer>>newSetWith(
           UnifiedSet.<Integer>newSet(),
           UnifiedSet.newSetWith(1),
           UnifiedSet.newSetWith(2),
           UnifiedSet.newSetWith(3),
           UnifiedSet.newSetWith(1, 2),
           UnifiedSet.newSetWith(1, 3),
           UnifiedSet.newSetWith(2, 3),
           UnifiedSet.newSetWith(1, 2, 3));
   Assert.assertEquals(expectedPowerSet, Sets.powerSet(set));
 }
예제 #13
0
 @Test
 public void copySet() {
   Verify.assertInstanceOf(ImmutableSet.class, Sets.immutable.ofAll(Sets.fixedSize.of()));
   MutableSet<Integer> set = Sets.fixedSize.of(1);
   ImmutableSet<Integer> immutableSet = set.toImmutable();
   Verify.assertInstanceOf(ImmutableSet.class, Sets.immutable.ofAll(set));
   Verify.assertInstanceOf(
       ImmutableSet.class, Sets.immutable.ofAll(UnifiedSet.newSetWith(1, 2, 3, 4, 5)));
   Assert.assertSame(Sets.immutable.ofAll(immutableSet.castToSet()), immutableSet);
 }
예제 #14
0
 @Test
 public void differenceAllUnique() {
   MutableSet<String> names =
       Sets.differenceAll(this.uniqueSets.get(0), this.uniqueSets.get(1), this.uniqueSets.get(2));
   Assert.assertEquals(UnifiedSet.newSetWith("Harry", "Tom", "Dick", null), names);
   Verify.assertSetsEqual(
       names,
       Sets.difference(
           Sets.difference(this.uniqueSets.get(0), this.uniqueSets.get(1)),
           this.uniqueSets.get(2)));
 }
예제 #15
0
 @Test
 public void differenceAllOverlapping() {
   MutableSet<String> names =
       Sets.differenceAll(
           this.overlappingSets.get(0), this.overlappingSets.get(1), this.overlappingSets.get(2));
   Assert.assertEquals(UnifiedSet.newSetWith("Harry"), names);
   Verify.assertSetsEqual(
       names,
       Sets.difference(
           Sets.difference(this.overlappingSets.get(0), this.overlappingSets.get(1)),
           this.overlappingSets.get(2)));
 }
예제 #16
0
 @Test
 public void differenceAllIdentical() {
   MutableSet<String> names =
       Sets.differenceAll(
           this.identicalSets.get(0), this.identicalSets.get(1), this.identicalSets.get(2));
   Assert.assertEquals(UnifiedSet.newSetWith(), names);
   Verify.assertSetsEqual(
       names,
       Sets.difference(
           Sets.difference(this.identicalSets.get(0), this.identicalSets.get(1)),
           this.identicalSets.get(2)));
 }
예제 #17
0
 @Test
 public void mutables() {
   MutableSetFactory setFactory = Sets.mutable;
   Assert.assertEquals(UnifiedSet.newSet(), setFactory.of());
   Verify.assertInstanceOf(MutableSet.class, setFactory.of());
   Assert.assertEquals(UnifiedSet.newSetWith(1), setFactory.of(1));
   Verify.assertInstanceOf(MutableSet.class, setFactory.of(1));
   Assert.assertEquals(UnifiedSet.newSetWith(1, 2), setFactory.of(1, 2));
   Verify.assertInstanceOf(MutableSet.class, setFactory.of(1, 2));
   Assert.assertEquals(UnifiedSet.newSetWith(1, 2, 3), setFactory.of(1, 2, 3));
   Verify.assertInstanceOf(MutableSet.class, setFactory.of(1, 2, 3));
   Assert.assertEquals(UnifiedSet.newSetWith(1, 2, 3, 4), setFactory.of(1, 2, 3, 4));
   Verify.assertInstanceOf(MutableSet.class, setFactory.of(1, 2, 3, 4));
   Assert.assertEquals(UnifiedSet.newSetWith(1, 2, 3, 4, 5), setFactory.of(1, 2, 3, 4, 5));
   Verify.assertInstanceOf(MutableSet.class, setFactory.of(1, 2, 3, 4, 5));
   Assert.assertEquals(
       UnifiedSet.newSetWith(1, 2, 3, 4, 5),
       setFactory.ofAll(UnifiedSet.newSetWith(1, 2, 3, 4, 5)));
   Verify.assertInstanceOf(
       MutableSet.class, setFactory.ofAll(UnifiedSet.newSetWith(1, 2, 3, 4, 5)));
 }
예제 #18
0
 @Test
 public void cartesianProduct_empty() {
   Assert.assertEquals(
       Bags.mutable.of(),
       HashBag.newBag(Sets.cartesianProduct(UnifiedSet.newSetWith(1, 2), UnifiedSet.newSet())));
 }
예제 #19
0
 private <E> TreeSet<E> newSortedSet(E... elements) {
   return new TreeSet<>(UnifiedSet.newSetWith(elements));
 }
예제 #20
0
 @Test
 public void powerSet_empty() {
   Assert.assertEquals(
       UnifiedSet.newSetWith(UnifiedSet.newSet()), Sets.powerSet(UnifiedSet.newSet()));
 }
예제 #21
0
 private <E> TreeSet<E> newReverseSortedSet(E... elements) {
   TreeSet<E> set = new TreeSet<>(Collections.reverseOrder());
   set.addAll(UnifiedSet.newSetWith(elements));
   return set;
 }
예제 #22
0
 @Test
 public void intersectAllUnique() {
   MutableSet<String> names =
       Sets.intersectAll(this.uniqueSets.get(0), this.uniqueSets.get(1), this.uniqueSets.get(2));
   Assert.assertEquals(UnifiedSet.newSetWith(), names);
 }
예제 #23
0
 private <E> Procedure2<Set<E>, E[]> containsExactlyProcedure() {
   return (set, elements) -> Assert.assertEquals(UnifiedSet.newSetWith(elements), set);
 }
예제 #24
0
 private <E> UnifiedSet<E> newUnsortedSet(E... elements) {
   return UnifiedSet.newSetWith(elements);
 }
 @SafeVarargs
 @Override
 protected final <V> UnifiedSet<V> createCollection(V... args) {
   return UnifiedSet.newSetWith(args);
 }