1 /* 2 * Copyright (C) 2008 The Guava Authors 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.google.common.collect; 18 19 import static com.google.common.base.Preconditions.checkArgument; 20 import static java.util.Arrays.asList; 21 22 import com.google.common.annotations.GwtCompatible; 23 import com.google.common.annotations.GwtIncompatible; 24 import com.google.common.collect.testing.SetTestSuiteBuilder; 25 import com.google.common.collect.testing.TestStringSetGenerator; 26 import com.google.common.collect.testing.features.CollectionFeature; 27 import com.google.common.collect.testing.features.CollectionSize; 28 29 import junit.framework.Test; 30 import junit.framework.TestCase; 31 import junit.framework.TestSuite; 32 33 import java.util.HashSet; 34 import java.util.Set; 35 36 /** 37 * Unit tests for {@link Sets#union}, {@link Sets#intersection} and 38 * {@link Sets#difference}. 39 * 40 * @author Kevin Bourrillion 41 */ 42 @GwtCompatible(emulated = true) 43 public class SetOperationsTest extends TestCase { 44 @GwtIncompatible("suite") 45 public static Test suite() { 46 TestSuite suite = new TestSuite(); 47 48 suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { 49 @Override protected Set<String> create(String[] elements) { 50 return Sets.union( 51 Sets.<String>newHashSet(), Sets.<String>newHashSet()); 52 } 53 }) 54 .named("empty U empty") 55 .withFeatures(CollectionSize.ZERO, CollectionFeature.NONE, 56 CollectionFeature.ALLOWS_NULL_VALUES) 57 .createTestSuite()); 58 59 suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { 60 @Override protected Set<String> create(String[] elements) { 61 checkArgument(elements.length == 1); 62 return Sets.union( 63 Sets.<String>newHashSet(elements), Sets.newHashSet(elements)); 64 } 65 }) 66 .named("singleton U itself") 67 .withFeatures(CollectionSize.ONE, CollectionFeature.ALLOWS_NULL_VALUES) 68 .createTestSuite()); 69 70 suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { 71 @Override protected Set<String> create(String[] elements) { 72 return Sets.union( 73 Sets.<String>newHashSet(), Sets.newHashSet(elements)); 74 } 75 }) 76 .named("empty U set") 77 .withFeatures(CollectionSize.ONE, CollectionSize.SEVERAL, 78 CollectionFeature.ALLOWS_NULL_VALUES) 79 .createTestSuite()); 80 81 suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { 82 @Override protected Set<String> create(String[] elements) { 83 return Sets.union( 84 Sets.newHashSet(elements), Sets.<String>newHashSet()); 85 } 86 }) 87 .named("set U empty") 88 .withFeatures(CollectionSize.ONE, CollectionSize.SEVERAL, 89 CollectionFeature.ALLOWS_NULL_VALUES) 90 .createTestSuite()); 91 92 suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { 93 @Override protected Set<String> create(String[] elements) { 94 checkArgument(elements.length == 3); 95 // Put the sets in different orders for the hell of it 96 return Sets.union( 97 Sets.newLinkedHashSet(asList(elements)), 98 Sets.newLinkedHashSet( 99 asList(elements[1], elements[0], elements[2]))); 100 } 101 }) 102 .named("set U itself") 103 .withFeatures(CollectionSize.SEVERAL, 104 CollectionFeature.ALLOWS_NULL_VALUES) 105 .createTestSuite()); 106 107 suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { 108 @Override protected Set<String> create(String[] elements) { 109 checkArgument(elements.length == 3); 110 return Sets.union( 111 Sets.newHashSet(elements[0]), 112 Sets.newHashSet(elements[1], elements[2])); 113 } 114 }) 115 .named("union of disjoint") 116 .withFeatures(CollectionSize.SEVERAL, 117 CollectionFeature.ALLOWS_NULL_VALUES) 118 .createTestSuite()); 119 120 suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { 121 @Override protected Set<String> create(String[] elements) { 122 return Sets.union( 123 Sets.<String>newHashSet(elements[0], elements[1]), 124 Sets.newHashSet(elements[1], elements[2])); 125 } 126 }) 127 .named("venn") 128 .withFeatures(CollectionSize.SEVERAL, 129 CollectionFeature.ALLOWS_NULL_VALUES) 130 .createTestSuite()); 131 132 suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { 133 @Override protected Set<String> create(String[] elements) { 134 return Sets.intersection( 135 Sets.<String>newHashSet(), Sets.<String>newHashSet()); 136 } 137 }) 138 .named("empty & empty") 139 .withFeatures(CollectionSize.ZERO, CollectionFeature.NONE, 140 CollectionFeature.ALLOWS_NULL_VALUES) 141 .createTestSuite()); 142 143 suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { 144 @Override protected Set<String> create(String[] elements) { 145 return Sets.intersection( 146 Sets.<String>newHashSet(), Sets.newHashSet((String) null)); 147 } 148 }) 149 .named("empty & singleton") 150 .withFeatures(CollectionSize.ZERO, CollectionFeature.NONE, 151 CollectionFeature.ALLOWS_NULL_VALUES) 152 .createTestSuite()); 153 154 suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { 155 @Override protected Set<String> create(String[] elements) { 156 return Sets.intersection( 157 Sets.newHashSet("a", "b"), Sets.newHashSet("c", "d")); 158 } 159 }) 160 .named("intersection of disjoint") 161 .withFeatures(CollectionSize.ZERO, CollectionFeature.NONE, 162 CollectionFeature.ALLOWS_NULL_VALUES) 163 .createTestSuite()); 164 165 suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { 166 @Override protected Set<String> create(String[] elements) { 167 return Sets.intersection( 168 Sets.newHashSet(elements), Sets.newHashSet(elements)); 169 } 170 }) 171 .named("set & itself") 172 .withFeatures(CollectionSize.ONE, CollectionSize.SEVERAL, 173 CollectionFeature.ALLOWS_NULL_VALUES) 174 .createTestSuite()); 175 176 suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { 177 @Override protected Set<String> create(String[] elements) { 178 return Sets.intersection( 179 Sets.newHashSet("a", elements[0], "b"), 180 Sets.newHashSet("c", elements[0], "d")); 181 } 182 }) 183 .named("intersection with overlap of one") 184 .withFeatures(CollectionSize.ONE, CollectionFeature.ALLOWS_NULL_VALUES) 185 .createTestSuite()); 186 187 suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { 188 @Override protected Set<String> create(String[] elements) { 189 return Sets.difference( 190 Sets.<String>newHashSet(), Sets.<String>newHashSet()); 191 } 192 }) 193 .named("empty - empty") 194 .withFeatures(CollectionSize.ZERO, CollectionFeature.NONE, 195 CollectionFeature.ALLOWS_NULL_VALUES) 196 .createTestSuite()); 197 198 suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { 199 @Override protected Set<String> create(String[] elements) { 200 return Sets.difference(Sets.newHashSet("a"), Sets.newHashSet("a")); 201 } 202 }) 203 .named("singleton - itself") 204 .withFeatures(CollectionSize.ZERO, CollectionFeature.NONE, 205 CollectionFeature.ALLOWS_NULL_VALUES) 206 .createTestSuite()); 207 208 suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { 209 @Override protected Set<String> create(String[] elements) { 210 Set<String> set = Sets.newHashSet("b", "c"); 211 Set<String> other = Sets.newHashSet("a", "b", "c", "d"); 212 return Sets.difference(set, other); 213 } 214 }) 215 .named("set - superset") 216 .withFeatures(CollectionSize.ZERO, CollectionFeature.NONE, 217 CollectionFeature.ALLOWS_NULL_VALUES) 218 .createTestSuite()); 219 220 suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { 221 @Override protected Set<String> create(String[] elements) { 222 Set<String> set = Sets.newHashSet(elements); 223 Set<String> other = Sets.newHashSet("wz", "xq"); 224 set.addAll(other); 225 other.add("pq"); 226 return Sets.difference(set, other); 227 } 228 }) 229 .named("set - set") 230 .withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_VALUES, 231 CollectionFeature.ALLOWS_NULL_VALUES) 232 .createTestSuite()); 233 234 suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { 235 @Override protected Set<String> create(String[] elements) { 236 return Sets.difference( 237 Sets.newHashSet(elements), Sets.newHashSet()); 238 } 239 }) 240 .named("set - empty") 241 .withFeatures(CollectionSize.ONE, CollectionSize.SEVERAL, 242 CollectionFeature.ALLOWS_NULL_VALUES) 243 .createTestSuite()); 244 245 suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { 246 @Override protected Set<String> create(String[] elements) { 247 return Sets.difference( 248 Sets.<String>newHashSet(elements), Sets.newHashSet("xx", "xq")); 249 } 250 }) 251 .named("set - disjoint") 252 .withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_VALUES) 253 .createTestSuite()); 254 255 suite.addTestSuite(MoreTests.class); 256 return suite; 257 } 258 259 public static class MoreTests extends TestCase { 260 Set<String> friends; 261 Set<String> enemies; 262 263 @Override public void setUp() { 264 friends = Sets.newHashSet("Tom", "Joe", "Dave"); 265 enemies = Sets.newHashSet("Dick", "Harry", "Tom"); 266 } 267 268 public void testUnion() { 269 Set<String> all = Sets.union(friends, enemies); 270 assertEquals(5, all.size()); 271 272 ImmutableSet<String> immut = Sets.union(friends, enemies).immutableCopy(); 273 HashSet<String> mut 274 = Sets.union(friends, enemies).copyInto(new HashSet<String>()); 275 276 enemies.add("Buck"); 277 assertEquals(6, all.size()); 278 assertEquals(5, immut.size()); 279 assertEquals(5, mut.size()); 280 } 281 282 public void testIntersection() { 283 Set<String> friends = Sets.newHashSet("Tom", "Joe", "Dave"); 284 Set<String> enemies = Sets.newHashSet("Dick", "Harry", "Tom"); 285 286 Set<String> frenemies = Sets.intersection(friends, enemies); 287 assertEquals(1, frenemies.size()); 288 289 ImmutableSet<String> immut 290 = Sets.intersection(friends, enemies).immutableCopy(); 291 HashSet<String> mut 292 = Sets.intersection(friends, enemies).copyInto(new HashSet<String>()); 293 294 enemies.add("Joe"); 295 assertEquals(2, frenemies.size()); 296 assertEquals(1, immut.size()); 297 assertEquals(1, mut.size()); 298 } 299 300 public void testDifference() { 301 Set<String> friends = Sets.newHashSet("Tom", "Joe", "Dave"); 302 Set<String> enemies = Sets.newHashSet("Dick", "Harry", "Tom"); 303 304 Set<String> goodFriends = Sets.difference(friends, enemies); 305 assertEquals(2, goodFriends.size()); 306 307 ImmutableSet<String> immut 308 = Sets.difference(friends, enemies).immutableCopy(); 309 HashSet<String> mut 310 = Sets.difference(friends, enemies).copyInto(new HashSet<String>()); 311 312 enemies.add("Dave"); 313 assertEquals(1, goodFriends.size()); 314 assertEquals(2, immut.size()); 315 assertEquals(2, mut.size()); 316 } 317 318 public void testSymmetricDifference() { 319 Set<String> friends = Sets.newHashSet("Tom", "Joe", "Dave"); 320 Set<String> enemies = Sets.newHashSet("Dick", "Harry", "Tom"); 321 322 Set<String> symmetricDifferenceFriendsFirst = Sets.symmetricDifference( 323 friends, enemies); 324 assertEquals(4, symmetricDifferenceFriendsFirst.size()); 325 326 Set<String> symmetricDifferenceEnemiesFirst = Sets.symmetricDifference( 327 enemies, friends); 328 assertEquals(4, symmetricDifferenceEnemiesFirst.size()); 329 330 assertEquals(symmetricDifferenceFriendsFirst, 331 symmetricDifferenceEnemiesFirst); 332 333 ImmutableSet<String> immut 334 = Sets.symmetricDifference(friends, enemies).immutableCopy(); 335 HashSet<String> mut = Sets.symmetricDifference(friends, enemies) 336 .copyInto(new HashSet<String>()); 337 338 enemies.add("Dave"); 339 assertEquals(3, symmetricDifferenceFriendsFirst.size()); 340 assertEquals(4, immut.size()); 341 assertEquals(4, mut.size()); 342 343 immut = Sets.symmetricDifference(enemies, friends).immutableCopy(); 344 mut = Sets.symmetricDifference(enemies, friends). 345 copyInto(new HashSet<String>()); 346 friends.add("Harry"); 347 assertEquals(2, symmetricDifferenceEnemiesFirst.size()); 348 assertEquals(3, immut.size()); 349 assertEquals(3, mut.size()); 350 } 351 } 352 } 353
