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.collect.testing.Helpers.mapEntry; 20 import static com.google.common.truth.Truth.assertThat; 21 22 import com.google.common.annotations.GwtCompatible; 23 import com.google.common.annotations.GwtIncompatible; 24 import com.google.common.annotations.J2ktIncompatible; 25 import com.google.common.base.Equivalence; 26 import com.google.common.collect.ImmutableBiMap.Builder; 27 import com.google.common.collect.testing.features.CollectionFeature; 28 import com.google.common.collect.testing.features.CollectionSize; 29 import com.google.common.collect.testing.features.MapFeature; 30 import com.google.common.collect.testing.google.BiMapGenerators.ImmutableBiMapCopyOfEntriesGenerator; 31 import com.google.common.collect.testing.google.BiMapGenerators.ImmutableBiMapCopyOfGenerator; 32 import com.google.common.collect.testing.google.BiMapGenerators.ImmutableBiMapGenerator; 33 import com.google.common.collect.testing.google.BiMapInverseTester; 34 import com.google.common.collect.testing.google.BiMapTestSuiteBuilder; 35 import com.google.common.collect.testing.google.TestStringBiMapGenerator; 36 import com.google.common.testing.CollectorTester; 37 import com.google.common.testing.SerializableTester; 38 import java.util.AbstractMap; 39 import java.util.Arrays; 40 import java.util.Collections; 41 import java.util.LinkedHashMap; 42 import java.util.Map; 43 import java.util.Map.Entry; 44 import java.util.Set; 45 import java.util.stream.Collector; 46 import java.util.stream.Stream; 47 import junit.framework.Test; 48 import junit.framework.TestCase; 49 import junit.framework.TestSuite; 50 import org.checkerframework.checker.nullness.qual.Nullable; 51 52 /** 53 * Tests for {@link ImmutableBiMap}. 54 * 55 * @author Jared Levy 56 */ 57 @GwtCompatible(emulated = true) 58 @ElementTypesAreNonnullByDefault 59 public class ImmutableBiMapTest extends TestCase { 60 61 // TODO: Reduce duplication of ImmutableMapTest code 62 63 @J2ktIncompatible 64 @GwtIncompatible // suite suite()65 public static Test suite() { 66 TestSuite suite = new TestSuite(); 67 68 suite.addTest( 69 BiMapTestSuiteBuilder.using(new ImmutableBiMapGenerator()) 70 .named("ImmutableBiMap") 71 .withFeatures( 72 CollectionSize.ANY, 73 CollectionFeature.SERIALIZABLE, 74 CollectionFeature.KNOWN_ORDER, 75 MapFeature.REJECTS_DUPLICATES_AT_CREATION, 76 MapFeature.ALLOWS_ANY_NULL_QUERIES) 77 .suppressing(BiMapInverseTester.getInverseSameAfterSerializingMethods()) 78 .createTestSuite()); 79 suite.addTest( 80 BiMapTestSuiteBuilder.using( 81 new TestStringBiMapGenerator() { 82 @Override 83 protected BiMap<String, String> create(Entry<String, String>[] entries) { 84 return ImmutableBiMap.<String, String>builder() 85 .putAll(Arrays.asList(entries)) 86 .buildJdkBacked(); 87 } 88 }) 89 .named("ImmutableBiMap [JDK backed]") 90 .withFeatures( 91 CollectionSize.ANY, 92 CollectionFeature.SERIALIZABLE, 93 CollectionFeature.KNOWN_ORDER, 94 MapFeature.REJECTS_DUPLICATES_AT_CREATION, 95 MapFeature.ALLOWS_ANY_NULL_QUERIES) 96 .suppressing(BiMapInverseTester.getInverseSameAfterSerializingMethods()) 97 .createTestSuite()); 98 suite.addTest( 99 BiMapTestSuiteBuilder.using(new ImmutableBiMapCopyOfGenerator()) 100 .named("ImmutableBiMap.copyOf[Map]") 101 .withFeatures( 102 CollectionSize.ANY, 103 CollectionFeature.SERIALIZABLE, 104 CollectionFeature.KNOWN_ORDER, 105 MapFeature.ALLOWS_ANY_NULL_QUERIES) 106 .suppressing(BiMapInverseTester.getInverseSameAfterSerializingMethods()) 107 .createTestSuite()); 108 suite.addTest( 109 BiMapTestSuiteBuilder.using(new ImmutableBiMapCopyOfEntriesGenerator()) 110 .named("ImmutableBiMap.copyOf[Iterable<Entry>]") 111 .withFeatures( 112 CollectionSize.ANY, 113 CollectionFeature.SERIALIZABLE, 114 CollectionFeature.KNOWN_ORDER, 115 MapFeature.REJECTS_DUPLICATES_AT_CREATION, 116 MapFeature.ALLOWS_ANY_NULL_QUERIES) 117 .suppressing(BiMapInverseTester.getInverseSameAfterSerializingMethods()) 118 .createTestSuite()); 119 suite.addTestSuite(ImmutableBiMapTest.class); 120 121 return suite; 122 } 123 124 // Creation tests 125 testEmptyBuilder()126 public void testEmptyBuilder() { 127 ImmutableBiMap<String, Integer> map = new Builder<String, Integer>().build(); 128 assertEquals(Collections.<String, Integer>emptyMap(), map); 129 assertEquals(Collections.<Integer, String>emptyMap(), map.inverse()); 130 assertSame(ImmutableBiMap.of(), map); 131 } 132 testSingletonBuilder()133 public void testSingletonBuilder() { 134 ImmutableBiMap<String, Integer> map = new Builder<String, Integer>().put("one", 1).build(); 135 assertMapEquals(map, "one", 1); 136 assertMapEquals(map.inverse(), 1, "one"); 137 } 138 testBuilder_withImmutableEntry()139 public void testBuilder_withImmutableEntry() { 140 ImmutableBiMap<String, Integer> map = 141 new Builder<String, Integer>().put(Maps.immutableEntry("one", 1)).build(); 142 assertMapEquals(map, "one", 1); 143 } 144 testBuilder()145 public void testBuilder() { 146 ImmutableBiMap<String, Integer> map = 147 ImmutableBiMap.<String, Integer>builder() 148 .put("one", 1) 149 .put("two", 2) 150 .put("three", 3) 151 .put("four", 4) 152 .put("five", 5) 153 .build(); 154 assertMapEquals(map, "one", 1, "two", 2, "three", 3, "four", 4, "five", 5); 155 assertMapEquals(map.inverse(), 1, "one", 2, "two", 3, "three", 4, "four", 5, "five"); 156 } 157 158 @GwtIncompatible testBuilderExactlySizedReusesArray()159 public void testBuilderExactlySizedReusesArray() { 160 ImmutableBiMap.Builder<Integer, Integer> builder = ImmutableBiMap.builderWithExpectedSize(10); 161 Entry<Integer, Integer>[] builderArray = builder.entries; 162 for (int i = 0; i < 10; i++) { 163 builder.put(i, i); 164 } 165 Entry<Integer, Integer>[] builderArrayAfterPuts = builder.entries; 166 RegularImmutableBiMap<Integer, Integer> map = 167 (RegularImmutableBiMap<Integer, Integer>) builder.build(); 168 Entry<Integer, Integer>[] mapInternalArray = map.entries; 169 assertSame(builderArray, builderArrayAfterPuts); 170 assertSame(builderArray, mapInternalArray); 171 } 172 testBuilder_orderEntriesByValue()173 public void testBuilder_orderEntriesByValue() { 174 ImmutableBiMap<String, Integer> map = 175 ImmutableBiMap.<String, Integer>builder() 176 .orderEntriesByValue(Ordering.natural()) 177 .put("three", 3) 178 .put("one", 1) 179 .put("five", 5) 180 .put("four", 4) 181 .put("two", 2) 182 .build(); 183 assertMapEquals(map, "one", 1, "two", 2, "three", 3, "four", 4, "five", 5); 184 assertMapEquals(map.inverse(), 1, "one", 2, "two", 3, "three", 4, "four", 5, "five"); 185 } 186 testBuilder_orderEntriesByValueAfterExactSizeBuild()187 public void testBuilder_orderEntriesByValueAfterExactSizeBuild() { 188 ImmutableBiMap.Builder<String, Integer> builder = 189 new ImmutableBiMap.Builder<String, Integer>(2).put("four", 4).put("one", 1); 190 ImmutableMap<String, Integer> keyOrdered = builder.build(); 191 ImmutableMap<String, Integer> valueOrdered = 192 builder.orderEntriesByValue(Ordering.natural()).build(); 193 assertMapEquals(keyOrdered, "four", 4, "one", 1); 194 assertMapEquals(valueOrdered, "one", 1, "four", 4); 195 } 196 testBuilder_orderEntriesByValue_usedTwiceFails()197 public void testBuilder_orderEntriesByValue_usedTwiceFails() { 198 ImmutableBiMap.Builder<String, Integer> builder = 199 new Builder<String, Integer>().orderEntriesByValue(Ordering.natural()); 200 try { 201 builder.orderEntriesByValue(Ordering.natural()); 202 fail("Expected IllegalStateException"); 203 } catch (IllegalStateException expected) { 204 } 205 } 206 testBuilderPutAllWithEmptyMap()207 public void testBuilderPutAllWithEmptyMap() { 208 ImmutableBiMap<String, Integer> map = 209 new Builder<String, Integer>().putAll(Collections.<String, Integer>emptyMap()).build(); 210 assertEquals(Collections.<String, Integer>emptyMap(), map); 211 } 212 testBuilderPutAll()213 public void testBuilderPutAll() { 214 Map<String, Integer> toPut = new LinkedHashMap<>(); 215 toPut.put("one", 1); 216 toPut.put("two", 2); 217 toPut.put("three", 3); 218 Map<String, Integer> moreToPut = new LinkedHashMap<>(); 219 moreToPut.put("four", 4); 220 moreToPut.put("five", 5); 221 222 ImmutableBiMap<String, Integer> map = 223 new Builder<String, Integer>().putAll(toPut).putAll(moreToPut).build(); 224 assertMapEquals(map, "one", 1, "two", 2, "three", 3, "four", 4, "five", 5); 225 assertMapEquals(map.inverse(), 1, "one", 2, "two", 3, "three", 4, "four", 5, "five"); 226 } 227 testBuilderReuse()228 public void testBuilderReuse() { 229 Builder<String, Integer> builder = new Builder<>(); 230 ImmutableBiMap<String, Integer> mapOne = builder.put("one", 1).put("two", 2).build(); 231 ImmutableBiMap<String, Integer> mapTwo = builder.put("three", 3).put("four", 4).build(); 232 233 assertMapEquals(mapOne, "one", 1, "two", 2); 234 assertMapEquals(mapOne.inverse(), 1, "one", 2, "two"); 235 assertMapEquals(mapTwo, "one", 1, "two", 2, "three", 3, "four", 4); 236 assertMapEquals(mapTwo.inverse(), 1, "one", 2, "two", 3, "three", 4, "four"); 237 } 238 testBuilderPutNullKey()239 public void testBuilderPutNullKey() { 240 Builder<String, Integer> builder = new Builder<>(); 241 try { 242 builder.put(null, 1); 243 fail(); 244 } catch (NullPointerException expected) { 245 } 246 } 247 testBuilderPutNullValue()248 public void testBuilderPutNullValue() { 249 Builder<String, Integer> builder = new Builder<>(); 250 try { 251 builder.put("one", null); 252 fail(); 253 } catch (NullPointerException expected) { 254 } 255 } 256 testBuilderPutNullKeyViaPutAll()257 public void testBuilderPutNullKeyViaPutAll() { 258 Builder<String, Integer> builder = new Builder<>(); 259 try { 260 builder.putAll(Collections.<String, Integer>singletonMap(null, 1)); 261 fail(); 262 } catch (NullPointerException expected) { 263 } 264 } 265 testBuilderPutNullValueViaPutAll()266 public void testBuilderPutNullValueViaPutAll() { 267 Builder<String, Integer> builder = new Builder<>(); 268 try { 269 builder.putAll(Collections.<String, Integer>singletonMap("one", null)); 270 fail(); 271 } catch (NullPointerException expected) { 272 } 273 } 274 275 @SuppressWarnings("AlwaysThrows") testPuttingTheSameKeyTwiceThrowsOnBuild()276 public void testPuttingTheSameKeyTwiceThrowsOnBuild() { 277 Builder<String, Integer> builder = 278 new Builder<String, Integer>() 279 .put("one", 1) 280 .put("one", 1); // throwing on this line would be even better 281 282 try { 283 builder.build(); 284 fail(); 285 } catch (IllegalArgumentException expected) { 286 assertThat(expected.getMessage()).contains("one"); 287 } 288 } 289 testOf()290 public void testOf() { 291 assertMapEquals(ImmutableBiMap.of("one", 1), "one", 1); 292 assertMapEquals(ImmutableBiMap.of("one", 1).inverse(), 1, "one"); 293 assertMapEquals(ImmutableBiMap.of("one", 1, "two", 2), "one", 1, "two", 2); 294 assertMapEquals(ImmutableBiMap.of("one", 1, "two", 2).inverse(), 1, "one", 2, "two"); 295 assertMapEquals( 296 ImmutableBiMap.of("one", 1, "two", 2, "three", 3), "one", 1, "two", 2, "three", 3); 297 assertMapEquals( 298 ImmutableBiMap.of("one", 1, "two", 2, "three", 3).inverse(), 299 1, 300 "one", 301 2, 302 "two", 303 3, 304 "three"); 305 assertMapEquals( 306 ImmutableBiMap.of("one", 1, "two", 2, "three", 3, "four", 4), 307 "one", 308 1, 309 "two", 310 2, 311 "three", 312 3, 313 "four", 314 4); 315 assertMapEquals( 316 ImmutableBiMap.of("one", 1, "two", 2, "three", 3, "four", 4).inverse(), 317 1, 318 "one", 319 2, 320 "two", 321 3, 322 "three", 323 4, 324 "four"); 325 assertMapEquals( 326 ImmutableBiMap.of("one", 1, "two", 2, "three", 3, "four", 4, "five", 5), 327 "one", 328 1, 329 "two", 330 2, 331 "three", 332 3, 333 "four", 334 4, 335 "five", 336 5); 337 assertMapEquals( 338 ImmutableBiMap.of("one", 1, "two", 2, "three", 3, "four", 4, "five", 5).inverse(), 339 1, 340 "one", 341 2, 342 "two", 343 3, 344 "three", 345 4, 346 "four", 347 5, 348 "five"); 349 assertMapEquals( 350 ImmutableBiMap.of( 351 "one", 1, 352 "two", 2, 353 "three", 3, 354 "four", 4, 355 "five", 5, 356 "six", 6), 357 "one", 358 1, 359 "two", 360 2, 361 "three", 362 3, 363 "four", 364 4, 365 "five", 366 5, 367 "six", 368 6); 369 assertMapEquals( 370 ImmutableBiMap.of( 371 "one", 1, 372 "two", 2, 373 "three", 3, 374 "four", 4, 375 "five", 5, 376 "six", 6, 377 "seven", 7), 378 "one", 379 1, 380 "two", 381 2, 382 "three", 383 3, 384 "four", 385 4, 386 "five", 387 5, 388 "six", 389 6, 390 "seven", 391 7); 392 assertMapEquals( 393 ImmutableBiMap.of( 394 "one", 1, 395 "two", 2, 396 "three", 3, 397 "four", 4, 398 "five", 5, 399 "six", 6, 400 "seven", 7, 401 "eight", 8), 402 "one", 403 1, 404 "two", 405 2, 406 "three", 407 3, 408 "four", 409 4, 410 "five", 411 5, 412 "six", 413 6, 414 "seven", 415 7, 416 "eight", 417 8); 418 assertMapEquals( 419 ImmutableBiMap.of( 420 "one", 1, 421 "two", 2, 422 "three", 3, 423 "four", 4, 424 "five", 5, 425 "six", 6, 426 "seven", 7, 427 "eight", 8, 428 "nine", 9), 429 "one", 430 1, 431 "two", 432 2, 433 "three", 434 3, 435 "four", 436 4, 437 "five", 438 5, 439 "six", 440 6, 441 "seven", 442 7, 443 "eight", 444 8, 445 "nine", 446 9); 447 assertMapEquals( 448 ImmutableBiMap.of( 449 "one", 1, 450 "two", 2, 451 "three", 3, 452 "four", 4, 453 "five", 5, 454 "six", 6, 455 "seven", 7, 456 "eight", 8, 457 "nine", 9, 458 "ten", 10), 459 "one", 460 1, 461 "two", 462 2, 463 "three", 464 3, 465 "four", 466 4, 467 "five", 468 5, 469 "six", 470 6, 471 "seven", 472 7, 473 "eight", 474 8, 475 "nine", 476 9, 477 "ten", 478 10); 479 } 480 testOfNullKey()481 public void testOfNullKey() { 482 try { 483 ImmutableBiMap.of(null, 1); 484 fail(); 485 } catch (NullPointerException expected) { 486 } 487 488 try { 489 ImmutableBiMap.of("one", 1, null, 2); 490 fail(); 491 } catch (NullPointerException expected) { 492 } 493 } 494 testOfNullValue()495 public void testOfNullValue() { 496 try { 497 ImmutableBiMap.of("one", null); 498 fail(); 499 } catch (NullPointerException expected) { 500 } 501 502 try { 503 ImmutableBiMap.of("one", 1, "two", null); 504 fail(); 505 } catch (NullPointerException expected) { 506 } 507 } 508 509 @SuppressWarnings("AlwaysThrows") testOfWithDuplicateKey()510 public void testOfWithDuplicateKey() { 511 try { 512 ImmutableBiMap.of("one", 1, "one", 1); 513 fail(); 514 } catch (IllegalArgumentException expected) { 515 assertThat(expected.getMessage()).contains("one"); 516 } 517 } 518 testOfEntries()519 public void testOfEntries() { 520 assertMapEquals(ImmutableBiMap.ofEntries(entry("one", 1), entry("two", 2)), "one", 1, "two", 2); 521 } 522 testOfEntriesNull()523 public void testOfEntriesNull() { 524 Entry<@Nullable Integer, Integer> nullKey = entry(null, 23); 525 try { 526 ImmutableBiMap.ofEntries((Entry<Integer, Integer>) nullKey); 527 fail(); 528 } catch (NullPointerException expected) { 529 } 530 Entry<Integer, @Nullable Integer> nullValue = 531 ImmutableBiMapTest.<@Nullable Integer>entry(23, null); 532 try { 533 ImmutableBiMap.ofEntries((Entry<Integer, Integer>) nullValue); 534 fail(); 535 } catch (NullPointerException expected) { 536 } 537 } 538 entry(T key, T value)539 private static <T extends @Nullable Object> Entry<T, T> entry(T key, T value) { 540 return new AbstractMap.SimpleImmutableEntry<>(key, value); 541 } 542 testCopyOfEmptyMap()543 public void testCopyOfEmptyMap() { 544 ImmutableBiMap<String, Integer> copy = 545 ImmutableBiMap.copyOf(Collections.<String, Integer>emptyMap()); 546 assertEquals(Collections.<String, Integer>emptyMap(), copy); 547 assertSame(copy, ImmutableBiMap.copyOf(copy)); 548 assertSame(ImmutableBiMap.of(), copy); 549 } 550 testCopyOfSingletonMap()551 public void testCopyOfSingletonMap() { 552 ImmutableBiMap<String, Integer> copy = 553 ImmutableBiMap.copyOf(Collections.singletonMap("one", 1)); 554 assertMapEquals(copy, "one", 1); 555 assertSame(copy, ImmutableBiMap.copyOf(copy)); 556 } 557 testCopyOf()558 public void testCopyOf() { 559 Map<String, Integer> original = new LinkedHashMap<>(); 560 original.put("one", 1); 561 original.put("two", 2); 562 original.put("three", 3); 563 564 ImmutableBiMap<String, Integer> copy = ImmutableBiMap.copyOf(original); 565 assertMapEquals(copy, "one", 1, "two", 2, "three", 3); 566 assertSame(copy, ImmutableBiMap.copyOf(copy)); 567 } 568 testEmpty()569 public void testEmpty() { 570 ImmutableBiMap<String, Integer> bimap = ImmutableBiMap.of(); 571 assertEquals(Collections.<String, Integer>emptyMap(), bimap); 572 assertEquals(Collections.<Integer, String>emptyMap(), bimap.inverse()); 573 } 574 testFromHashMap()575 public void testFromHashMap() { 576 Map<String, Integer> hashMap = Maps.newLinkedHashMap(); 577 hashMap.put("one", 1); 578 hashMap.put("two", 2); 579 ImmutableBiMap<String, Integer> bimap = ImmutableBiMap.copyOf(hashMap); 580 assertMapEquals(bimap, "one", 1, "two", 2); 581 assertMapEquals(bimap.inverse(), 1, "one", 2, "two"); 582 } 583 testFromImmutableMap()584 public void testFromImmutableMap() { 585 ImmutableBiMap<String, Integer> bimap = 586 ImmutableBiMap.copyOf( 587 new ImmutableMap.Builder<String, Integer>() 588 .put("one", 1) 589 .put("two", 2) 590 .put("three", 3) 591 .put("four", 4) 592 .put("five", 5) 593 .buildOrThrow()); 594 assertMapEquals(bimap, "one", 1, "two", 2, "three", 3, "four", 4, "five", 5); 595 assertMapEquals(bimap.inverse(), 1, "one", 2, "two", 3, "three", 4, "four", 5, "five"); 596 } 597 testDuplicateValues()598 public void testDuplicateValues() { 599 ImmutableMap<String, Integer> map = 600 new ImmutableMap.Builder<String, Integer>() 601 .put("one", 1) 602 .put("two", 2) 603 .put("uno", 1) 604 .put("dos", 2) 605 .buildOrThrow(); 606 607 try { 608 ImmutableBiMap.copyOf(map); 609 fail(); 610 } catch (IllegalArgumentException expected) { 611 assertThat(expected.getMessage()).containsMatch("1|2"); 612 // We don't specify which of the two dups should be reported. 613 } 614 } 615 testToImmutableBiMap()616 public void testToImmutableBiMap() { 617 Collector<Entry<String, Integer>, ?, ImmutableBiMap<String, Integer>> collector = 618 ImmutableBiMap.toImmutableBiMap(Entry::getKey, Entry::getValue); 619 Equivalence<ImmutableBiMap<String, Integer>> equivalence = 620 Equivalence.equals() 621 .<Entry<String, Integer>>pairwise() 622 .onResultOf(ImmutableBiMap::entrySet); 623 CollectorTester.of(collector, equivalence) 624 .expectCollects( 625 ImmutableBiMap.of("one", 1, "two", 2, "three", 3), 626 mapEntry("one", 1), 627 mapEntry("two", 2), 628 mapEntry("three", 3)); 629 } 630 testToImmutableBiMap_exceptionOnDuplicateKey()631 public void testToImmutableBiMap_exceptionOnDuplicateKey() { 632 Collector<Entry<String, Integer>, ?, ImmutableBiMap<String, Integer>> collector = 633 ImmutableBiMap.toImmutableBiMap(Entry::getKey, Entry::getValue); 634 try { 635 Stream.of(mapEntry("one", 1), mapEntry("one", 11)).collect(collector); 636 fail("Expected IllegalArgumentException"); 637 } catch (IllegalArgumentException expected) { 638 } 639 } 640 641 // BiMap-specific tests 642 643 @SuppressWarnings("DoNotCall") testForcePut()644 public void testForcePut() { 645 BiMap<String, Integer> bimap = ImmutableBiMap.copyOf(ImmutableMap.of("one", 1, "two", 2)); 646 try { 647 bimap.forcePut("three", 3); 648 fail(); 649 } catch (UnsupportedOperationException expected) { 650 } 651 } 652 testKeySet()653 public void testKeySet() { 654 ImmutableBiMap<String, Integer> bimap = 655 ImmutableBiMap.copyOf(ImmutableMap.of("one", 1, "two", 2, "three", 3, "four", 4)); 656 Set<String> keys = bimap.keySet(); 657 assertEquals(Sets.newHashSet("one", "two", "three", "four"), keys); 658 assertThat(keys).containsExactly("one", "two", "three", "four").inOrder(); 659 } 660 testValues()661 public void testValues() { 662 ImmutableBiMap<String, Integer> bimap = 663 ImmutableBiMap.copyOf(ImmutableMap.of("one", 1, "two", 2, "three", 3, "four", 4)); 664 Set<Integer> values = bimap.values(); 665 assertEquals(Sets.newHashSet(1, 2, 3, 4), values); 666 assertThat(values).containsExactly(1, 2, 3, 4).inOrder(); 667 } 668 testDoubleInverse()669 public void testDoubleInverse() { 670 ImmutableBiMap<String, Integer> bimap = 671 ImmutableBiMap.copyOf(ImmutableMap.of("one", 1, "two", 2)); 672 assertSame(bimap, bimap.inverse().inverse()); 673 } 674 675 @J2ktIncompatible 676 @GwtIncompatible // SerializableTester testEmptySerialization()677 public void testEmptySerialization() { 678 ImmutableBiMap<String, Integer> bimap = ImmutableBiMap.of(); 679 assertSame(bimap, SerializableTester.reserializeAndAssert(bimap)); 680 } 681 682 @J2ktIncompatible 683 @GwtIncompatible // SerializableTester testSerialization()684 public void testSerialization() { 685 ImmutableBiMap<String, Integer> bimap = 686 ImmutableBiMap.copyOf(ImmutableMap.of("one", 1, "two", 2)); 687 ImmutableBiMap<String, Integer> copy = SerializableTester.reserializeAndAssert(bimap); 688 assertEquals(Integer.valueOf(1), copy.get("one")); 689 assertEquals("one", copy.inverse().get(1)); 690 assertSame(copy, copy.inverse().inverse()); 691 } 692 693 @J2ktIncompatible 694 @GwtIncompatible // SerializableTester testInverseSerialization()695 public void testInverseSerialization() { 696 ImmutableBiMap<String, Integer> bimap = 697 ImmutableBiMap.copyOf(ImmutableMap.of(1, "one", 2, "two")).inverse(); 698 ImmutableBiMap<String, Integer> copy = SerializableTester.reserializeAndAssert(bimap); 699 assertEquals(Integer.valueOf(1), copy.get("one")); 700 assertEquals("one", copy.inverse().get(1)); 701 assertSame(copy, copy.inverse().inverse()); 702 } 703 assertMapEquals(Map<K, V> map, Object... alternatingKeysAndValues)704 private static <K, V> void assertMapEquals(Map<K, V> map, Object... alternatingKeysAndValues) { 705 Map<Object, Object> expected = new LinkedHashMap<>(); 706 for (int i = 0; i < alternatingKeysAndValues.length; i += 2) { 707 expected.put(alternatingKeysAndValues[i], alternatingKeysAndValues[i + 1]); 708 } 709 assertThat(map).containsExactlyEntriesIn(expected).inOrder(); 710 } 711 712 /** No-op test so that the class has at least one method, making Maven's test runner happy. */ testNoop()713 public void testNoop() {} 714 } 715