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