@Override protected void expectContents(Collection<Entry<K, V>> expected) { super.expectContents(expected); List<Entry<V, K>> reversedEntries = new ArrayList<>(); for (Entry<K, V> entry : expected) { reversedEntries.add(reverseEntry(entry)); } Helpers.assertEqualIgnoringOrder(getMap().inverse().entrySet(), reversedEntries); for (Entry<K, V> entry : expected) { assertEquals( "Wrong key for value " + entry.getValue(), entry.getKey(), getMap().inverse().get(entry.getValue())); } }
/** @see #addUserProfile(UserHandle) */ @Implementation protected int getUserSerialNumber(@UserIdInt int userHandle) { for (Entry<UserHandle, Long> entry : userProfiles.entrySet()) { if (entry.getKey().getIdentifier() == userHandle) { return entry.getValue().intValue(); } } return -1; }
public void testInsertionOrder() { BiMap<String, Integer> map = HashBiMap.create(); map.put("foo", 1); map.put("bar", 2); map.put("quux", 3); assertThat(map.entrySet()) .containsExactly( Maps.immutableEntry("foo", 1), Maps.immutableEntry("bar", 2), Maps.immutableEntry("quux", 3)) .inOrder(); }
public void testInverseInsertionOrderAfterInverse() { BiMap<String, Integer> map = HashBiMap.create(); map.put("bar", 2); map.put("quux", 1); assertThat(map.inverse().entrySet()) .containsExactly(Maps.immutableEntry(2, "bar"), Maps.immutableEntry(1, "quux")) .inOrder(); }
@MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES}) @CollectionSize.Require(absent = ZERO) public void testSetValueNullSupported() { for (Entry<K, V> entry : getMap().entrySet()) { if (entry.getKey().equals(k0())) { entry.setValue(null); } } expectReplacement(entry(k0(), (V) null)); } }
@Override protected void expectMissing(Entry<K, V>... entries) { super.expectMissing(entries); for (Entry<K, V> entry : entries) { Entry<V, K> reversed = reverseEntry(entry); BiMap<V, K> inv = getMap().inverse(); assertFalse( "Inverse should not contain entry " + reversed, inv.entrySet().contains(reversed)); assertFalse( "Inverse should not contain key " + reversed.getKey(), inv.containsKey(reversed.getKey())); assertFalse( "Inverse should not contain value " + reversed.getValue(), inv.containsValue(reversed.getValue())); /* * TODO(cpovirk): This is a bit stronger than super.expectMissing(), which permits a <key, * someOtherValue> pair. */ assertNull( "Inverse should not return a mapping for key " + reversed.getKey(), inv.get(reversed.getKey())); } } }
@MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_VALUES) @CollectionSize.Require(absent = ZERO) public void testSetValueNullUnsupported() { for (Entry<K, V> entry : getMap().entrySet()) { try { entry.setValue(null); fail("Expected NullPointerException"); } catch (NullPointerException expected) { } expectUnchanged(); } }
public void testInverseInsertionOrderAfterInverseForcePut() { BiMap<String, Integer> map = HashBiMap.create(); map.put("foo", 1); map.put("bar", 2); map.put("quux", 3); map.inverse().forcePut(1, "quux"); assertThat(map.inverse().entrySet()) .containsExactly(Maps.immutableEntry(2, "bar"), Maps.immutableEntry(1, "quux")) .inOrder(); }
@MapFeature.Require(SUPPORTS_PUT) @CollectionSize.Require(SEVERAL) public void testSetValue_valuePresent() { for (Entry<K, V> entry : getMap().entrySet()) { if (entry.getKey().equals(k0())) { try { entry.setValue(v1()); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { } } } expectUnchanged(); }
public void testInverseEntrySetValueNewKey() { BiMap<Integer, String> map = HashBiMap.create(); map.put(1, "a"); map.put(2, "b"); Iterator<Entry<String, Integer>> inverseEntryItr = map.inverse().entrySet().iterator(); Entry<String, Integer> entry = inverseEntryItr.next(); entry.setValue(3); assertEquals(Maps.immutableEntry("b", 2), inverseEntryItr.next()); assertFalse(inverseEntryItr.hasNext()); assertThat(map.entrySet()) .containsExactly(Maps.immutableEntry(2, "b"), Maps.immutableEntry(3, "a")) .inOrder(); } }
public void testInsertionOrderAfterRemoveMiddle() { BiMap<String, Integer> map = HashBiMap.create(); map.put("foo", 1); map.put("bar", 2); map.put("quux", 3); map.remove("bar"); assertThat(map.entrySet()) .containsExactly(Maps.immutableEntry("foo", 1), Maps.immutableEntry("quux", 3)) .inOrder(); }
public void testInsertionOrderAfterRemoveLast() { BiMap<String, Integer> map = HashBiMap.create(); map.put("foo", 1); map.put("bar", 2); map.put("quux", 3); map.remove("quux"); assertThat(map.entrySet()) .containsExactly(Maps.immutableEntry("foo", 1), Maps.immutableEntry("bar", 2)) .inOrder(); }
public void testInsertionOrderAfterInverseForcePut() { BiMap<String, Integer> map = HashBiMap.create(); map.put("foo", 1); map.put("bar", 2); map.put("quux", 3); map.inverse().forcePut(1, "quux"); assertThat(map.entrySet()) .containsExactly(Maps.immutableEntry("bar", 2), Maps.immutableEntry("quux", 1)) .inOrder(); }
public void testInsertionOrderAfterForcePut() { BiMap<String, Integer> map = HashBiMap.create(); map.put("foo", 1); map.put("bar", 2); map.put("quux", 3); map.forcePut("quux", 1); assertThat(map.entrySet()) .containsExactly(Maps.immutableEntry("bar", 2), Maps.immutableEntry("quux", 1)) .inOrder(); }
public void testInsertionOrderAfterRemoveFirst() { BiMap<String, Integer> map = HashBiMap.create(); map.put("foo", 1); map.put("bar", 2); map.put("quux", 3); map.remove("foo"); assertThat(map.entrySet()) .containsExactly(Maps.immutableEntry("bar", 2), Maps.immutableEntry("quux", 3)) .inOrder(); }
public void testBiMapEntrySetIteratorRemove() { BiMap<Integer, String> map = HashBiMap.create(); map.put(1, "one"); Set<Entry<Integer, String>> entries = map.entrySet(); Iterator<Entry<Integer, String>> iterator = entries.iterator(); Entry<Integer, String> entry = iterator.next(); entry.setValue("two"); // changes the iterator's current entry value assertEquals("two", map.get(1)); assertEquals(Integer.valueOf(1), map.inverse().get("two")); iterator.remove(); // removes the updated entry assertTrue(map.isEmpty()); }
public void testInverseInsertionOrderAfterInverseForcePutPresentKey() { BiMap<String, Integer> map = HashBiMap.create(); map.put("foo", 1); map.put("bar", 2); map.put("quux", 3); map.put("nab", 4); map.inverse().forcePut(4, "bar"); assertThat(map.entrySet()) .containsExactly( Maps.immutableEntry("foo", 1), Maps.immutableEntry("bar", 4), Maps.immutableEntry("quux", 3)) .inOrder(); }
public void testIdentityEntrySetIteratorRemove() { BiMap<Integer, String> bimap = new AbstractBiMap<Integer, String>( new IdentityHashMap<Integer, String>(), new IdentityHashMap<String, Integer>()) {}; bimap.put(1, "one"); bimap.put(2, "two"); bimap.put(3, "three"); Iterator<Entry<Integer, String>> iterator = bimap.entrySet().iterator(); iterator.next(); iterator.next(); iterator.remove(); iterator.next(); iterator.remove(); assertEquals(1, bimap.size()); assertEquals(1, bimap.inverse().size()); } }
@MapFeature.Require(SUPPORTS_PUT) @CollectionSize.Require(absent = ZERO) public void testSetValue_valueAbsent() { for (Entry<K, V> entry : getMap().entrySet()) { if (entry.getKey().equals(k0())) { assertEquals("entry.setValue() should return the old value", v0(), entry.setValue(v3())); } } expectReplacement(entry(k0(), v3())); }
public void testBashIt() throws Exception { BiMap<Integer, Integer> bimap = HashBiMap.create(N); BiMap<Integer, Integer> inverse = bimap.inverse(); for (int i = 0; i < N; i++) { assertNull(bimap.put(2 * i, 2 * i + 1)); } for (int i = 0; i < N; i++) { assertEquals(2 * i + 1, (int) bimap.get(2 * i)); } for (int i = 0; i < N; i++) { assertEquals(2 * i, (int) inverse.get(2 * i + 1)); } for (int i = 0; i < N; i++) { int oldValue = bimap.get(2 * i); assertEquals(2 * i + 1, (int) bimap.put(2 * i, oldValue - 2)); } for (int i = 0; i < N; i++) { assertEquals(2 * i - 1, (int) bimap.get(2 * i)); } for (int i = 0; i < N; i++) { assertEquals(2 * i, (int) inverse.get(2 * i - 1)); } Set<Entry<Integer, Integer>> entries = bimap.entrySet(); for (Entry<Integer, Integer> entry : entries) { entry.setValue(entry.getValue() + 2 * N); } for (int i = 0; i < N; i++) { assertEquals(2 * N + 2 * i - 1, (int) bimap.get(2 * i)); } }