1/* 2 * Copyright (C) 2011 The Guava Authors 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except 5 * in compliance with the License. You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software distributed under the License 10 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express 11 * or implied. See the License for the specific language governing permissions and limitations under 12 * the License. 13 */ 14 15package com.google.common.collect; 16 17import static java.util.Arrays.asList; 18import static org.junit.contrib.truth.Truth.ASSERT; 19 20import com.google.common.base.Function; 21import com.google.common.collect.testing.MinimalCollection; 22import com.google.common.collect.testing.SetTestSuiteBuilder; 23import com.google.common.collect.testing.TestStringSetGenerator; 24import com.google.common.collect.testing.features.CollectionFeature; 25import com.google.common.collect.testing.features.CollectionSize; 26import com.google.common.collect.testing.google.SortedMultisetTestSuiteBuilder; 27import com.google.common.collect.testing.google.TestStringMultisetGenerator; 28import com.google.common.collect.testing.google.UnmodifiableCollectionTests; 29import com.google.common.testing.NullPointerTester; 30import com.google.common.testing.SerializableTester; 31 32import junit.framework.Test; 33import junit.framework.TestCase; 34import junit.framework.TestSuite; 35 36import java.util.Arrays; 37import java.util.Collection; 38import java.util.Collections; 39import java.util.Comparator; 40import java.util.Iterator; 41import java.util.List; 42import java.util.Set; 43 44/** 45 * Tests for {@link ImmutableSortedMultiset}. 46 * 47 * @author Louis Wasserman 48 */ 49public class ImmutableSortedMultisetTest extends TestCase { 50 public static Test suite() { 51 TestSuite suite = new TestSuite(); 52 suite.addTestSuite(ImmutableSortedMultisetTest.class); 53 54 suite.addTest(SortedMultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() { 55 @Override 56 protected Multiset<String> create(String[] elements) { 57 return ImmutableSortedMultiset.copyOf(elements); 58 } 59 60 @Override 61 public List<String> order(List<String> insertionOrder) { 62 return Ordering.natural().sortedCopy(insertionOrder); 63 } 64 }).named("ImmutableSortedMultiset").withFeatures(CollectionSize.ANY, 65 CollectionFeature.ALLOWS_NULL_QUERIES) 66 .createTestSuite()); 67 68 suite.addTest(SortedMultisetTestSuiteBuilder.using(new TestStringMultisetGenerator() { 69 @Override 70 protected Multiset<String> create(String[] elements) { 71 return SerializableTester.reserialize(ImmutableSortedMultiset.copyOf(elements)); 72 } 73 74 @Override 75 public List<String> order(List<String> insertionOrder) { 76 return Ordering.natural().sortedCopy(insertionOrder); 77 } 78 }).named("ImmutableSortedMultiset, reserialized").withFeatures(CollectionSize.ANY, 79 CollectionFeature.ALLOWS_NULL_QUERIES) 80 .createTestSuite()); 81 82 suite.addTest(SetTestSuiteBuilder 83 .using(new TestStringSetGenerator() { 84 @Override 85 protected Set<String> create(String[] elements) { 86 return SerializableTester.reserialize(ImmutableSortedMultiset.copyOf(elements) 87 .elementSet()); 88 } 89 90 @Override 91 public List<String> order(List<String> insertionOrder) { 92 return Ordering.natural().immutableSortedCopy(insertionOrder); 93 } 94 }).named("ImmutableSortedMultiset, element set").withFeatures(CollectionSize.ANY, 95 CollectionFeature.ALLOWS_NULL_QUERIES) 96 .createTestSuite()); 97 98 return suite; 99 } 100 101 public void testCreation_noArgs() { 102 Multiset<String> multiset = ImmutableSortedMultiset.of(); 103 assertTrue(multiset.isEmpty()); 104 } 105 106 public void testCreation_oneElement() { 107 Multiset<String> multiset = ImmutableSortedMultiset.of("a"); 108 assertEquals(HashMultiset.create(asList("a")), multiset); 109 } 110 111 public void testCreation_twoElements() { 112 Multiset<String> multiset = ImmutableSortedMultiset.of("a", "b"); 113 assertEquals(HashMultiset.create(asList("a", "b")), multiset); 114 } 115 116 public void testCreation_threeElements() { 117 Multiset<String> multiset = ImmutableSortedMultiset.of("a", "b", "c"); 118 assertEquals(HashMultiset.create(asList("a", "b", "c")), multiset); 119 } 120 121 public void testCreation_fourElements() { 122 Multiset<String> multiset = ImmutableSortedMultiset.of("a", "b", "c", "d"); 123 assertEquals(HashMultiset.create(asList("a", "b", "c", "d")), multiset); 124 } 125 126 public void testCreation_fiveElements() { 127 Multiset<String> multiset = ImmutableSortedMultiset.of("a", "b", "c", "d", "e"); 128 assertEquals(HashMultiset.create(asList("a", "b", "c", "d", "e")), multiset); 129 } 130 131 public void testCreation_sixElements() { 132 Multiset<String> multiset = ImmutableSortedMultiset.of("a", "b", "c", "d", "e", "f"); 133 assertEquals(HashMultiset.create(asList("a", "b", "c", "d", "e", "f")), multiset); 134 } 135 136 public void testCreation_sevenElements() { 137 Multiset<String> multiset = ImmutableSortedMultiset.of("a", "b", "c", "d", "e", "f", "g"); 138 assertEquals(HashMultiset.create(asList("a", "b", "c", "d", "e", "f", "g")), multiset); 139 } 140 141 public void testCreation_emptyArray() { 142 String[] array = new String[0]; 143 Multiset<String> multiset = ImmutableSortedMultiset.copyOf(array); 144 assertTrue(multiset.isEmpty()); 145 } 146 147 public void testCreation_arrayOfOneElement() { 148 String[] array = new String[] {"a"}; 149 Multiset<String> multiset = ImmutableSortedMultiset.copyOf(array); 150 assertEquals(HashMultiset.create(asList("a")), multiset); 151 } 152 153 public void testCreation_arrayOfArray() { 154 Comparator<String[]> comparator = 155 Ordering.natural().lexicographical() 156 .onResultOf(new Function<String[], Iterable<Comparable>>() { 157 @Override 158 public Iterable<Comparable> apply(String[] input) { 159 return Arrays.<Comparable>asList(input); 160 } 161 }); 162 String[] array = new String[] {"a"}; 163 Multiset<String[]> multiset = ImmutableSortedMultiset.orderedBy(comparator).add(array).build(); 164 Multiset<String[]> expected = HashMultiset.create(); 165 expected.add(array); 166 assertEquals(expected, multiset); 167 } 168 169 public void testCreation_arrayContainingOnlyNull() { 170 String[] array = new String[] {null}; 171 try { 172 ImmutableSortedMultiset.copyOf(array); 173 fail(); 174 } catch (NullPointerException expected) {} 175 } 176 177 public void testCopyOf_collection_empty() { 178 // "<String>" is required to work around a javac 1.5 bug. 179 Collection<String> c = MinimalCollection.<String>of(); 180 Multiset<String> multiset = ImmutableSortedMultiset.copyOf(c); 181 assertTrue(multiset.isEmpty()); 182 } 183 184 public void testCopyOf_collection_oneElement() { 185 Collection<String> c = MinimalCollection.of("a"); 186 Multiset<String> multiset = ImmutableSortedMultiset.copyOf(c); 187 assertEquals(HashMultiset.create(asList("a")), multiset); 188 } 189 190 public void testCopyOf_collection_general() { 191 Collection<String> c = MinimalCollection.of("a", "b", "a"); 192 Multiset<String> multiset = ImmutableSortedMultiset.copyOf(c); 193 assertEquals(HashMultiset.create(asList("a", "b", "a")), multiset); 194 } 195 196 public void testCopyOf_collectionContainingNull() { 197 Collection<String> c = MinimalCollection.of("a", null, "b"); 198 try { 199 ImmutableSortedMultiset.copyOf(c); 200 fail(); 201 } catch (NullPointerException expected) {} 202 } 203 204 public void testCopyOf_multiset_empty() { 205 Multiset<String> c = HashMultiset.create(); 206 Multiset<String> multiset = ImmutableSortedMultiset.copyOf(c); 207 assertTrue(multiset.isEmpty()); 208 } 209 210 public void testCopyOf_multiset_oneElement() { 211 Multiset<String> c = HashMultiset.create(asList("a")); 212 Multiset<String> multiset = ImmutableSortedMultiset.copyOf(c); 213 assertEquals(HashMultiset.create(asList("a")), multiset); 214 } 215 216 public void testCopyOf_multiset_general() { 217 Multiset<String> c = HashMultiset.create(asList("a", "b", "a")); 218 Multiset<String> multiset = ImmutableSortedMultiset.copyOf(c); 219 assertEquals(HashMultiset.create(asList("a", "b", "a")), multiset); 220 } 221 222 public void testCopyOf_multisetContainingNull() { 223 Multiset<String> c = HashMultiset.create(asList("a", null, "b")); 224 try { 225 ImmutableSortedMultiset.copyOf(c); 226 fail(); 227 } catch (NullPointerException expected) {} 228 } 229 230 public void testCopyOf_iterator_empty() { 231 Iterator<String> iterator = Iterators.emptyIterator(); 232 Multiset<String> multiset = ImmutableSortedMultiset.copyOf(iterator); 233 assertTrue(multiset.isEmpty()); 234 } 235 236 public void testCopyOf_iterator_oneElement() { 237 Iterator<String> iterator = Iterators.singletonIterator("a"); 238 Multiset<String> multiset = ImmutableSortedMultiset.copyOf(iterator); 239 assertEquals(HashMultiset.create(asList("a")), multiset); 240 } 241 242 public void testCopyOf_iterator_general() { 243 Iterator<String> iterator = asList("a", "b", "a").iterator(); 244 Multiset<String> multiset = ImmutableSortedMultiset.copyOf(iterator); 245 assertEquals(HashMultiset.create(asList("a", "b", "a")), multiset); 246 } 247 248 public void testCopyOf_iteratorContainingNull() { 249 Iterator<String> iterator = asList("a", null, "b").iterator(); 250 try { 251 ImmutableSortedMultiset.copyOf(iterator); 252 fail(); 253 } catch (NullPointerException expected) {} 254 } 255 256 private static class CountingIterable implements Iterable<String> { 257 int count = 0; 258 259 @Override 260 public Iterator<String> iterator() { 261 count++; 262 return asList("a", "b", "a").iterator(); 263 } 264 } 265 266 public void testCopyOf_plainIterable() { 267 CountingIterable iterable = new CountingIterable(); 268 Multiset<String> multiset = ImmutableSortedMultiset.copyOf(iterable); 269 assertEquals(HashMultiset.create(asList("a", "b", "a")), multiset); 270 assertEquals(1, iterable.count); 271 } 272 273 public void testCopyOf_shortcut_empty() { 274 Collection<String> c = ImmutableSortedMultiset.of(); 275 assertSame(c, ImmutableSortedMultiset.copyOf(c)); 276 } 277 278 public void testCopyOf_shortcut_singleton() { 279 Collection<String> c = ImmutableSortedMultiset.of("a"); 280 assertSame(c, ImmutableSortedMultiset.copyOf(c)); 281 } 282 283 public void testCopyOf_shortcut_immutableMultiset() { 284 Collection<String> c = ImmutableSortedMultiset.of("a", "b", "c"); 285 assertSame(c, ImmutableSortedMultiset.copyOf(c)); 286 } 287 288 public void testBuilderAdd() { 289 ImmutableSortedMultiset<String> multiset = 290 ImmutableSortedMultiset.<String>naturalOrder().add("a").add("b").add("a").add("c").build(); 291 assertEquals(HashMultiset.create(asList("a", "b", "a", "c")), multiset); 292 } 293 294 public void testBuilderAddAll() { 295 List<String> a = asList("a", "b"); 296 List<String> b = asList("c", "d"); 297 ImmutableSortedMultiset<String> multiset = 298 ImmutableSortedMultiset.<String>naturalOrder().addAll(a).addAll(b).build(); 299 assertEquals(HashMultiset.create(asList("a", "b", "c", "d")), multiset); 300 } 301 302 public void testBuilderAddAllMultiset() { 303 Multiset<String> a = HashMultiset.create(asList("a", "b", "b")); 304 Multiset<String> b = HashMultiset.create(asList("c", "b")); 305 ImmutableSortedMultiset<String> multiset = 306 ImmutableSortedMultiset.<String>naturalOrder().addAll(a).addAll(b).build(); 307 assertEquals(HashMultiset.create(asList("a", "b", "b", "b", "c")), multiset); 308 } 309 310 public void testBuilderAddAllIterator() { 311 Iterator<String> iterator = asList("a", "b", "a", "c").iterator(); 312 ImmutableSortedMultiset<String> multiset = 313 ImmutableSortedMultiset.<String>naturalOrder().addAll(iterator).build(); 314 assertEquals(HashMultiset.create(asList("a", "b", "a", "c")), multiset); 315 } 316 317 public void testBuilderAddCopies() { 318 ImmutableSortedMultiset<String> multiset = 319 ImmutableSortedMultiset.<String>naturalOrder().addCopies("a", 2).addCopies("b", 3) 320 .addCopies("c", 0).build(); 321 assertEquals(HashMultiset.create(asList("a", "a", "b", "b", "b")), multiset); 322 } 323 324 public void testBuilderSetCount() { 325 ImmutableSortedMultiset<String> multiset = 326 ImmutableSortedMultiset.<String>naturalOrder().add("a").setCount("a", 2).setCount("b", 3) 327 .build(); 328 assertEquals(HashMultiset.create(asList("a", "a", "b", "b", "b")), multiset); 329 } 330 331 public void testBuilderAddHandlesNullsCorrectly() { 332 ImmutableSortedMultiset.Builder<String> builder = ImmutableSortedMultiset.naturalOrder(); 333 try { 334 builder.add((String) null); 335 fail("expected NullPointerException"); 336 } catch (NullPointerException expected) {} 337 } 338 339 public void testBuilderAddAllHandlesNullsCorrectly() { 340 ImmutableSortedMultiset.Builder<String> builder = ImmutableSortedMultiset.naturalOrder(); 341 try { 342 builder.addAll((Collection<String>) null); 343 fail("expected NullPointerException"); 344 } catch (NullPointerException expected) {} 345 346 builder = ImmutableSortedMultiset.naturalOrder(); 347 List<String> listWithNulls = asList("a", null, "b"); 348 try { 349 builder.addAll(listWithNulls); 350 fail("expected NullPointerException"); 351 } catch (NullPointerException expected) {} 352 353 builder = ImmutableSortedMultiset.naturalOrder(); 354 Multiset<String> multisetWithNull = LinkedHashMultiset.create(asList("a", null, "b")); 355 try { 356 builder.addAll(multisetWithNull); 357 fail("expected NullPointerException"); 358 } catch (NullPointerException expected) {} 359 } 360 361 public void testBuilderAddCopiesHandlesNullsCorrectly() { 362 ImmutableSortedMultiset.Builder<String> builder = ImmutableSortedMultiset.naturalOrder(); 363 try { 364 builder.addCopies(null, 2); 365 fail("expected NullPointerException"); 366 } catch (NullPointerException expected) {} 367 } 368 369 public void testBuilderAddCopiesIllegal() { 370 ImmutableSortedMultiset.Builder<String> builder = ImmutableSortedMultiset.naturalOrder(); 371 try { 372 builder.addCopies("a", -2); 373 fail("expected IllegalArgumentException"); 374 } catch (IllegalArgumentException expected) {} 375 } 376 377 public void testBuilderSetCountHandlesNullsCorrectly() { 378 ImmutableSortedMultiset.Builder<String> builder = 379 new ImmutableSortedMultiset.Builder<String>(Ordering.natural().nullsFirst()); 380 try { 381 builder.setCount(null, 2); 382 fail("expected NullPointerException"); 383 } catch (NullPointerException expected) {} 384 } 385 386 public void testBuilderSetCountIllegal() { 387 ImmutableSortedMultiset.Builder<String> builder = ImmutableSortedMultiset.naturalOrder(); 388 try { 389 builder.setCount("a", -2); 390 fail("expected IllegalArgumentException"); 391 } catch (IllegalArgumentException expected) {} 392 } 393 394 public void testNullPointers() throws Exception { 395 NullPointerTester tester = new NullPointerTester(); 396 tester.setDefault(Comparator.class, Ordering.natural()); 397 tester.setDefault(Comparable.class, ""); 398 tester.setDefault(Iterator.class, Iterators.emptyIterator()); 399 tester.setDefault(Iterable.class, Collections.emptySet()); 400 tester.setDefault(Comparable[].class, new Comparable[0]); 401 tester.testAllPublicStaticMethods(ImmutableSortedMultiset.class); 402 } 403 404 public void testSerialization_empty() { 405 Collection<String> c = ImmutableSortedMultiset.of(); 406 assertSame(c, SerializableTester.reserialize(c)); 407 } 408 409 public void testSerialization_multiple() { 410 Collection<String> c = ImmutableSortedMultiset.of("a", "b", "a"); 411 Collection<String> copy = SerializableTester.reserializeAndAssert(c); 412 ASSERT.that(copy).hasContentsInOrder("a", "a", "b"); 413 } 414 415 public void testSerialization_elementSet() { 416 Multiset<String> c = ImmutableSortedMultiset.of("a", "b", "a"); 417 Collection<String> copy = SerializableTester.reserializeAndAssert(c.elementSet()); 418 ASSERT.that(copy).hasContentsInOrder("a", "b"); 419 } 420 421 public void testSerialization_entrySet() { 422 Multiset<String> c = ImmutableSortedMultiset.of("a", "b", "c"); 423 SerializableTester.reserializeAndAssert(c.entrySet()); 424 } 425 426 public void testEquals_immutableMultiset() { 427 Collection<String> c = ImmutableSortedMultiset.of("a", "b", "a"); 428 assertEquals(c, ImmutableSortedMultiset.of("a", "b", "a")); 429 assertEquals(c, ImmutableSortedMultiset.of("a", "a", "b")); 430 ASSERT.that(c).isNotEqualTo(ImmutableSortedMultiset.of("a", "b")); 431 ASSERT.that(c).isNotEqualTo(ImmutableSortedMultiset.of("a", "b", "c", "d")); 432 } 433 434 public void testIterationOrder() { 435 Collection<String> c = ImmutableSortedMultiset.of("a", "b", "a"); 436 ASSERT.that(c).hasContentsInOrder("a", "a", "b"); 437 } 438 439 public void testMultisetWrites() { 440 Multiset<String> multiset = ImmutableSortedMultiset.of("a", "b", "a"); 441 UnmodifiableCollectionTests.assertMultisetIsUnmodifiable(multiset, "test"); 442 } 443 444 public void testAsList() { 445 ImmutableSortedMultiset<String> multiset = ImmutableSortedMultiset.of("a", "a", "b", "b", "b"); 446 ImmutableList<String> list = multiset.asList(); 447 assertEquals(ImmutableList.of("a", "a", "b", "b", "b"), list); 448 assertTrue(list instanceof ImmutableAsList); 449 ImmutableList<String> copy = SerializableTester.reserializeAndAssert(list); 450 assertTrue(copy instanceof ImmutableAsList); 451 assertEquals(2, list.indexOf("b")); 452 assertEquals(4, list.lastIndexOf("b")); 453 } 454} 455