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