383 lines
15 KiB
Java
383 lines
15 KiB
Java
/*
|
|
* Copyright (C) 2008 The Guava Authors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.google.common.collect;
|
|
|
|
import static com.google.common.base.Preconditions.checkArgument;
|
|
import static java.util.Arrays.asList;
|
|
|
|
import com.google.common.annotations.GwtCompatible;
|
|
import com.google.common.annotations.GwtIncompatible;
|
|
import com.google.common.collect.testing.SetTestSuiteBuilder;
|
|
import com.google.common.collect.testing.TestStringSetGenerator;
|
|
import com.google.common.collect.testing.features.CollectionFeature;
|
|
import com.google.common.collect.testing.features.CollectionSize;
|
|
import java.util.HashSet;
|
|
import java.util.Set;
|
|
import junit.framework.Test;
|
|
import junit.framework.TestCase;
|
|
import junit.framework.TestSuite;
|
|
|
|
/**
|
|
* Unit tests for {@link Sets#union}, {@link Sets#intersection} and {@link Sets#difference}.
|
|
*
|
|
* @author Kevin Bourrillion
|
|
*/
|
|
@GwtCompatible(emulated = true)
|
|
public class SetOperationsTest extends TestCase {
|
|
@GwtIncompatible // suite
|
|
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"));
|
|
}
|
|
})
|
|
.named("set - disjoint")
|
|
.withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_VALUES)
|
|
.createTestSuite());
|
|
|
|
suite.addTestSuite(MoreTests.class);
|
|
return suite;
|
|
}
|
|
|
|
public static class MoreTests extends TestCase {
|
|
Set<String> friends;
|
|
Set<String> enemies;
|
|
|
|
@Override
|
|
public void setUp() {
|
|
friends = Sets.newHashSet("Tom", "Joe", "Dave");
|
|
enemies = Sets.newHashSet("Dick", "Harry", "Tom");
|
|
}
|
|
|
|
public void testUnion() {
|
|
Set<String> all = Sets.union(friends, enemies);
|
|
assertEquals(5, all.size());
|
|
|
|
ImmutableSet<String> immut = Sets.union(friends, enemies).immutableCopy();
|
|
HashSet<String> mut = Sets.union(friends, enemies).copyInto(new HashSet<String>());
|
|
|
|
enemies.add("Buck");
|
|
assertEquals(6, all.size());
|
|
assertEquals(5, immut.size());
|
|
assertEquals(5, mut.size());
|
|
}
|
|
|
|
public void testIntersection() {
|
|
Set<String> friends = Sets.newHashSet("Tom", "Joe", "Dave");
|
|
Set<String> enemies = Sets.newHashSet("Dick", "Harry", "Tom");
|
|
|
|
Set<String> frenemies = Sets.intersection(friends, enemies);
|
|
assertEquals(1, frenemies.size());
|
|
|
|
ImmutableSet<String> immut = Sets.intersection(friends, enemies).immutableCopy();
|
|
HashSet<String> mut = Sets.intersection(friends, enemies).copyInto(new HashSet<String>());
|
|
|
|
enemies.add("Joe");
|
|
assertEquals(2, frenemies.size());
|
|
assertEquals(1, immut.size());
|
|
assertEquals(1, mut.size());
|
|
}
|
|
|
|
public void testDifference() {
|
|
Set<String> friends = Sets.newHashSet("Tom", "Joe", "Dave");
|
|
Set<String> enemies = Sets.newHashSet("Dick", "Harry", "Tom");
|
|
|
|
Set<String> goodFriends = Sets.difference(friends, enemies);
|
|
assertEquals(2, goodFriends.size());
|
|
|
|
ImmutableSet<String> immut = Sets.difference(friends, enemies).immutableCopy();
|
|
HashSet<String> mut = Sets.difference(friends, enemies).copyInto(new HashSet<String>());
|
|
|
|
enemies.add("Dave");
|
|
assertEquals(1, goodFriends.size());
|
|
assertEquals(2, immut.size());
|
|
assertEquals(2, mut.size());
|
|
}
|
|
|
|
public void testSymmetricDifference() {
|
|
Set<String> friends = Sets.newHashSet("Tom", "Joe", "Dave");
|
|
Set<String> enemies = Sets.newHashSet("Dick", "Harry", "Tom");
|
|
|
|
Set<String> symmetricDifferenceFriendsFirst = Sets.symmetricDifference(friends, enemies);
|
|
assertEquals(4, symmetricDifferenceFriendsFirst.size());
|
|
|
|
Set<String> symmetricDifferenceEnemiesFirst = Sets.symmetricDifference(enemies, friends);
|
|
assertEquals(4, symmetricDifferenceEnemiesFirst.size());
|
|
|
|
assertEquals(symmetricDifferenceFriendsFirst, symmetricDifferenceEnemiesFirst);
|
|
|
|
ImmutableSet<String> immut = Sets.symmetricDifference(friends, enemies).immutableCopy();
|
|
HashSet<String> mut =
|
|
Sets.symmetricDifference(friends, enemies).copyInto(new HashSet<String>());
|
|
|
|
enemies.add("Dave");
|
|
assertEquals(3, symmetricDifferenceFriendsFirst.size());
|
|
assertEquals(4, immut.size());
|
|
assertEquals(4, mut.size());
|
|
|
|
immut = Sets.symmetricDifference(enemies, friends).immutableCopy();
|
|
mut = Sets.symmetricDifference(enemies, friends).copyInto(new HashSet<String>());
|
|
friends.add("Harry");
|
|
assertEquals(2, symmetricDifferenceEnemiesFirst.size());
|
|
assertEquals(3, immut.size());
|
|
assertEquals(3, mut.size());
|
|
}
|
|
}
|
|
}
|