11d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert/* 21d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * Copyright (C) 2007 The Guava Authors 31d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * 41d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * Licensed under the Apache License, Version 2.0 (the "License"); 51d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * you may not use this file except in compliance with the License. 61d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * You may obtain a copy of the License at 71d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * 81d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * http://www.apache.org/licenses/LICENSE-2.0 91d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * 101d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * Unless required by applicable law or agreed to in writing, software 111d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * distributed under the License is distributed on an "AS IS" BASIS, 121d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 131d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * See the License for the specific language governing permissions and 141d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * limitations under the License. 151d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert */ 161d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 171d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertpackage com.google.common.collect; 181d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 191d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport static com.google.common.collect.Maps.transformEntries; 201d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport static com.google.common.collect.testing.testers.CollectionIteratorTester.getIteratorUnknownOrderRemoveSupportedMethod; 211d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport static org.junit.contrib.truth.Truth.ASSERT; 221d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 231d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport com.google.common.annotations.GwtCompatible; 241d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport com.google.common.annotations.GwtIncompatible; 251d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport com.google.common.base.Equivalence; 261d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport com.google.common.base.Equivalences; 271d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport com.google.common.base.Function; 281d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport com.google.common.base.Functions; 291d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport com.google.common.base.Predicate; 301d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport com.google.common.base.Predicates; 311d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport com.google.common.collect.Maps.EntryTransformer; 321d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport com.google.common.collect.Maps.ValueDifferenceImpl; 331d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport com.google.common.collect.SetsTest.Derived; 341d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport com.google.common.collect.testing.MapTestSuiteBuilder; 351d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport com.google.common.collect.testing.SortedMapInterfaceTest; 361d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport com.google.common.collect.testing.TestStringMapGenerator; 371d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport com.google.common.collect.testing.features.CollectionSize; 381d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport com.google.common.collect.testing.features.MapFeature; 391d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport com.google.common.testing.EqualsTester; 401d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport com.google.common.testing.NullPointerTester; 411d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 421d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport junit.framework.Test; 431d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport junit.framework.TestCase; 441d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport junit.framework.TestSuite; 451d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 461d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport java.io.IOException; 471d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport java.lang.reflect.Field; 481d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport java.util.Arrays; 491d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport java.util.Collections; 501d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport java.util.Comparator; 511d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport java.util.EnumMap; 521d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport java.util.Enumeration; 531d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport java.util.HashMap; 541d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport java.util.IdentityHashMap; 551d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport java.util.Iterator; 561d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport java.util.LinkedHashMap; 571d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport java.util.List; 581d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport java.util.Map; 591d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport java.util.Map.Entry; 601d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport java.util.Properties; 611d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport java.util.Set; 621d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport java.util.SortedMap; 631d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport java.util.TreeMap; 641d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertimport java.util.concurrent.ConcurrentMap; 651d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 661d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert/** 671d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * Unit test for {@code Maps}. 681d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * 691d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * @author Kevin Bourrillion 701d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * @author Mike Bostock 711d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * @author Jared Levy 721d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert */ 731d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert@GwtCompatible(emulated = true) 741d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringertpublic class MapsTest extends TestCase { 751d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 761d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert private static final Comparator<Integer> SOME_COMPARATOR = 771d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Collections.reverseOrder(); 781d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 791d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testHashMap() { 801d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert HashMap<Integer, Integer> map = Maps.newHashMap(); 811d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(Collections.emptyMap(), map); 821d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 831d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 841d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testHashMapWithInitialMap() { 851d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> original = new TreeMap<String, Integer>(); 861d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert original.put("a", 1); 871d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert original.put("b", 2); 881d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert original.put("c", 3); 891d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert HashMap<String, Integer> map = Maps.newHashMap(original); 901d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(original, map); 911d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 921d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 931d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testHashMapGeneralizesTypes() { 941d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> original = new TreeMap<String, Integer>(); 951d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert original.put("a", 1); 961d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert original.put("b", 2); 971d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert original.put("c", 3); 981d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert HashMap<Object, Object> map = 991d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.newHashMap((Map<? extends Object, ? extends Object>) original); 1001d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(original, map); 1011d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 1021d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1031d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testCapacityForNegativeSizeFails() { 1041d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 1051d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.capacity(-1); 1061d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail("Negative expected size must result in IllegalArgumentException"); 1071d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (IllegalArgumentException ex) { 1081d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 1091d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 1101d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1111d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert /** 1121d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * Tests that nHMWES makes hash maps large enough that adding the expected 1131d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * number of elements won't cause a rehash. 1141d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * 1151d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * This test may fail miserably on non-OpenJDK environments... 1161d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert */ 1171d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @GwtIncompatible("reflection") 1181d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testNewHashMapWithExpectedSize_wontGrow() throws Exception { 1191d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert for (int size = 0; size < 200; size++) { 1201d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert HashMap<Integer, Void> map1 = Maps.newHashMapWithExpectedSize(size); 1211d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1221d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert int startSize = sizeOf(map1); 1231d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1241d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert for (int i = 0; i < size; i++) { 1251d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map1.put(i, null); 1261d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 1271d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("table size after adding " + size + "elements", 1281d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert startSize, sizeOf(map1)); 1291d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1301d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert /* 1311d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * Something slightly different happens when the entries are added all at 1321d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * once; make sure that passes too. 1331d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert */ 1341d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert HashMap<Integer, Void> map2 = Maps.newHashMapWithExpectedSize(size); 1351d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map2.putAll(map1); 1361d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("table size after adding " + size + "elements", 1371d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert startSize, sizeOf(map2)); 1381d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 1391d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 1401d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1411d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @GwtIncompatible("reflection") 1421d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert private static int sizeOf(HashMap<?, ?> hashMap) throws Exception { 1431d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Field tableField = HashMap.class.getDeclaredField("table"); 1441d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert tableField.setAccessible(true); 1451d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Object[] table = (Object[]) tableField.get(hashMap); 1461d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return table.length; 1471d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 1481d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1491d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testCapacityForLargeSizes() { 1501d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert int[] largeExpectedSizes = new int[] { 1511d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Integer.MAX_VALUE / 2 - 1, 1521d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Integer.MAX_VALUE / 2, 1531d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Integer.MAX_VALUE / 2 + 1, 1541d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Integer.MAX_VALUE - 1, 1551d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Integer.MAX_VALUE}; 1561d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert for (int expectedSize : largeExpectedSizes) { 1571d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert int capacity = Maps.capacity(expectedSize); 1581d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertTrue( 1591d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert "capacity (" + capacity + ") must be >= expectedSize (" + expectedSize + ")", 1601d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert capacity >= expectedSize); 1611d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 1621d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 1631d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1641d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testLinkedHashMap() { 1651d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert LinkedHashMap<Integer, Integer> map = Maps.newLinkedHashMap(); 1661d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(Collections.emptyMap(), map); 1671d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 1681d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1691d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @SuppressWarnings("serial") 1701d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testLinkedHashMapWithInitialMap() { 1711d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, String> map = new LinkedHashMap<String, String>() {{ 1721d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert put("Hello", "World"); 1731d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert put("first", "second"); 1741d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert put("polygene", "lubricants"); 1751d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert put("alpha", "betical"); 1761d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }}; 1771d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1781d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert LinkedHashMap<String, String> copy = Maps.newLinkedHashMap(map); 1791d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1801d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Iterator<Entry<String, String>> iter = copy.entrySet().iterator(); 1811d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertTrue(iter.hasNext()); 1821d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Entry<String, String> entry = iter.next(); 1831d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("Hello", entry.getKey()); 1841d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("World", entry.getValue()); 1851d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertTrue(iter.hasNext()); 1861d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1871d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert entry = iter.next(); 1881d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("first", entry.getKey()); 1891d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("second", entry.getValue()); 1901d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertTrue(iter.hasNext()); 1911d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1921d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert entry = iter.next(); 1931d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("polygene", entry.getKey()); 1941d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("lubricants", entry.getValue()); 1951d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertTrue(iter.hasNext()); 1961d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1971d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert entry = iter.next(); 1981d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("alpha", entry.getKey()); 1991d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("betical", entry.getValue()); 2001d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertFalse(iter.hasNext()); 2011d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 2021d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 2031d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testLinkedHashMapGeneralizesTypes() { 2041d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> original = new LinkedHashMap<String, Integer>(); 2051d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert original.put("a", 1); 2061d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert original.put("b", 2); 2071d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert original.put("c", 3); 2081d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert HashMap<Object, Object> map 2091d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert = Maps.<Object, Object>newLinkedHashMap(original); 2101d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(original, map); 2111d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 2121d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 2131d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testIdentityHashMap() { 2141d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert IdentityHashMap<Integer, Integer> map = Maps.newIdentityHashMap(); 2151d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(Collections.emptyMap(), map); 2161d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 2171d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 2181d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testConcurrentMap() { 2191d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ConcurrentMap<Integer, Integer> map = Maps.newConcurrentMap(); 2201d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(Collections.emptyMap(), map); 2211d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 2221d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 2231d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testTreeMap() { 2241d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert TreeMap<Integer, Integer> map = Maps.newTreeMap(); 2251d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(Collections.emptyMap(), map); 2261d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertNull(map.comparator()); 2271d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 2281d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 2291d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testTreeMapDerived() { 2301d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert TreeMap<Derived, Integer> map = Maps.newTreeMap(); 2311d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(Collections.emptyMap(), map); 2321d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map.put(new Derived("foo"), 1); 2331d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map.put(new Derived("bar"), 2); 2341d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(map.keySet()).hasContentsInOrder( 2351d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert new Derived("bar"), new Derived("foo")); 2361d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(map.values()).hasContentsInOrder(2, 1); 2371d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertNull(map.comparator()); 2381d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 2391d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 2401d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testTreeMapNonGeneric() { 2411d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert TreeMap<LegacyComparable, Integer> map = Maps.newTreeMap(); 2421d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(Collections.emptyMap(), map); 2431d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map.put(new LegacyComparable("foo"), 1); 2441d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map.put(new LegacyComparable("bar"), 2); 2451d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(map.keySet()).hasContentsInOrder( 2461d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert new LegacyComparable("bar"), new LegacyComparable("foo")); 2471d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(map.values()).hasContentsInOrder(2, 1); 2481d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertNull(map.comparator()); 2491d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 2501d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 2511d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testTreeMapWithComparator() { 2521d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert TreeMap<Integer, Integer> map = Maps.newTreeMap(SOME_COMPARATOR); 2531d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(Collections.emptyMap(), map); 2541d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertSame(SOME_COMPARATOR, map.comparator()); 2551d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 2561d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 2571d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testTreeMapWithInitialMap() { 2581d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMap<Integer, Integer> map = Maps.newTreeMap(); 2591d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map.put(5, 10); 2601d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map.put(3, 20); 2611d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map.put(1, 30); 2621d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert TreeMap<Integer, Integer> copy = Maps.newTreeMap(map); 2631d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(copy, map); 2641d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertSame(copy.comparator(), map.comparator()); 2651d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 2661d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 2671d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public enum SomeEnum { SOME_INSTANCE } 2681d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 2691d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testEnumMap() { 2701d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert EnumMap<SomeEnum, Integer> map = Maps.newEnumMap(SomeEnum.class); 2711d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(Collections.emptyMap(), map); 2721d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map.put(SomeEnum.SOME_INSTANCE, 0); 2731d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(Collections.singletonMap(SomeEnum.SOME_INSTANCE, 0), map); 2741d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 2751d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 2761d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testEnumMapNullClass() { 2771d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 2781d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.<SomeEnum, Long>newEnumMap((Class<MapsTest.SomeEnum>) null); 2791d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail("no exception thrown"); 2801d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (NullPointerException expected) { 2811d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 2821d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 2831d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 2841d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testEnumMapWithInitialEnumMap() { 2851d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert EnumMap<SomeEnum, Integer> original = Maps.newEnumMap(SomeEnum.class); 2861d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert original.put(SomeEnum.SOME_INSTANCE, 0); 2871d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert EnumMap<SomeEnum, Integer> copy = Maps.newEnumMap(original); 2881d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(original, copy); 2891d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 2901d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 2911d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testEnumMapWithInitialEmptyEnumMap() { 2921d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert EnumMap<SomeEnum, Integer> original = Maps.newEnumMap(SomeEnum.class); 2931d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert EnumMap<SomeEnum, Integer> copy = Maps.newEnumMap(original); 2941d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(original, copy); 2951d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertNotSame(original, copy); 2961d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 2971d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 2981d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testEnumMapWithInitialMap() { 2991d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert HashMap<SomeEnum, Integer> original = Maps.newHashMap(); 3001d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert original.put(SomeEnum.SOME_INSTANCE, 0); 3011d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert EnumMap<SomeEnum, Integer> copy = Maps.newEnumMap(original); 3021d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(original, copy); 3031d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 3041d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 3051d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testEnumMapWithInitialEmptyMap() { 3061d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<SomeEnum, Integer> original = Maps.newHashMap(); 3071d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 3081d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.newEnumMap(original); 3091d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail("Empty map must result in an IllegalArgumentException"); 3101d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (IllegalArgumentException expected) {} 3111d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 3121d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 3131d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @GwtIncompatible("NullPointerTester") 3141d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testNullPointerExceptions() throws Exception { 3151d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert NullPointerTester tester = new NullPointerTester(); 3161d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert tester.setDefault(BiMap.class, ImmutableBiMap.of()); 3171d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert tester.setDefault(EntryTransformer.class, ALWAYS_NULL); 3181d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert tester.setDefault(Equivalence.class, Equivalences.equals()); 3191d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert tester.setDefault(SortedMap.class, Maps.newTreeMap()); 3201d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert tester.ignore(Maps.class.getDeclaredMethod("uniqueIndex", Object.class, Function.class)); 3211d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert tester.testAllPublicStaticMethods(Maps.class); 3221d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 3231d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 3241d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert private static final EntryTransformer<Object, Object, Object> ALWAYS_NULL = 3251d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert new EntryTransformer<Object, Object, Object>() { 3261d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 3271d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public Object transformEntry(Object k, Object v1) { 3281d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return null; 3291d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 3301d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }; 3311d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 3321d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert private static final Map<Integer, Integer> EMPTY 3331d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert = Collections.emptyMap(); 3341d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert private static final Map<Integer, Integer> SINGLETON 3351d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert = Collections.singletonMap(1, 2); 3361d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 3371d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testMapDifferenceEmptyEmpty() { 3381d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapDifference<Integer, Integer> diff = Maps.difference(EMPTY, EMPTY); 3391d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertTrue(diff.areEqual()); 3401d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(EMPTY, diff.entriesOnlyOnLeft()); 3411d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(EMPTY, diff.entriesOnlyOnRight()); 3421d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(EMPTY, diff.entriesInCommon()); 3431d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(EMPTY, diff.entriesDiffering()); 3441d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("equal", diff.toString()); 3451d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 3461d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 3471d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testMapDifferenceEmptySingleton() { 3481d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapDifference<Integer, Integer> diff = Maps.difference(EMPTY, SINGLETON); 3491d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertFalse(diff.areEqual()); 3501d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(EMPTY, diff.entriesOnlyOnLeft()); 3511d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(SINGLETON, diff.entriesOnlyOnRight()); 3521d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(EMPTY, diff.entriesInCommon()); 3531d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(EMPTY, diff.entriesDiffering()); 3541d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("not equal: only on right={1=2}", diff.toString()); 3551d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 3561d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 3571d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testMapDifferenceSingletonEmpty() { 3581d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapDifference<Integer, Integer> diff = Maps.difference(SINGLETON, EMPTY); 3591d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertFalse(diff.areEqual()); 3601d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(SINGLETON, diff.entriesOnlyOnLeft()); 3611d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(EMPTY, diff.entriesOnlyOnRight()); 3621d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(EMPTY, diff.entriesInCommon()); 3631d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(EMPTY, diff.entriesDiffering()); 3641d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("not equal: only on left={1=2}", diff.toString()); 3651d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 3661d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 3671d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testMapDifferenceTypical() { 3681d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Integer, String> left = ImmutableMap.of( 3691d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1, "a", 2, "b", 3, "c", 4, "d", 5, "e"); 3701d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Integer, String> right = ImmutableMap.of( 3711d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1, "a", 3, "f", 5, "g", 6, "z"); 3721d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 3731d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapDifference<Integer, String> diff1 = Maps.difference(left, right); 3741d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertFalse(diff1.areEqual()); 3751d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of(2, "b", 4, "d"), diff1.entriesOnlyOnLeft()); 3761d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of(6, "z"), diff1.entriesOnlyOnRight()); 3771d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of(1, "a"), diff1.entriesInCommon()); 3781d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of(3, 3791d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ValueDifferenceImpl.create("c", "f"), 5, 3801d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ValueDifferenceImpl.create("e", "g")), 3811d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert diff1.entriesDiffering()); 3821d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("not equal: only on left={2=b, 4=d}: only on right={6=z}: " 3831d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert + "value differences={3=(c, f), 5=(e, g)}", diff1.toString()); 3841d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 3851d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapDifference<Integer, String> diff2 = Maps.difference(right, left); 3861d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertFalse(diff2.areEqual()); 3871d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of(6, "z"), diff2.entriesOnlyOnLeft()); 3881d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of(2, "b", 4, "d"), diff2.entriesOnlyOnRight()); 3891d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of(1, "a"), diff2.entriesInCommon()); 3901d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of(3, 3911d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ValueDifferenceImpl.create("f", "c"), 5, 3921d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ValueDifferenceImpl.create("g", "e")), 3931d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert diff2.entriesDiffering()); 3941d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("not equal: only on left={6=z}: only on right={2=b, 4=d}: " 3951d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert + "value differences={3=(f, c), 5=(g, e)}", diff2.toString()); 3961d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 3971d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 3981d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testMapDifferenceEquals() { 3991d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Integer, String> left = ImmutableMap.of( 4001d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1, "a", 2, "b", 3, "c", 4, "d", 5, "e"); 4011d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Integer, String> right = ImmutableMap.of( 4021d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1, "a", 3, "f", 5, "g", 6, "z"); 4031d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Integer, String> right2 = ImmutableMap.of( 4041d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1, "a", 3, "h", 5, "g", 6, "z"); 4051d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapDifference<Integer, String> original = Maps.difference(left, right); 4061d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapDifference<Integer, String> same = Maps.difference(left, right); 4071d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapDifference<Integer, String> reverse = Maps.difference(right, left); 4081d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapDifference<Integer, String> diff2 = Maps.difference(left, right2); 4091d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 4101d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert new EqualsTester() 4111d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .addEqualityGroup(original, same) 4121d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .addEqualityGroup(reverse) 4131d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .addEqualityGroup(diff2) 4141d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .testEquals(); 4151d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 4161d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 4171d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testMapDifferencePredicateTypical() { 4181d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Integer, String> left = ImmutableMap.of( 4191d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1, "a", 2, "b", 3, "c", 4, "d", 5, "e"); 4201d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Integer, String> right = ImmutableMap.of( 4211d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 1, "A", 3, "F", 5, "G", 6, "Z"); 4221d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 4231d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // TODO(kevinb): replace with Ascii.caseInsensitiveEquivalence() when it 4241d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // exists 4251d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Equivalence<String> caseInsensitiveEquivalence = Equivalences.equals().onResultOf( 4261d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert new Function<String, String>() { 4271d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override public String apply(String input) { 4281d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return input.toLowerCase(); 4291d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 4301d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }); 4311d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 4321d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapDifference<Integer, String> diff1 = Maps.difference(left, right, 4331d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert caseInsensitiveEquivalence); 4341d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertFalse(diff1.areEqual()); 4351d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of(2, "b", 4, "d"), diff1.entriesOnlyOnLeft()); 4361d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of(6, "Z"), diff1.entriesOnlyOnRight()); 4371d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of(1, "a"), diff1.entriesInCommon()); 4381d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of(3, 4391d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ValueDifferenceImpl.create("c", "F"), 5, 4401d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ValueDifferenceImpl.create("e", "G")), 4411d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert diff1.entriesDiffering()); 4421d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("not equal: only on left={2=b, 4=d}: only on right={6=Z}: " 4431d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert + "value differences={3=(c, F), 5=(e, G)}", diff1.toString()); 4441d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 4451d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapDifference<Integer, String> diff2 = Maps.difference(right, left, 4461d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert caseInsensitiveEquivalence); 4471d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertFalse(diff2.areEqual()); 4481d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of(6, "Z"), diff2.entriesOnlyOnLeft()); 4491d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of(2, "b", 4, "d"), diff2.entriesOnlyOnRight()); 4501d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of(1, "A"), diff2.entriesInCommon()); 4511d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of(3, 4521d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ValueDifferenceImpl.create("F", "c"), 5, 4531d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ValueDifferenceImpl.create("G", "e")), 4541d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert diff2.entriesDiffering()); 4551d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("not equal: only on left={6=Z}: only on right={2=b, 4=d}: " 4561d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert + "value differences={3=(F, c), 5=(G, e)}", diff2.toString()); 4571d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 4581d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 4591d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert private static final SortedMap<Integer, Integer> SORTED_EMPTY = Maps.newTreeMap(); 4601d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert private static final SortedMap<Integer, Integer> SORTED_SINGLETON = 4611d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ImmutableSortedMap.of(1, 2); 4621d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 4631d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testMapDifferenceOfSortedMapIsSorted() { 4641d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Integer, Integer> map = SORTED_SINGLETON; 4651d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapDifference<Integer, Integer> difference = Maps.difference(map, EMPTY); 4661d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertTrue(difference instanceof SortedMapDifference); 4671d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 4681d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 4691d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testSortedMapDifferenceEmptyEmpty() { 4701d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMapDifference<Integer, Integer> diff = 4711d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.difference(SORTED_EMPTY, SORTED_EMPTY); 4721d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertTrue(diff.areEqual()); 4731d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(SORTED_EMPTY, diff.entriesOnlyOnLeft()); 4741d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(SORTED_EMPTY, diff.entriesOnlyOnRight()); 4751d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(SORTED_EMPTY, diff.entriesInCommon()); 4761d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(SORTED_EMPTY, diff.entriesDiffering()); 4771d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("equal", diff.toString()); 4781d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 4791d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 4801d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testSortedMapDifferenceEmptySingleton() { 4811d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMapDifference<Integer, Integer> diff = 4821d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.difference(SORTED_EMPTY, SORTED_SINGLETON); 4831d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertFalse(diff.areEqual()); 4841d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(SORTED_EMPTY, diff.entriesOnlyOnLeft()); 4851d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(SORTED_SINGLETON, diff.entriesOnlyOnRight()); 4861d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(SORTED_EMPTY, diff.entriesInCommon()); 4871d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(SORTED_EMPTY, diff.entriesDiffering()); 4881d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("not equal: only on right={1=2}", diff.toString()); 4891d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 4901d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 4911d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testSortedMapDifferenceSingletonEmpty() { 4921d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMapDifference<Integer, Integer> diff = 4931d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.difference(SORTED_SINGLETON, SORTED_EMPTY); 4941d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertFalse(diff.areEqual()); 4951d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(SORTED_SINGLETON, diff.entriesOnlyOnLeft()); 4961d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(SORTED_EMPTY, diff.entriesOnlyOnRight()); 4971d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(SORTED_EMPTY, diff.entriesInCommon()); 4981d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(SORTED_EMPTY, diff.entriesDiffering()); 4991d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("not equal: only on left={1=2}", diff.toString()); 5001d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 5011d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 5021d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testSortedMapDifferenceTypical() { 5031d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMap<Integer, String> left = 5041d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ImmutableSortedMap.<Integer, String>reverseOrder() 5051d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .put(1, "a").put(2, "b").put(3, "c").put(4, "d").put(5, "e") 5061d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .build(); 5071d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 5081d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMap<Integer, String> right = 5091d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ImmutableSortedMap.of(1, "a", 3, "f", 5, "g", 6, "z"); 5101d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 5111d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMapDifference<Integer, String> diff1 = 5121d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.difference(left, right); 5131d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertFalse(diff1.areEqual()); 5141d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(diff1.entriesOnlyOnLeft().entrySet()).hasContentsInOrder( 5151d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.immutableEntry(4, "d"), Maps.immutableEntry(2, "b")); 5161d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(diff1.entriesOnlyOnRight().entrySet()).hasContentsInOrder( 5171d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.immutableEntry(6, "z")); 5181d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(diff1.entriesInCommon().entrySet()).hasContentsInOrder( 5191d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.immutableEntry(1, "a")); 5201d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(diff1.entriesDiffering().entrySet()).hasContentsInOrder( 5211d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.immutableEntry(5, ValueDifferenceImpl.create("e", "g")), 5221d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.immutableEntry(3, ValueDifferenceImpl.create("c", "f"))); 5231d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("not equal: only on left={4=d, 2=b}: only on right={6=z}: " 5241d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert + "value differences={5=(e, g), 3=(c, f)}", diff1.toString()); 5251d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 5261d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMapDifference<Integer, String> diff2 = 5271d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.difference(right, left); 5281d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertFalse(diff2.areEqual()); 5291d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(diff2.entriesOnlyOnLeft().entrySet()).hasContentsInOrder( 5301d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.immutableEntry(6, "z")); 5311d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(diff2.entriesOnlyOnRight().entrySet()).hasContentsInOrder( 5321d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.immutableEntry(2, "b"), Maps.immutableEntry(4, "d")); 5331d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(diff1.entriesInCommon().entrySet()).hasContentsInOrder( 5341d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.immutableEntry(1, "a")); 5351d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of( 5361d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 3, ValueDifferenceImpl.create("f", "c"), 5371d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 5, ValueDifferenceImpl.create("g", "e")), 5381d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert diff2.entriesDiffering()); 5391d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("not equal: only on left={6=z}: only on right={2=b, 4=d}: " 5401d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert + "value differences={3=(f, c), 5=(g, e)}", diff2.toString()); 5411d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 5421d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 5431d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testSortedMapDifferenceImmutable() { 5441d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMap<Integer, String> left = Maps.newTreeMap( 5451d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ImmutableSortedMap.of(1, "a", 2, "b", 3, "c", 4, "d", 5, "e")); 5461d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMap<Integer, String> right = 5471d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.newTreeMap(ImmutableSortedMap.of(1, "a", 3, "f", 5, "g", 6, "z")); 5481d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 5491d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMapDifference<Integer, String> diff1 = 5501d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.difference(left, right); 5511d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert left.put(6, "z"); 5521d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertFalse(diff1.areEqual()); 5531d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(diff1.entriesOnlyOnLeft().entrySet()).hasContentsInOrder( 5541d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.immutableEntry(2, "b"), Maps.immutableEntry(4, "d")); 5551d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(diff1.entriesOnlyOnRight().entrySet()).hasContentsInOrder( 5561d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.immutableEntry(6, "z")); 5571d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(diff1.entriesInCommon().entrySet()).hasContentsInOrder( 5581d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.immutableEntry(1, "a")); 5591d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(diff1.entriesDiffering().entrySet()).hasContentsInOrder( 5601d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.immutableEntry(3, ValueDifferenceImpl.create("c", "f")), 5611d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.immutableEntry(5, ValueDifferenceImpl.create("e", "g"))); 5621d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 5631d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert diff1.entriesInCommon().put(7, "x"); 5641d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail(); 5651d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (UnsupportedOperationException expected) { 5661d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 5671d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 5681d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert diff1.entriesOnlyOnLeft().put(7, "x"); 5691d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail(); 5701d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (UnsupportedOperationException expected) { 5711d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 5721d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 5731d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert diff1.entriesOnlyOnRight().put(7, "x"); 5741d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail(); 5751d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (UnsupportedOperationException expected) { 5761d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 5771d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 5781d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 5791d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testSortedMapDifferenceEquals() { 5801d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMap<Integer, String> left = 5811d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ImmutableSortedMap.of(1, "a", 2, "b", 3, "c", 4, "d", 5, "e"); 5821d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMap<Integer, String> right = 5831d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ImmutableSortedMap.of(1, "a", 3, "f", 5, "g", 6, "z"); 5841d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMap<Integer, String> right2 = 5851d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ImmutableSortedMap.of(1, "a", 3, "h", 5, "g", 6, "z"); 5861d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMapDifference<Integer, String> original = 5871d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.difference(left, right); 5881d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMapDifference<Integer, String> same = 5891d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.difference(left, right); 5901d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMapDifference<Integer, String> reverse = 5911d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.difference(right, left); 5921d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMapDifference<Integer, String> diff2 = 5931d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.difference(left, right2); 5941d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 5951d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert new EqualsTester() 5961d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .addEqualityGroup(original, same) 5971d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .addEqualityGroup(reverse) 5981d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .addEqualityGroup(diff2) 5991d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .testEquals(); 6001d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 6011d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 6021d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert private static final BiMap<Integer, String> INT_TO_STRING_MAP = 6031d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert new ImmutableBiMap.Builder<Integer, String>() 6041d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .put(1, "one") 6051d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .put(2, "two") 6061d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .put(3, "three") 6071d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .build(); 6081d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 6091d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testUniqueIndexCollection() { 6101d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ImmutableMap<Integer, String> outputMap = 6111d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.uniqueIndex(INT_TO_STRING_MAP.values(), 6121d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Functions.forMap(INT_TO_STRING_MAP.inverse())); 6131d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(INT_TO_STRING_MAP, outputMap); 6141d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 6151d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 6161d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testUniqueIndexIterable() { 6171d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ImmutableMap<Integer, String> outputMap = 6181d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.uniqueIndex(new Iterable<String>() { 6191d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 6201d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public Iterator<String> iterator() { 6211d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return INT_TO_STRING_MAP.values().iterator(); 6221d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 6231d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }, 6241d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Functions.forMap(INT_TO_STRING_MAP.inverse())); 6251d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(INT_TO_STRING_MAP, outputMap); 6261d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 6271d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 6281d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // NOTE: evil, never do this 6291d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert private abstract static class IterableIterator<T> 6301d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert extends ForwardingIterator<T> implements Iterable<T> { 6311d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 6321d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public Iterator<T> iterator() { 6331d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return this; 6341d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 6351d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 6361d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 6371d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @SuppressWarnings("deprecation") // that is the purpose of this test 6381d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testUniqueIndexIterableIterator() { 6391d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ImmutableMap<Integer, String> outputMap = 6401d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.uniqueIndex(new IterableIterator<String>() { 6411d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert private final Iterator<String> iterator = INT_TO_STRING_MAP.values().iterator(); 6421d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 6431d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public Iterator<String> delegate() { 6441d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return iterator; 6451d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 6461d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }, 6471d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Functions.forMap(INT_TO_STRING_MAP.inverse())); 6481d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(INT_TO_STRING_MAP, outputMap); 6491d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 6501d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 6511d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testUniqueIndexIterator() { 6521d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ImmutableMap<Integer, String> outputMap = 6531d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.uniqueIndex(INT_TO_STRING_MAP.values().iterator(), 6541d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Functions.forMap(INT_TO_STRING_MAP.inverse())); 6551d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(INT_TO_STRING_MAP, outputMap); 6561d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 6571d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 6581d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert /** Can't create the map if more than one value maps to the same key. */ 6591d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testUniqueIndexDuplicates() { 6601d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 6611d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.uniqueIndex(ImmutableSet.of("one", "uno"), Functions.constant(1)); 6621d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail(); 6631d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (IllegalArgumentException expected) { 6641d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 6651d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 6661d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 6671d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert /** Null values are not allowed. */ 6681d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testUniqueIndexNullValue() { 6691d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert List<String> listWithNull = Lists.newArrayList((String) null); 6701d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 6711d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.uniqueIndex(listWithNull, Functions.constant(1)); 6721d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail(); 6731d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (NullPointerException expected) { 6741d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 6751d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 6761d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 6771d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert /** Null keys aren't allowed either. */ 6781d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testUniqueIndexNullKey() { 6791d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert List<String> oneStringList = Lists.newArrayList("foo"); 6801d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 6811d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.uniqueIndex(oneStringList, Functions.constant(null)); 6821d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail(); 6831d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (NullPointerException expected) { 6841d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 6851d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 6861d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 6871d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @GwtIncompatible("Maps.fromProperties") 6881d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @SuppressWarnings("deprecation") // StringBufferInputStream 6891d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testFromProperties() throws IOException { 6901d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Properties testProp = new Properties(); 6911d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 6921d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, String> result = Maps.fromProperties(testProp); 6931d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertTrue(result.isEmpty()); 6941d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert testProp.setProperty("first", "true"); 6951d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 6961d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert result = Maps.fromProperties(testProp); 6971d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("true", result.get("first")); 6981d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(1, result.size()); 6991d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert testProp.setProperty("second", "null"); 7001d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 7011d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert result = Maps.fromProperties(testProp); 7021d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("true", result.get("first")); 7031d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("null", result.get("second")); 7041d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(2, result.size()); 7051d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 7061d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // Now test values loaded from a stream. 7071d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert String props = "test\n second = 2\n Third item : a short phrase "; 7081d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 7091d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // TODO: change to StringReader in Java 1.6 7101d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert testProp.load(new java.io.StringBufferInputStream(props)); 7111d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 7121d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert result = Maps.fromProperties(testProp); 7131d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(4, result.size()); 7141d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("true", result.get("first")); 7151d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("", result.get("test")); 7161d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("2", result.get("second")); 7171d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("item : a short phrase ", result.get("Third")); 7181d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertFalse(result.containsKey("not here")); 7191d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 7201d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // Test loading system properties 7211d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert result = Maps.fromProperties(System.getProperties()); 7221d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertTrue(result.containsKey("java.version")); 7231d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 7241d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // Test that defaults work, too. 7251d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert testProp = new Properties(System.getProperties()); 7261d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert String override = "test\njava.version : hidden"; 7271d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 7281d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // TODO: change to StringReader in Java 1.6 7291d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert testProp.load(new java.io.StringBufferInputStream(override)); 7301d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 7311d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert result = Maps.fromProperties(testProp); 7321d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertTrue(result.size() > 2); 7331d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("", result.get("test")); 7341d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("hidden", result.get("java.version")); 7351d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertNotSame(System.getProperty("java.version"), 7361d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert result.get("java.version")); 7371d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 7381d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 7391d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @GwtIncompatible("Maps.fromProperties") 7401d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @SuppressWarnings("serial") // never serialized 7411d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testFromPropertiesNullKey() { 7421d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Properties properties = new Properties() { 7431d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override public Enumeration<?> propertyNames() { 7441d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return Iterators.asEnumeration( 7451d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Arrays.asList(null, "first", "second").iterator()); 7461d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 7471d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }; 7481d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert properties.setProperty("first", "true"); 7491d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert properties.setProperty("second", "null"); 7501d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 7511d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 7521d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.fromProperties(properties); 7531d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail(); 7541d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (NullPointerException expected) {} 7551d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 7561d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 7571d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @GwtIncompatible("Maps.fromProperties") 7581d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @SuppressWarnings("serial") // never serialized 7591d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testFromPropertiesNonStringKeys() { 7601d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Properties properties = new Properties() { 7611d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override public Enumeration<?> propertyNames() { 7621d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return Iterators.asEnumeration( 7631d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Arrays.<Object>asList(Integer.valueOf(123), "first").iterator()); 7641d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 7651d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }; 7661d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 7671d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 7681d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.fromProperties(properties); 7691d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail(); 7701d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (ClassCastException expected) {} 7711d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 7721d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 7731d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert /** 7741d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * Constructs a "nefarious" map entry with the specified key and value, 7751d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * meaning an entry that is suitable for testing that map entries cannot be 7761d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * modified via a nefarious implementation of equals. This is used for testing 7771d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * unmodifiable collections of map entries; for example, it should not be 7781d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * possible to access the raw (modifiable) map entry via a nefarious equals 7791d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * method. 7801d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert */ 7811d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public static <K, V> Map.Entry<K, V> nefariousEntry( 7821d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert final K key, final V value) { 7831d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return new AbstractMapEntry<K, V>() { 7841d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override public K getKey() { 7851d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return key; 7861d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 7871d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override public V getValue() { 7881d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return value; 7891d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 7901d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override public V setValue(V value) { 7911d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert throw new UnsupportedOperationException(); 7921d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 7931d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @SuppressWarnings("unchecked") 7941d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override public boolean equals(Object o) { 7951d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert if (o instanceof Map.Entry<?, ?>) { 7961d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map.Entry<K, V> e = (Map.Entry<K, V>) o; 7971d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert e.setValue(value); // muhahaha! 7981d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 7991d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return super.equals(o); 8001d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 8011d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }; 8021d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 8031d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 8041d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testUnmodifiableBiMap() { 8051d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert BiMap<Integer, String> mod = HashBiMap.create(); 8061d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert mod.put(1, "one"); 8071d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert mod.put(2, "two"); 8081d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert mod.put(3, "three"); 8091d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 8101d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert BiMap<Number, String> unmod = Maps.<Number, String>unmodifiableBiMap(mod); 8111d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 8121d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert /* No aliasing on inverse operations. */ 8131d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertSame(unmod.inverse(), unmod.inverse()); 8141d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertSame(unmod, unmod.inverse().inverse()); 8151d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 8161d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert /* Unmodifiable is a view. */ 8171d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert mod.put(4, "four"); 8181d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(true, unmod.get(4).equals("four")); 8191d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(true, unmod.inverse().get("four").equals(4)); 8201d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 8211d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert /* UnsupportedOperationException on direct modifications. */ 8221d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 8231d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unmod.put(4, "four"); 8241d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail("UnsupportedOperationException expected"); 8251d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (UnsupportedOperationException expected) {} 8261d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 8271d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unmod.forcePut(4, "four"); 8281d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail("UnsupportedOperationException expected"); 8291d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (UnsupportedOperationException expected) {} 8301d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 8311d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unmod.putAll(Collections.singletonMap(4, "four")); 8321d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail("UnsupportedOperationException expected"); 8331d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (UnsupportedOperationException expected) {} 8341d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 8351d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert /* UnsupportedOperationException on indirect modifications. */ 8361d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert BiMap<String, Number> inverse = unmod.inverse(); 8371d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 8381d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert inverse.put("four", 4); 8391d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail("UnsupportedOperationException expected"); 8401d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (UnsupportedOperationException expected) {} 8411d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 8421d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert inverse.forcePut("four", 4); 8431d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail("UnsupportedOperationException expected"); 8441d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (UnsupportedOperationException expected) {} 8451d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 8461d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert inverse.putAll(Collections.singletonMap("four", 4)); 8471d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail("UnsupportedOperationException expected"); 8481d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (UnsupportedOperationException expected) {} 8491d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Set<String> values = unmod.values(); 8501d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 8511d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert values.remove("four"); 8521d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail("UnsupportedOperationException expected"); 8531d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (UnsupportedOperationException expected) {} 8541d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Set<Map.Entry<Number, String>> entries = unmod.entrySet(); 8551d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map.Entry<Number, String> entry = entries.iterator().next(); 8561d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 8571d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert entry.setValue("four"); 8581d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail("UnsupportedOperationException expected"); 8591d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (UnsupportedOperationException expected) {} 8601d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @SuppressWarnings("unchecked") 8611d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map.Entry<Integer, String> entry2 8621d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert = (Map.Entry<Integer, String>) entries.toArray()[0]; 8631d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 8641d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert entry2.setValue("four"); 8651d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail("UnsupportedOperationException expected"); 8661d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (UnsupportedOperationException expected) {} 8671d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 8681d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 8691d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testBiMapEntrySetIteratorRemove() { 8701d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert BiMap<Integer, String> map = HashBiMap.create(); 8711d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map.put(1, "one"); 8721d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Set<Map.Entry<Integer, String>> entries = map.entrySet(); 8731d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Iterator<Map.Entry<Integer, String>> iterator = entries.iterator(); 8741d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map.Entry<Integer, String> entry = iterator.next(); 8751d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert entry.setValue("two"); // changes the iterator's current entry value 8761d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("two", map.get(1)); 8771d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert iterator.remove(); // removes the updated entry 8781d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertTrue(map.isEmpty()); 8791d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 8801d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 8811d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testImmutableEntry() { 8821d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map.Entry<String, Integer> e = Maps.immutableEntry("foo", 1); 8831d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("foo", e.getKey()); 8841d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(1, (int) e.getValue()); 8851d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 8861d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert e.setValue(2); 8871d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail("UnsupportedOperationException expected"); 8881d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (UnsupportedOperationException expected) {} 8891d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("foo=1", e.toString()); 8901d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(101575, e.hashCode()); 8911d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 8921d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 8931d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testImmutableEntryNull() { 8941d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map.Entry<String, Integer> e 8951d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert = Maps.immutableEntry((String) null, (Integer) null); 8961d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertNull(e.getKey()); 8971d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertNull(e.getValue()); 8981d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 8991d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert e.setValue(null); 9001d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail("UnsupportedOperationException expected"); 9011d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (UnsupportedOperationException expected) {} 9021d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("null=null", e.toString()); 9031d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(0, e.hashCode()); 9041d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 9051d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 9061d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert /** See {@link SynchronizedBiMapTest} for more tests. */ 9071d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testSynchronizedBiMap() { 9081d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert BiMap<String, Integer> bimap = HashBiMap.create(); 9091d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert bimap.put("one", 1); 9101d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert BiMap<String, Integer> sync = Maps.synchronizedBiMap(bimap); 9111d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert bimap.put("two", 2); 9121d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert sync.put("three", 3); 9131d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableSet.of(1, 2, 3), bimap.inverse().keySet()); 9141d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableSet.of(1, 2, 3), sync.inverse().keySet()); 9151d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 9161d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 9171d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert private static final Predicate<String> NOT_LENGTH_3 9181d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert = new Predicate<String>() { 9191d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 9201d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public boolean apply(String input) { 9211d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return input == null || input.length() != 3; 9221d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 9231d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }; 9241d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 9251d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert private static final Predicate<Integer> EVEN 9261d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert = new Predicate<Integer>() { 9271d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 9281d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public boolean apply(Integer input) { 9291d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return input == null || input % 2 == 0; 9301d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 9311d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }; 9321d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 9331d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert private static final Predicate<Entry<String, Integer>> CORRECT_LENGTH 9341d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert = new Predicate<Entry<String, Integer>>() { 9351d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 9361d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public boolean apply(Entry<String, Integer> input) { 9371d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return input.getKey().length() == input.getValue(); 9381d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 9391d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }; 9401d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 9411d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testFilteredKeysIllegalPut() { 9421d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> unfiltered = Maps.newHashMap(); 9431d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> filtered = Maps.filterKeys(unfiltered, NOT_LENGTH_3); 9441d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert filtered.put("a", 1); 9451d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert filtered.put("b", 2); 9461d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("a", 1, "b", 2), filtered); 9471d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 9481d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 9491d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert filtered.put("yyy", 3); 9501d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail(); 9511d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (IllegalArgumentException expected) {} 9521d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 9531d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 9541d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert filtered.putAll(ImmutableMap.of("c", 3, "zzz", 4, "b", 5)); 9551d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail(); 9561d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (IllegalArgumentException expected) {} 9571d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 9581d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("a", 1, "b", 2), filtered); 9591d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 9601d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 9611d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testFilteredKeysChangeFiltered() { 9621d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> unfiltered = Maps.newHashMap(); 9631d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> filtered = Maps.filterKeys(unfiltered, NOT_LENGTH_3); 9641d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("two", 2); 9651d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("three", 3); 9661d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("four", 4); 9671d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("two", 2, "three", 3, "four", 4), unfiltered); 9681d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("three", 3, "four", 4), filtered); 9691d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 9701d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.remove("three"); 9711d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("two", 2, "four", 4), unfiltered); 9721d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("four", 4), filtered); 9731d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 9741d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.clear(); 9751d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of(), unfiltered); 9761d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of(), filtered); 9771d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 9781d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 9791d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testFilteredKeysChangeUnfiltered() { 9801d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> unfiltered = Maps.newHashMap(); 9811d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> filtered = Maps.filterKeys(unfiltered, NOT_LENGTH_3); 9821d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("two", 2); 9831d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("three", 3); 9841d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("four", 4); 9851d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("two", 2, "three", 3, "four", 4), unfiltered); 9861d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("three", 3, "four", 4), filtered); 9871d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 9881d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert filtered.remove("three"); 9891d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("two", 2, "four", 4), unfiltered); 9901d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("four", 4), filtered); 9911d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 9921d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert filtered.clear(); 9931d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("two", 2), unfiltered); 9941d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of(), filtered); 9951d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 9961d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 9971d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testFilteredValuesIllegalPut() { 9981d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> unfiltered = Maps.newHashMap(); 9991d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> filtered = Maps.filterValues(unfiltered, EVEN); 10001d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert filtered.put("a", 2); 10011d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("b", 4); 10021d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("c", 5); 10031d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("a", 2, "b", 4), filtered); 10041d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 10051d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 10061d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert filtered.put("yyy", 3); 10071d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail(); 10081d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (IllegalArgumentException expected) {} 10091d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 10101d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 10111d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert filtered.putAll(ImmutableMap.of("c", 4, "zzz", 5, "b", 6)); 10121d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail(); 10131d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (IllegalArgumentException expected) {} 10141d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 10151d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("a", 2, "b", 4), filtered); 10161d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 10171d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 10181d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testFilteredValuesIllegalSetValue() { 10191d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> unfiltered = Maps.newHashMap(); 10201d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> filtered = Maps.filterValues(unfiltered, EVEN); 10211d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert filtered.put("a", 2); 10221d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert filtered.put("b", 4); 10231d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("a", 2, "b", 4), filtered); 10241d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 10251d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Entry<String, Integer> entry = filtered.entrySet().iterator().next(); 10261d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 10271d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert entry.setValue(5); 10281d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail(); 10291d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (IllegalArgumentException expected) {} 10301d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 10311d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("a", 2, "b", 4), filtered); 10321d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 10331d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 10341d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testFilteredValuesClear() { 10351d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> unfiltered = Maps.newHashMap(); 10361d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("one", 1); 10371d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("two", 2); 10381d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("three", 3); 10391d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("four", 4); 10401d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> filtered = Maps.filterValues(unfiltered, EVEN); 10411d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("one", 1, "two", 2, "three", 3, "four", 4), 10421d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered); 10431d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("two", 2, "four", 4), filtered); 10441d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 10451d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert filtered.clear(); 10461d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("one", 1, "three", 3), unfiltered); 10471d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertTrue(filtered.isEmpty()); 10481d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 10491d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 10501d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testFilteredEntriesIllegalPut() { 10511d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> unfiltered = Maps.newHashMap(); 10521d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("cat", 3); 10531d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("dog", 2); 10541d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("horse", 5); 10551d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> filtered 10561d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert = Maps.filterEntries(unfiltered, CORRECT_LENGTH); 10571d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("cat", 3, "horse", 5), filtered); 10581d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 10591d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert filtered.put("chicken", 7); 10601d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("cat", 3, "horse", 5, "chicken", 7), filtered); 10611d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 10621d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 10631d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert filtered.put("cow", 7); 10641d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail(); 10651d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (IllegalArgumentException expected) {} 10661d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("cat", 3, "horse", 5, "chicken", 7), filtered); 10671d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 10681d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 10691d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert filtered.putAll(ImmutableMap.of("sheep", 5, "cow", 7)); 10701d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert fail(); 10711d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (IllegalArgumentException expected) {} 10721d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("cat", 3, "horse", 5, "chicken", 7), filtered); 10731d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 10741d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 10751d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testFilteredEntriesObjectPredicate() { 10761d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> unfiltered = Maps.newHashMap(); 10771d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("cat", 3); 10781d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("dog", 2); 10791d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("horse", 5); 10801d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Predicate<Object> predicate = Predicates.alwaysFalse(); 10811d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> filtered 10821d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert = Maps.filterEntries(unfiltered, predicate); 10831d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertTrue(filtered.isEmpty()); 10841d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 10851d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 10861d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testFilteredEntriesWildCardEntryPredicate() { 10871d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> unfiltered = Maps.newHashMap(); 10881d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("cat", 3); 10891d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("dog", 2); 10901d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put("horse", 5); 10911d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Predicate<Entry<?, ?>> predicate = new Predicate<Entry<?, ?>>() { 10921d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 10931d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public boolean apply(Entry<?, ?> input) { 10941d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return "cat".equals(input.getKey()) 10951d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert || Integer.valueOf(2) == input.getValue(); 10961d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 10971d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }; 10981d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> filtered 10991d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert = Maps.filterEntries(unfiltered, predicate); 11001d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("cat", 3, "dog", 2), filtered); 11011d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 11021d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 11031d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testTransformValues() { 11041d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> map = ImmutableMap.of("a", 4, "b", 9); 11051d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Function<Integer, Double> sqrt = new Function<Integer, Double>() { 11061d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 11071d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public Double apply(Integer in) { 11081d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return Math.sqrt(in); 11091d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 11101d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }; 11111d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Double> transformed = Maps.transformValues(map, sqrt); 11121d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 11131d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("a", 2.0, "b", 3.0), transformed); 11141d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 11151d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 11161d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testTransformValuesSecretlySorted() { 11171d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Integer> map = ImmutableSortedMap.of("a", 4, "b", 9); 11181d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Function<Integer, Double> sqrt = new Function<Integer, Double>() { 11191d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 11201d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public Double apply(Integer in) { 11211d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return Math.sqrt(in); 11221d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 11231d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }; 11241d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Double> transformed = Maps.transformValues(map, sqrt); 11251d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 11261d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("a", 2.0, "b", 3.0), transformed); 11271d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertTrue(transformed instanceof SortedMap); 11281d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 11291d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 11301d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testTransformEntries() { 11311d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, String> map = ImmutableMap.of("a", "4", "b", "9"); 11321d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert EntryTransformer<String, String, String> concat = 11331d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert new EntryTransformer<String, String, String>() { 11341d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 11351d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public String transformEntry(String key, String value) { 11361d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return key + value; 11371d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 11381d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }; 11391d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, String> transformed = Maps.transformEntries(map, concat); 11401d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 11411d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("a", "a4", "b", "b9"), transformed); 11421d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 11431d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 11441d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testTransformEntriesSecretlySorted() { 11451d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, String> map = ImmutableSortedMap.of("a", "4", "b", "9"); 11461d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert EntryTransformer<String, String, String> concat = 11471d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert new EntryTransformer<String, String, String>() { 11481d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 11491d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public String transformEntry(String key, String value) { 11501d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return key + value; 11511d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 11521d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }; 11531d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, String> transformed = Maps.transformEntries(map, concat); 11541d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 11551d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableMap.of("a", "a4", "b", "b9"), transformed); 11561d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertTrue(transformed instanceof SortedMap); 11571d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 11581d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 11591d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testTransformEntriesGenerics() { 11601d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Object, Object> map1 = ImmutableMap.<Object, Object>of(1, 2); 11611d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Object, Number> map2 = ImmutableMap.<Object, Number>of(1, 2); 11621d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Object, Integer> map3 = ImmutableMap.<Object, Integer>of(1, 2); 11631d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Number, Object> map4 = ImmutableMap.<Number, Object>of(1, 2); 11641d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Number, Number> map5 = ImmutableMap.<Number, Number>of(1, 2); 11651d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Number, Integer> map6 = ImmutableMap.<Number, Integer>of(1, 2); 11661d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Integer, Object> map7 = ImmutableMap.<Integer, Object>of(1, 2); 11671d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Integer, Number> map8 = ImmutableMap.<Integer, Number>of(1, 2); 11681d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Integer, Integer> map9 = ImmutableMap.<Integer, Integer>of(1, 2); 11691d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<? extends Number, ? extends Number> map0 = ImmutableMap.of(1, 2); 11701d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 11711d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert EntryTransformer<Number, Number, Double> transformer = 11721d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert new EntryTransformer<Number, Number, Double>() { 11731d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 11741d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public Double transformEntry(Number key, Number value) { 11751d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return key.doubleValue() + value.doubleValue(); 11761d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 11771d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }; 11781d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 11791d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Object, Double> objectKeyed; 11801d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Number, Double> numberKeyed; 11811d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<Integer, Double> integerKeyed; 11821d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 11831d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert numberKeyed = transformEntries(map5, transformer); 11841d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert numberKeyed = transformEntries(map6, transformer); 11851d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert integerKeyed = transformEntries(map8, transformer); 11861d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert integerKeyed = transformEntries(map9, transformer); 11871d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 11881d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<? extends Number, Double> wildcarded = transformEntries(map0, transformer); 11891d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 11901d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // Can't loosen the key type: 11911d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // objectKeyed = transformEntries(map5, transformer); 11921d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // objectKeyed = transformEntries(map6, transformer); 11931d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // objectKeyed = transformEntries(map8, transformer); 11941d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // objectKeyed = transformEntries(map9, transformer); 11951d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // numberKeyed = transformEntries(map8, transformer); 11961d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // numberKeyed = transformEntries(map9, transformer); 11971d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 11981d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // Can't loosen the value type: 11991d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // Map<Number, Number> looseValued1 = transformEntries(map5, transformer); 12001d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // Map<Number, Number> looseValued2 = transformEntries(map6, transformer); 12011d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // Map<Integer, Number> looseValued3 = transformEntries(map8, transformer); 12021d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // Map<Integer, Number> looseValued4 = transformEntries(map9, transformer); 12031d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 12041d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // Can't call with too loose a key: 12051d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // transformEntries(map1, transformer); 12061d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // transformEntries(map2, transformer); 12071d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // transformEntries(map3, transformer); 12081d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 12091d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // Can't call with too loose a value: 12101d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // transformEntries(map1, transformer); 12111d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // transformEntries(map4, transformer); 12121d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // transformEntries(map7, transformer); 12131d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 12141d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 12151d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testTransformEntriesExample() { 12161d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, Boolean> options = 12171d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ImmutableMap.of("verbose", true, "sort", false); 12181d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert EntryTransformer<String, Boolean, String> flagPrefixer = 12191d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert new EntryTransformer<String, Boolean, String>() { 12201d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 12211d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public String transformEntry(String key, Boolean value) { 12221d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return value ? key : "no" + key; 12231d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 12241d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }; 12251d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, String> transformed = 12261d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.transformEntries(options, flagPrefixer); 12271d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals("{verbose=verbose, sort=nosort}", transformed.toString()); 12281d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 12291d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 12301d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // TestStringMapGenerator uses entries of the form "one=January" and so forth. 12311d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // To test the filtered collections, we'll create a map containing the entries 12321d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // they ask for, plus some bogus numeric entries. Then our predicates will 12331d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // simply filter numeric entries back out. 12341d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 12351d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert private static ImmutableMap<String, String> ENTRIES_TO_FILTER_OUT = 12361d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert new ImmutableMap.Builder<String, String>() 12371d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .put("0", "0") 12381d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .put("1", "1") 12391d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .put("2", "2") 12401d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .build(); 12411d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 12421d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @GwtIncompatible("suite") 12431d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public static class FilteredMapTests extends TestCase { 12441d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public static Test suite() { 12451d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert TestSuite suite = new TestSuite(); 12461d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 12471d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert suite.addTest(MapTestSuiteBuilder.using( 12481d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert new TestStringMapGenerator() { 12491d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override protected Map<String, String> create( 12501d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Entry<String, String>[] entries) { 12511d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, String> map = Maps.newHashMap(); 12521d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert for (Entry<String, String> entry : entries) { 12531d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map.put(entry.getKey(), entry.getValue()); 12541d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 12551d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map.putAll(ENTRIES_TO_FILTER_OUT); 12561d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return Maps.filterKeys(map, new Predicate<String>() { 12571d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 12581d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public boolean apply(String input) { 12591d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return input == null 12601d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert || (input.charAt(0) >= 'a' && input.charAt(0) <= 'z'); 12611d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 12621d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }); 12631d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 12641d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }) 12651d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .named("Maps.filterKeys") 12661d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .withFeatures( 12671d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert CollectionSize.ANY, 12681d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapFeature.ALLOWS_NULL_KEYS, 12691d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapFeature.ALLOWS_NULL_VALUES, 12701d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapFeature.GENERAL_PURPOSE) 12711d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .suppressing(getIteratorUnknownOrderRemoveSupportedMethod()) 12721d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .createTestSuite()); 12731d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 12741d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert suite.addTest(MapTestSuiteBuilder.using( 12751d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert new TestStringMapGenerator() { 12761d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override protected Map<String, String> create( 12771d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Entry<String, String>[] entries) { 12781d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, String> map = Maps.newHashMap(); 12791d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert for (Entry<String, String> entry : entries) { 12801d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map.put(entry.getKey(), entry.getValue()); 12811d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 12821d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map.putAll(ENTRIES_TO_FILTER_OUT); 12831d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return Maps.filterValues(map, new Predicate<String>() { 12841d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 12851d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public boolean apply(String input) { 12861d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return input == null 12871d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert || (input.charAt(0) >= 'A' && input.charAt(0) <= 'Z'); 12881d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 12891d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }); 12901d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 12911d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }) 12921d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .named("Maps.filterValues") 12931d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .withFeatures( 12941d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert CollectionSize.ANY, 12951d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapFeature.ALLOWS_NULL_KEYS, 12961d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapFeature.ALLOWS_NULL_VALUES, 12971d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapFeature.GENERAL_PURPOSE) 12981d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .suppressing(getIteratorUnknownOrderRemoveSupportedMethod()) 12991d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .createTestSuite()); 13001d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 13011d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert suite.addTest(MapTestSuiteBuilder.using( 13021d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert new TestStringMapGenerator() { 13031d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override protected Map<String, String> create( 13041d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Entry<String, String>[] entries) { 13051d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, String> map = Maps.newHashMap(); 13061d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert for (Entry<String, String> entry : entries) { 13071d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map.put(entry.getKey(), entry.getValue()); 13081d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 13091d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map.putAll(ENTRIES_TO_FILTER_OUT); 13101d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return Maps.filterEntries(map, 13111d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert new Predicate<Entry<String, String>>() { 13121d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 13131d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public boolean apply(Entry<String, String> entry) { 13141d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert String input = entry.getKey(); 13151d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return input == null 13161d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert || (input.charAt(0) >= 'a' && input.charAt(0) <= 'z'); 13171d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 13181d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }); 13191d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 13201d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }) 13211d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .named("Maps.filterEntries") 13221d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .withFeatures( 13231d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert CollectionSize.ANY, 13241d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapFeature.ALLOWS_NULL_KEYS, 13251d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapFeature.ALLOWS_NULL_VALUES, 13261d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapFeature.GENERAL_PURPOSE) 13271d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .suppressing(getIteratorUnknownOrderRemoveSupportedMethod()) 13281d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .createTestSuite()); 13291d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 13301d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert suite.addTest(MapTestSuiteBuilder.using( 13311d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert new TestStringMapGenerator() { 13321d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override protected Map<String, String> create( 13331d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Entry<String, String>[] entries) { 13341d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, String> map = Maps.newHashMap(); 13351d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert for (Entry<String, String> entry : entries) { 13361d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map.put(entry.getKey(), entry.getValue()); 13371d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 13381d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map.putAll(ENTRIES_TO_FILTER_OUT); 13391d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert map.put("", "weird"); 13401d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Map<String, String> withoutEmptyKey = Maps.filterKeys(map, 13411d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert new Predicate<String>() { 13421d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 13431d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public boolean apply(String input) { 13441d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return input == null || input.length() != 0; 13451d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 13461d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }); 13471d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return Maps.filterKeys(withoutEmptyKey, new Predicate<String>() { 13481d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 13491d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public boolean apply(String input) { 13501d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return input == null 13511d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert || (input.charAt(0) >= 'a' && input.charAt(0) <= 'z'); 13521d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 13531d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }); 13541d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // note: these filters were deliberately chosen so that an 13551d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // element somehow getting around the first filter would cause 13561d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // an exception in the second 13571d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 13581d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }) 13591d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .named("Maps.filterKeys, chained") 13601d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .withFeatures( 13611d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert CollectionSize.ANY, 13621d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapFeature.ALLOWS_NULL_KEYS, 13631d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapFeature.ALLOWS_NULL_VALUES, 13641d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert MapFeature.GENERAL_PURPOSE) 13651d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .suppressing(getIteratorUnknownOrderRemoveSupportedMethod()) 13661d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert .createTestSuite()); 13671d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 13681d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return suite; 13691d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 13701d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 13711d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 13721d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testSortedMapTransformValues() { 13731d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMap<String, Integer> map = ImmutableSortedMap.of("a", 4, "b", 9); 13741d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Function<Integer, Double> sqrt = new Function<Integer, Double>() { 13751d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 13761d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public Double apply(Integer in) { 13771d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return Math.sqrt(in); 13781d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 13791d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }; 13801d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMap<String, Double> transformed = 13811d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.transformValues(map, sqrt); 13821d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 13831d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableSortedMap.of("a", 2.0, "b", 3.0), transformed); 13841d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 13851d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 13861d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testSortedMapTransformEntries() { 13871d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMap<String, String> map = ImmutableSortedMap.of("a", "4", "b", "9"); 13881d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert EntryTransformer<String, String, String> concat = 13891d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert new EntryTransformer<String, String, String>() { 13901d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override 13911d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public String transformEntry(String key, String value) { 13921d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return key + value; 13931d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 13941d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }; 13951d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMap<String, String> transformed = 13961d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Maps.transformEntries(map, concat); 13971d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 13981d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals(ImmutableSortedMap.of("a", "a4", "b", "b9"), transformed); 13991d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 14001d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 14011d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert /* 14021d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * Not testing Map methods of Maps.filter*(SortedMap), since the 14031d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * implementation doesn't override Maps.FilteredEntryMap, which is already 14041d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert * tested. 14051d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert */ 14061d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 14071d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testSortedMapFilterKeys() { 14081d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Comparator<Integer> comparator = Ordering.natural(); 14091d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMap<Integer, String> unfiltered = Maps.newTreeMap(comparator); 14101d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(1, "one"); 14111d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(2, "two"); 14121d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(3, "three"); 14131d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(4, "four"); 14141d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(5, "five"); 14151d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(6, "six"); 14161d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(7, "seven"); 14171d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMap<Integer, String> filtered 14181d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert = Maps.filterKeys(unfiltered, EVEN); 14191d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(filtered.keySet()).hasContentsInOrder(2, 4, 6); 14201d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertSame(comparator, filtered.comparator()); 14211d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals((Integer) 2, filtered.firstKey()); 14221d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals((Integer) 6, filtered.lastKey()); 14231d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(filtered.headMap(5).keySet()).hasContentsInOrder(2, 4); 14241d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(filtered.tailMap(3).keySet()).hasContentsInOrder(4, 6); 14251d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(filtered.subMap(3, 5).keySet()).hasContentsInOrder(4); 14261d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 14271d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 14281d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public void testSortedMapFilterValues() { 14291d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert Comparator<Integer> comparator = Ordering.natural(); 14301d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMap<Integer, String> unfiltered = Maps.newTreeMap(comparator); 14311d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(1, "one"); 14321d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(2, "two"); 14331d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(3, "three"); 14341d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(4, "four"); 14351d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(5, "five"); 14361d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(6, "six"); 14371d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(7, "seven"); 14381d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMap<Integer, String> filtered 14391d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert = Maps.filterValues(unfiltered, NOT_LENGTH_3); 14401d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(filtered.keySet()).hasContentsInOrder(3, 4, 5, 7); 14411d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertSame(comparator, filtered.comparator()); 14421d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals((Integer) 3, filtered.firstKey()); 14431d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert assertEquals((Integer) 7, filtered.lastKey()); 14441d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(filtered.headMap(5).keySet()).hasContentsInOrder(3, 4); 14451d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(filtered.tailMap(4).keySet()).hasContentsInOrder(4, 5, 7); 14461d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert ASSERT.that(filtered.subMap(4, 6).keySet()).hasContentsInOrder(4, 5); 14471d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 14481d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 14491d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert private static final Predicate<Map.Entry<Integer, String>> 14501d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert EVEN_AND_LENGTH_3 = new Predicate<Map.Entry<Integer, String>>() { 14511d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override public boolean apply(Entry<Integer, String> entry) { 14521d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return (entry.getKey() == null || entry.getKey() % 2 == 0) 14531d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert && (entry.getValue() == null || entry.getValue().length() == 3); 14541d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 14551d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert }; 14561d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 14571d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert private static class ContainsKeySafeSortedMap 14581d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert extends ForwardingSortedMap<Integer, String> { 14591d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMap<Integer, String> delegate 14601d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert = Maps.newTreeMap(Ordering.natural().nullsFirst()); 14611d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 14621d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override protected SortedMap<Integer, String> delegate() { 14631d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return delegate; 14641d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 14651d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 14661d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // Needed by MapInterfaceTest.testContainsKey() 14671d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override public boolean containsKey(Object key) { 14681d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert try { 14691d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return super.containsKey(key); 14701d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } catch (ClassCastException e) { 14711d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return false; 14721d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 14731d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 14741d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 14751d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 14761d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public static class FilteredEntriesSortedMapInterfaceTest 14771d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert extends SortedMapInterfaceTest<Integer, String> { 14781d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert public FilteredEntriesSortedMapInterfaceTest() { 14791d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert super(true, true, true, true, true); 14801d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 14811d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 14821d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override protected SortedMap<Integer, String> makeEmptyMap() { 14831d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMap<Integer, String> unfiltered = new ContainsKeySafeSortedMap(); 14841d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(1, "one"); 14851d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(3, "three"); 14861d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(4, "four"); 14871d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(5, "five"); 14881d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return Maps.filterEntries(unfiltered, EVEN_AND_LENGTH_3); 14891d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 14901d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 14911d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override protected SortedMap<Integer, String> makePopulatedMap() { 14921d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert SortedMap<Integer, String> unfiltered = new ContainsKeySafeSortedMap(); 14931d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(1, "one"); 14941d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(2, "two"); 14951d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(3, "three"); 14961d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(4, "four"); 14971d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(5, "five"); 14981d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert unfiltered.put(6, "six"); 14991d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return Maps.filterEntries(unfiltered, EVEN_AND_LENGTH_3); 15001d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 15011d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 15021d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override protected Integer getKeyNotInPopulatedMap() { 15031d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return 10; 15041d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 15051d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 15061d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override protected String getValueNotInPopulatedMap() { 15071d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert return "ten"; 15081d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 15091d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 15101d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // Iterators don't support remove. 15111d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override public void testEntrySetIteratorRemove() {} 15121d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override public void testValuesIteratorRemove() {} 15131d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert 15141d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // These tests fail on GWT. 15151d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert // TODO: Investigate why. 15161d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override public void testEntrySetRemoveAll() {} 15171d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert @Override public void testEntrySetRetainAll() {} 15181d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert } 15191d580d0f6ee4f21eb309ba7b509d2c6d671c4044Bjorn Bringert} 1520