1 /* 2 * Copyright (C) 2009 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.collect.testing.Helpers.mapEntry; 20 import static com.google.common.collect.testing.features.CollectionFeature.KNOWN_ORDER; 21 import static com.google.common.collect.testing.features.CollectionFeature.SERIALIZABLE; 22 import static com.google.common.collect.testing.features.MapFeature.ALLOWS_ANY_NULL_QUERIES; 23 import static com.google.common.truth.Truth.assertThat; 24 25 import com.google.common.annotations.GwtCompatible; 26 import com.google.common.annotations.GwtIncompatible; 27 import com.google.common.base.Equivalence; 28 import com.google.common.collect.ImmutableSetMultimap.Builder; 29 import com.google.common.collect.testing.features.CollectionSize; 30 import com.google.common.collect.testing.google.SetMultimapTestSuiteBuilder; 31 import com.google.common.collect.testing.google.TestStringSetMultimapGenerator; 32 import com.google.common.collect.testing.google.UnmodifiableCollectionTests; 33 import com.google.common.primitives.Chars; 34 import com.google.common.testing.CollectorTester; 35 import com.google.common.testing.EqualsTester; 36 import com.google.common.testing.NullPointerTester; 37 import com.google.common.testing.SerializableTester; 38 import java.util.Arrays; 39 import java.util.Collection; 40 import java.util.Collections; 41 import java.util.Map.Entry; 42 import java.util.function.BiPredicate; 43 import java.util.stream.Collector; 44 import junit.framework.Test; 45 import junit.framework.TestCase; 46 import junit.framework.TestSuite; 47 48 /** 49 * Tests for {@link ImmutableSetMultimap}. 50 * 51 * @author Mike Ward 52 */ 53 @GwtCompatible(emulated = true) 54 public class ImmutableSetMultimapTest extends TestCase { 55 private static final class ImmutableSetMultimapGenerator extends TestStringSetMultimapGenerator { 56 @Override create(Entry<String, String>[] entries)57 protected SetMultimap<String, String> create(Entry<String, String>[] entries) { 58 ImmutableSetMultimap.Builder<String, String> builder = ImmutableSetMultimap.builder(); 59 for (Entry<String, String> entry : entries) { 60 builder.put(entry.getKey(), entry.getValue()); 61 } 62 return builder.build(); 63 } 64 } 65 66 private static final class ImmutableSetMultimapCopyOfEntriesGenerator 67 extends TestStringSetMultimapGenerator { 68 @Override create(Entry<String, String>[] entries)69 protected SetMultimap<String, String> create(Entry<String, String>[] entries) { 70 return ImmutableSetMultimap.copyOf(Arrays.asList(entries)); 71 } 72 } 73 74 @GwtIncompatible // suite suite()75 public static Test suite() { 76 TestSuite suite = new TestSuite(); 77 suite.addTestSuite(ImmutableSetMultimapTest.class); 78 suite.addTest( 79 SetMultimapTestSuiteBuilder.using(new ImmutableSetMultimapGenerator()) 80 .named("ImmutableSetMultimap") 81 .withFeatures(ALLOWS_ANY_NULL_QUERIES, KNOWN_ORDER, SERIALIZABLE, CollectionSize.ANY) 82 .createTestSuite()); 83 suite.addTest( 84 SetMultimapTestSuiteBuilder.using(new ImmutableSetMultimapCopyOfEntriesGenerator()) 85 .named("ImmutableSetMultimap.copyOf[Iterable<Entry>]") 86 .withFeatures(ALLOWS_ANY_NULL_QUERIES, KNOWN_ORDER, SERIALIZABLE, CollectionSize.ANY) 87 .createTestSuite()); 88 return suite; 89 } 90 testBuilder_withImmutableEntry()91 public void testBuilder_withImmutableEntry() { 92 ImmutableSetMultimap<String, Integer> multimap = 93 new Builder<String, Integer>().put(Maps.immutableEntry("one", 1)).build(); 94 assertEquals(ImmutableSet.of(1), multimap.get("one")); 95 } 96 testBuilder_withImmutableEntryAndNullContents()97 public void testBuilder_withImmutableEntryAndNullContents() { 98 Builder<String, Integer> builder = new Builder<>(); 99 try { 100 builder.put(Maps.immutableEntry("one", (Integer) null)); 101 fail(); 102 } catch (NullPointerException expected) { 103 } 104 try { 105 builder.put(Maps.immutableEntry((String) null, 1)); 106 fail(); 107 } catch (NullPointerException expected) { 108 } 109 } 110 111 private static class StringHolder { 112 String string; 113 } 114 testBuilder_withMutableEntry()115 public void testBuilder_withMutableEntry() { 116 ImmutableSetMultimap.Builder<String, Integer> builder = new Builder<>(); 117 final StringHolder holder = new StringHolder(); 118 holder.string = "one"; 119 Entry<String, Integer> entry = 120 new AbstractMapEntry<String, Integer>() { 121 @Override 122 public String getKey() { 123 return holder.string; 124 } 125 126 @Override 127 public Integer getValue() { 128 return 1; 129 } 130 }; 131 132 builder.put(entry); 133 holder.string = "two"; 134 assertEquals(ImmutableSet.of(1), builder.build().get("one")); 135 } 136 testBuilderPutAllIterable()137 public void testBuilderPutAllIterable() { 138 ImmutableSetMultimap.Builder<String, Integer> builder = ImmutableSetMultimap.builder(); 139 builder.putAll("foo", Arrays.asList(1, 2, 3)); 140 builder.putAll("bar", Arrays.asList(4, 5)); 141 builder.putAll("foo", Arrays.asList(6, 7)); 142 Multimap<String, Integer> multimap = builder.build(); 143 assertEquals(ImmutableSet.of(1, 2, 3, 6, 7), multimap.get("foo")); 144 assertEquals(ImmutableSet.of(4, 5), multimap.get("bar")); 145 assertEquals(7, multimap.size()); 146 } 147 testBuilderPutAllVarargs()148 public void testBuilderPutAllVarargs() { 149 ImmutableSetMultimap.Builder<String, Integer> builder = ImmutableSetMultimap.builder(); 150 builder.putAll("foo", 1, 2, 3); 151 builder.putAll("bar", 4, 5); 152 builder.putAll("foo", 6, 7); 153 Multimap<String, Integer> multimap = builder.build(); 154 assertEquals(ImmutableSet.of(1, 2, 3, 6, 7), multimap.get("foo")); 155 assertEquals(ImmutableSet.of(4, 5), multimap.get("bar")); 156 assertEquals(7, multimap.size()); 157 } 158 testBuilderPutAllMultimap()159 public void testBuilderPutAllMultimap() { 160 Multimap<String, Integer> toPut = LinkedListMultimap.create(); 161 toPut.put("foo", 1); 162 toPut.put("bar", 4); 163 toPut.put("foo", 2); 164 toPut.put("foo", 3); 165 Multimap<String, Integer> moreToPut = LinkedListMultimap.create(); 166 moreToPut.put("foo", 6); 167 moreToPut.put("bar", 5); 168 moreToPut.put("foo", 7); 169 ImmutableSetMultimap.Builder<String, Integer> builder = ImmutableSetMultimap.builder(); 170 builder.putAll(toPut); 171 builder.putAll(moreToPut); 172 Multimap<String, Integer> multimap = builder.build(); 173 assertEquals(ImmutableSet.of(1, 2, 3, 6, 7), multimap.get("foo")); 174 assertEquals(ImmutableSet.of(4, 5), multimap.get("bar")); 175 assertEquals(7, multimap.size()); 176 } 177 testBuilderPutAllWithDuplicates()178 public void testBuilderPutAllWithDuplicates() { 179 ImmutableSetMultimap.Builder<String, Integer> builder = ImmutableSetMultimap.builder(); 180 builder.putAll("foo", 1, 2, 3); 181 builder.putAll("bar", 4, 5); 182 builder.putAll("foo", 1, 6, 7); 183 ImmutableSetMultimap<String, Integer> multimap = builder.build(); 184 assertEquals(7, multimap.size()); 185 } 186 testBuilderPutWithDuplicates()187 public void testBuilderPutWithDuplicates() { 188 ImmutableSetMultimap.Builder<String, Integer> builder = ImmutableSetMultimap.builder(); 189 builder.putAll("foo", 1, 2, 3); 190 builder.putAll("bar", 4, 5); 191 builder.put("foo", 1); 192 ImmutableSetMultimap<String, Integer> multimap = builder.build(); 193 assertEquals(5, multimap.size()); 194 } 195 testBuilderPutAllMultimapWithDuplicates()196 public void testBuilderPutAllMultimapWithDuplicates() { 197 Multimap<String, Integer> toPut = LinkedListMultimap.create(); 198 toPut.put("foo", 1); 199 toPut.put("bar", 4); 200 toPut.put("foo", 2); 201 toPut.put("foo", 1); 202 toPut.put("bar", 5); 203 ImmutableSetMultimap.Builder<String, Integer> builder = ImmutableSetMultimap.builder(); 204 builder.putAll(toPut); 205 ImmutableSetMultimap<String, Integer> multimap = builder.build(); 206 assertEquals(4, multimap.size()); 207 } 208 testBuilderPutNullKey()209 public void testBuilderPutNullKey() { 210 Multimap<String, Integer> toPut = LinkedListMultimap.create(); 211 toPut.put("foo", null); 212 ImmutableSetMultimap.Builder<String, Integer> builder = ImmutableSetMultimap.builder(); 213 try { 214 builder.put(null, 1); 215 fail(); 216 } catch (NullPointerException expected) { 217 } 218 try { 219 builder.putAll(null, Arrays.asList(1, 2, 3)); 220 fail(); 221 } catch (NullPointerException expected) { 222 } 223 try { 224 builder.putAll(null, 1, 2, 3); 225 fail(); 226 } catch (NullPointerException expected) { 227 } 228 try { 229 builder.putAll(toPut); 230 fail(); 231 } catch (NullPointerException expected) { 232 } 233 } 234 testBuilderPutNullValue()235 public void testBuilderPutNullValue() { 236 Multimap<String, Integer> toPut = LinkedListMultimap.create(); 237 toPut.put(null, 1); 238 ImmutableSetMultimap.Builder<String, Integer> builder = ImmutableSetMultimap.builder(); 239 try { 240 builder.put("foo", null); 241 fail(); 242 } catch (NullPointerException expected) { 243 } 244 try { 245 builder.putAll("foo", Arrays.asList(1, null, 3)); 246 fail(); 247 } catch (NullPointerException expected) { 248 } 249 try { 250 builder.putAll("foo", 4, null, 6); 251 fail(); 252 } catch (NullPointerException expected) { 253 } 254 try { 255 builder.putAll(toPut); 256 fail(); 257 } catch (NullPointerException expected) { 258 } 259 } 260 testBuilderOrderKeysBy()261 public void testBuilderOrderKeysBy() { 262 ImmutableSetMultimap.Builder<String, Integer> builder = ImmutableSetMultimap.builder(); 263 builder.put("b", 3); 264 builder.put("d", 2); 265 builder.put("a", 5); 266 builder.orderKeysBy(Collections.reverseOrder()); 267 builder.put("c", 4); 268 builder.put("a", 2); 269 builder.put("b", 6); 270 ImmutableSetMultimap<String, Integer> multimap = builder.build(); 271 assertThat(multimap.keySet()).containsExactly("d", "c", "b", "a").inOrder(); 272 assertThat(multimap.values()).containsExactly(2, 4, 3, 6, 5, 2).inOrder(); 273 assertThat(multimap.get("a")).containsExactly(5, 2).inOrder(); 274 assertThat(multimap.get("b")).containsExactly(3, 6).inOrder(); 275 assertFalse(multimap.get("a") instanceof ImmutableSortedSet); 276 assertFalse(multimap.get("x") instanceof ImmutableSortedSet); 277 assertFalse(multimap.asMap().get("a") instanceof ImmutableSortedSet); 278 } 279 testBuilderOrderKeysByDuplicates()280 public void testBuilderOrderKeysByDuplicates() { 281 ImmutableSetMultimap.Builder<String, Integer> builder = ImmutableSetMultimap.builder(); 282 builder.put("bb", 3); 283 builder.put("d", 2); 284 builder.put("a", 5); 285 builder.orderKeysBy( 286 new Ordering<String>() { 287 @Override 288 public int compare(String left, String right) { 289 return left.length() - right.length(); 290 } 291 }); 292 builder.put("cc", 4); 293 builder.put("a", 2); 294 builder.put("bb", 6); 295 ImmutableSetMultimap<String, Integer> multimap = builder.build(); 296 assertThat(multimap.keySet()).containsExactly("d", "a", "bb", "cc").inOrder(); 297 assertThat(multimap.values()).containsExactly(2, 5, 2, 3, 6, 4).inOrder(); 298 assertThat(multimap.get("a")).containsExactly(5, 2).inOrder(); 299 assertThat(multimap.get("bb")).containsExactly(3, 6).inOrder(); 300 assertFalse(multimap.get("a") instanceof ImmutableSortedSet); 301 assertFalse(multimap.get("x") instanceof ImmutableSortedSet); 302 assertFalse(multimap.asMap().get("a") instanceof ImmutableSortedSet); 303 } 304 testBuilderOrderValuesBy()305 public void testBuilderOrderValuesBy() { 306 ImmutableSetMultimap.Builder<String, Integer> builder = ImmutableSetMultimap.builder(); 307 builder.put("b", 3); 308 builder.put("d", 2); 309 builder.put("a", 5); 310 builder.orderValuesBy(Collections.reverseOrder()); 311 builder.put("c", 4); 312 builder.put("a", 2); 313 builder.put("b", 6); 314 ImmutableSetMultimap<String, Integer> multimap = builder.build(); 315 assertThat(multimap.keySet()).containsExactly("b", "d", "a", "c").inOrder(); 316 assertThat(multimap.values()).containsExactly(6, 3, 2, 5, 2, 4).inOrder(); 317 assertThat(multimap.get("a")).containsExactly(5, 2).inOrder(); 318 assertThat(multimap.get("b")).containsExactly(6, 3).inOrder(); 319 assertTrue(multimap.get("a") instanceof ImmutableSortedSet); 320 assertEquals( 321 Collections.reverseOrder(), ((ImmutableSortedSet<Integer>) multimap.get("a")).comparator()); 322 assertTrue(multimap.get("x") instanceof ImmutableSortedSet); 323 assertEquals( 324 Collections.reverseOrder(), ((ImmutableSortedSet<Integer>) multimap.get("x")).comparator()); 325 assertTrue(multimap.asMap().get("a") instanceof ImmutableSortedSet); 326 assertEquals( 327 Collections.reverseOrder(), 328 ((ImmutableSortedSet<Integer>) multimap.asMap().get("a")).comparator()); 329 } 330 testBuilderOrderKeysAndValuesBy()331 public void testBuilderOrderKeysAndValuesBy() { 332 ImmutableSetMultimap.Builder<String, Integer> builder = ImmutableSetMultimap.builder(); 333 builder.put("b", 3); 334 builder.put("d", 2); 335 builder.put("a", 5); 336 builder.orderKeysBy(Collections.reverseOrder()); 337 builder.orderValuesBy(Collections.reverseOrder()); 338 builder.put("c", 4); 339 builder.put("a", 2); 340 builder.put("b", 6); 341 ImmutableSetMultimap<String, Integer> multimap = builder.build(); 342 assertThat(multimap.keySet()).containsExactly("d", "c", "b", "a").inOrder(); 343 assertThat(multimap.values()).containsExactly(2, 4, 6, 3, 5, 2).inOrder(); 344 assertThat(multimap.get("a")).containsExactly(5, 2).inOrder(); 345 assertThat(multimap.get("b")).containsExactly(6, 3).inOrder(); 346 assertTrue(multimap.get("a") instanceof ImmutableSortedSet); 347 assertEquals( 348 Collections.reverseOrder(), ((ImmutableSortedSet<Integer>) multimap.get("a")).comparator()); 349 assertTrue(multimap.get("x") instanceof ImmutableSortedSet); 350 assertEquals( 351 Collections.reverseOrder(), ((ImmutableSortedSet<Integer>) multimap.get("x")).comparator()); 352 assertTrue(multimap.asMap().get("a") instanceof ImmutableSortedSet); 353 assertEquals( 354 Collections.reverseOrder(), 355 ((ImmutableSortedSet<Integer>) multimap.asMap().get("a")).comparator()); 356 } 357 testCopyOf()358 public void testCopyOf() { 359 HashMultimap<String, Integer> input = HashMultimap.create(); 360 input.put("foo", 1); 361 input.put("bar", 2); 362 input.put("foo", 3); 363 Multimap<String, Integer> multimap = ImmutableSetMultimap.copyOf(input); 364 assertEquals(multimap, input); 365 assertEquals(input, multimap); 366 } 367 testCopyOfWithDuplicates()368 public void testCopyOfWithDuplicates() { 369 ArrayListMultimap<Object, Object> input = ArrayListMultimap.create(); 370 input.put("foo", 1); 371 input.put("bar", 2); 372 input.put("foo", 3); 373 input.put("foo", 1); 374 ImmutableSetMultimap<Object, Object> copy = ImmutableSetMultimap.copyOf(input); 375 assertEquals(3, copy.size()); 376 } 377 testCopyOfEmpty()378 public void testCopyOfEmpty() { 379 HashMultimap<String, Integer> input = HashMultimap.create(); 380 Multimap<String, Integer> multimap = ImmutableSetMultimap.copyOf(input); 381 assertEquals(multimap, input); 382 assertEquals(input, multimap); 383 } 384 testCopyOfImmutableSetMultimap()385 public void testCopyOfImmutableSetMultimap() { 386 Multimap<String, Integer> multimap = createMultimap(); 387 assertSame(multimap, ImmutableSetMultimap.copyOf(multimap)); 388 } 389 testCopyOfNullKey()390 public void testCopyOfNullKey() { 391 HashMultimap<String, Integer> input = HashMultimap.create(); 392 input.put(null, 1); 393 try { 394 ImmutableSetMultimap.copyOf(input); 395 fail(); 396 } catch (NullPointerException expected) { 397 } 398 } 399 testCopyOfNullValue()400 public void testCopyOfNullValue() { 401 HashMultimap<String, Integer> input = HashMultimap.create(); 402 input.putAll("foo", Arrays.asList(1, null, 3)); 403 try { 404 ImmutableSetMultimap.copyOf(input); 405 fail(); 406 } catch (NullPointerException expected) { 407 } 408 } 409 testToImmutableSetMultimap()410 public void testToImmutableSetMultimap() { 411 Collector<Entry<String, Integer>, ?, ImmutableSetMultimap<String, Integer>> collector = 412 ImmutableSetMultimap.toImmutableSetMultimap(Entry::getKey, Entry::getValue); 413 BiPredicate<ImmutableSetMultimap<?, ?>, ImmutableSetMultimap<?, ?>> equivalence = 414 Equivalence.equals() 415 .onResultOf( 416 (ImmutableSetMultimap<?, ?> mm) -> 417 ImmutableListMultimap.copyOf(mm).asMap().entrySet().asList()) 418 .and(Equivalence.equals()); 419 CollectorTester.of(collector, equivalence) 420 .expectCollects(ImmutableSetMultimap.of()) 421 .expectCollects( 422 ImmutableSetMultimap.of("a", 1, "b", 2, "a", 3, "c", 4), 423 mapEntry("a", 1), 424 mapEntry("b", 2), 425 mapEntry("a", 3), 426 mapEntry("c", 4)); 427 } 428 testFlatteningToImmutableSetMultimap()429 public void testFlatteningToImmutableSetMultimap() { 430 Collector<String, ?, ImmutableSetMultimap<Character, Character>> collector = 431 ImmutableSetMultimap.flatteningToImmutableSetMultimap( 432 str -> str.charAt(0), str -> Chars.asList(str.substring(1).toCharArray()).stream()); 433 BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence = 434 Equivalence.equals() 435 .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet())) 436 .and(Equivalence.equals()); 437 ImmutableSetMultimap<Character, Character> empty = ImmutableSetMultimap.of(); 438 ImmutableSetMultimap<Character, Character> filled = 439 ImmutableSetMultimap.<Character, Character>builder() 440 .putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a')) 441 .putAll('a', Arrays.asList('p', 'p', 'l', 'e')) 442 .putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't')) 443 .putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's')) 444 .putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y')) 445 .build(); 446 CollectorTester.of(collector, equivalence) 447 .expectCollects(empty) 448 .expectCollects(filled, "banana", "apple", "carrot", "asparagus", "cherry"); 449 } 450 testEmptyMultimapReads()451 public void testEmptyMultimapReads() { 452 Multimap<String, Integer> multimap = ImmutableSetMultimap.of(); 453 assertFalse(multimap.containsKey("foo")); 454 assertFalse(multimap.containsValue(1)); 455 assertFalse(multimap.containsEntry("foo", 1)); 456 assertTrue(multimap.entries().isEmpty()); 457 assertTrue(multimap.equals(HashMultimap.create())); 458 assertEquals(Collections.emptySet(), multimap.get("foo")); 459 assertEquals(0, multimap.hashCode()); 460 assertTrue(multimap.isEmpty()); 461 assertEquals(HashMultiset.create(), multimap.keys()); 462 assertEquals(Collections.emptySet(), multimap.keySet()); 463 assertEquals(0, multimap.size()); 464 assertTrue(multimap.values().isEmpty()); 465 assertEquals("{}", multimap.toString()); 466 } 467 testEmptyMultimapWrites()468 public void testEmptyMultimapWrites() { 469 Multimap<String, Integer> multimap = ImmutableSetMultimap.of(); 470 UnmodifiableCollectionTests.assertMultimapIsUnmodifiable(multimap, "foo", 1); 471 } 472 testMultimapReads()473 public void testMultimapReads() { 474 Multimap<String, Integer> multimap = createMultimap(); 475 assertTrue(multimap.containsKey("foo")); 476 assertFalse(multimap.containsKey("cat")); 477 assertTrue(multimap.containsValue(1)); 478 assertFalse(multimap.containsValue(5)); 479 assertTrue(multimap.containsEntry("foo", 1)); 480 assertFalse(multimap.containsEntry("cat", 1)); 481 assertFalse(multimap.containsEntry("foo", 5)); 482 assertFalse(multimap.entries().isEmpty()); 483 assertEquals(3, multimap.size()); 484 assertFalse(multimap.isEmpty()); 485 assertEquals("{foo=[1, 3], bar=[2]}", multimap.toString()); 486 } 487 testMultimapWrites()488 public void testMultimapWrites() { 489 Multimap<String, Integer> multimap = createMultimap(); 490 UnmodifiableCollectionTests.assertMultimapIsUnmodifiable(multimap, "bar", 2); 491 } 492 testMultimapEquals()493 public void testMultimapEquals() { 494 Multimap<String, Integer> multimap = createMultimap(); 495 Multimap<String, Integer> hashMultimap = HashMultimap.create(); 496 hashMultimap.putAll("foo", Arrays.asList(1, 3)); 497 hashMultimap.put("bar", 2); 498 499 new EqualsTester() 500 .addEqualityGroup( 501 multimap, 502 createMultimap(), 503 hashMultimap, 504 ImmutableSetMultimap.<String, Integer>builder() 505 .put("bar", 2) 506 .put("foo", 1) 507 .put("foo", 3) 508 .build(), 509 ImmutableSetMultimap.<String, Integer>builder() 510 .put("bar", 2) 511 .put("foo", 3) 512 .put("foo", 1) 513 .build()) 514 .addEqualityGroup( 515 ImmutableSetMultimap.<String, Integer>builder() 516 .put("foo", 2) 517 .put("foo", 3) 518 .put("foo", 1) 519 .build()) 520 .addEqualityGroup( 521 ImmutableSetMultimap.<String, Integer>builder().put("bar", 2).put("foo", 3).build()) 522 .testEquals(); 523 } 524 testOf()525 public void testOf() { 526 assertMultimapEquals(ImmutableSetMultimap.of("one", 1), "one", 1); 527 assertMultimapEquals(ImmutableSetMultimap.of("one", 1, "two", 2), "one", 1, "two", 2); 528 assertMultimapEquals( 529 ImmutableSetMultimap.of("one", 1, "two", 2, "three", 3), "one", 1, "two", 2, "three", 3); 530 assertMultimapEquals( 531 ImmutableSetMultimap.of("one", 1, "two", 2, "three", 3, "four", 4), 532 "one", 533 1, 534 "two", 535 2, 536 "three", 537 3, 538 "four", 539 4); 540 assertMultimapEquals( 541 ImmutableSetMultimap.of("one", 1, "two", 2, "three", 3, "four", 4, "five", 5), 542 "one", 543 1, 544 "two", 545 2, 546 "three", 547 3, 548 "four", 549 4, 550 "five", 551 5); 552 } 553 testInverse()554 public void testInverse() { 555 assertEquals( 556 ImmutableSetMultimap.<Integer, String>of(), 557 ImmutableSetMultimap.<String, Integer>of().inverse()); 558 assertEquals(ImmutableSetMultimap.of(1, "one"), ImmutableSetMultimap.of("one", 1).inverse()); 559 assertEquals( 560 ImmutableSetMultimap.of(1, "one", 2, "two"), 561 ImmutableSetMultimap.of("one", 1, "two", 2).inverse()); 562 assertEquals( 563 ImmutableSetMultimap.of('o', "of", 'f', "of", 't', "to", 'o', "to"), 564 ImmutableSetMultimap.of("of", 'o', "of", 'f', "to", 't', "to", 'o').inverse()); 565 } 566 testInverseMinimizesWork()567 public void testInverseMinimizesWork() { 568 ImmutableSetMultimap<String, Character> multimap = 569 ImmutableSetMultimap.of("of", 'o', "of", 'f', "to", 't', "to", 'o'); 570 assertSame(multimap.inverse(), multimap.inverse()); 571 assertSame(multimap, multimap.inverse().inverse()); 572 } 573 assertMultimapEquals( Multimap<K, V> multimap, Object... alternatingKeysAndValues)574 private static <K, V> void assertMultimapEquals( 575 Multimap<K, V> multimap, Object... alternatingKeysAndValues) { 576 assertEquals(multimap.size(), alternatingKeysAndValues.length / 2); 577 int i = 0; 578 for (Entry<K, V> entry : multimap.entries()) { 579 assertEquals(alternatingKeysAndValues[i++], entry.getKey()); 580 assertEquals(alternatingKeysAndValues[i++], entry.getValue()); 581 } 582 } 583 584 @GwtIncompatible // SerializableTester testSerialization()585 public void testSerialization() { 586 Multimap<String, Integer> multimap = createMultimap(); 587 SerializableTester.reserializeAndAssert(multimap); 588 assertEquals(multimap.size(), SerializableTester.reserialize(multimap).size()); 589 SerializableTester.reserializeAndAssert(multimap.get("foo")); 590 LenientSerializableTester.reserializeAndAssertLenient(multimap.keySet()); 591 LenientSerializableTester.reserializeAndAssertLenient(multimap.keys()); 592 SerializableTester.reserializeAndAssert(multimap.asMap()); 593 Collection<Integer> valuesCopy = SerializableTester.reserialize(multimap.values()); 594 assertEquals(HashMultiset.create(multimap.values()), HashMultiset.create(valuesCopy)); 595 } 596 597 @GwtIncompatible // SerializableTester testEmptySerialization()598 public void testEmptySerialization() { 599 Multimap<String, Integer> multimap = ImmutableSetMultimap.of(); 600 assertSame(multimap, SerializableTester.reserialize(multimap)); 601 } 602 603 @GwtIncompatible // SerializableTester testSortedSerialization()604 public void testSortedSerialization() { 605 Multimap<String, Integer> multimap = 606 new ImmutableSetMultimap.Builder<String, Integer>() 607 .orderKeysBy(Ordering.natural().reverse()) 608 .orderValuesBy(Ordering.usingToString()) 609 .put("a", 2) 610 .put("a", 10) 611 .put("b", 1) 612 .build(); 613 multimap = SerializableTester.reserialize(multimap); 614 assertThat(multimap.keySet()).containsExactly("b", "a").inOrder(); 615 assertThat(multimap.get("a")).containsExactly(10, 2).inOrder(); 616 assertEquals( 617 Ordering.usingToString(), ((ImmutableSortedSet<Integer>) multimap.get("a")).comparator()); 618 assertEquals( 619 Ordering.usingToString(), ((ImmutableSortedSet<Integer>) multimap.get("z")).comparator()); 620 } 621 createMultimap()622 private ImmutableSetMultimap<String, Integer> createMultimap() { 623 return ImmutableSetMultimap.<String, Integer>builder() 624 .put("foo", 1) 625 .put("bar", 2) 626 .put("foo", 3) 627 .build(); 628 } 629 630 @GwtIncompatible // reflection 631 @AndroidIncompatible // see ImmutableTableTest.testNullPointerInstance testNulls()632 public void testNulls() throws Exception { 633 NullPointerTester tester = new NullPointerTester(); 634 tester.testAllPublicStaticMethods(ImmutableSetMultimap.class); 635 tester.ignore(ImmutableSetMultimap.class.getMethod("get", Object.class)); 636 tester.testAllPublicInstanceMethods(ImmutableSetMultimap.of()); 637 tester.testAllPublicInstanceMethods(ImmutableSetMultimap.of("a", 1)); 638 } 639 } 640