@Override
@Test
public void retainAllFromEntrySet() {
super.retainAllFromEntrySet();
for (int i = 1; i < COLLISIONS.size(); i++) {
MutableMap<Integer, Integer> map = this.mapWithCollisionsOfSize(i);
Assert.assertFalse(
map.entrySet()
.retainAll(
FastList.newList(map.entrySet())
.with(ImmutableEntry.of(COLLISION_10, COLLISION_10))));
Assert.assertTrue(map.entrySet().retainAll(this.mapWithCollisionsOfSize(i - 1).entrySet()));
Assert.assertEquals(this.mapWithCollisionsOfSize(i - 1), map);
}
// simple map, collection to retain contains non-entry element
MutableMap<Integer, String> map4 = this.newMapWithKeysValues(1, "One", 2, "Two");
FastList<Object> toRetain =
FastList.<Object>newListWith(
ImmutableEntry.of(1, "One"), "explosion!", ImmutableEntry.of(2, "Two"));
Assert.assertFalse(map4.entrySet().retainAll(toRetain));
}
protected static MutableList<String> generateCollisions() {
MutableList<String> collisions = FastList.newList();
ObjectBooleanHashMap<String> hashMap = new ObjectBooleanHashMap<String>();
for (int each = 3; collisions.size() <= 10; each++) {
if (hashMap.index(String.valueOf(each)) == hashMap.index(String.valueOf(3))) {
collisions.add(String.valueOf(each));
}
}
return collisions;
}
@Test
public void remove() {
for (int i = 1; i < COLLISIONS.size(); i++) {
MutableMap<Integer, Integer> map = this.mapWithCollisionsOfSize(i);
Assert.assertNull(map.put(null, null));
Assert.assertNull(map.remove(null));
Assert.assertNull(map.remove(COLLISION_10));
Integer biggestValue = COLLISIONS.get(i - 1);
Assert.assertEquals(biggestValue, map.remove(biggestValue));
}
}
@Override
@Test
public void clear() {
super.clear();
MutableList<String> list = new CompositeFastList<String>();
list.addAll(FastList.newListWith("1", "2", "3", "4"));
list.addAll(FastList.newListWith("3", "B", "3", "B"));
list.clear();
Assert.assertTrue(list.isEmpty());
Assert.assertEquals(0, list.size());
}
@Test
public void contains_key_and_value() {
for (int i = 1; i < COLLISIONS.size(); i++) {
MutableMap<Integer, Integer> map = this.mapWithCollisionsOfSize(i);
Assert.assertTrue(map.containsKey(COLLISIONS.get(i - 1)));
Assert.assertTrue(map.containsValue(COLLISIONS.get(i - 1)));
Assert.assertFalse(map.containsKey(COLLISION_10));
Assert.assertFalse(map.containsValue(COLLISION_10));
Assert.assertFalse(map.containsKey(null));
Assert.assertFalse(map.containsValue(null));
map.put(null, null);
Assert.assertTrue(map.containsKey(null));
Assert.assertTrue(map.containsValue(null));
}
}
@Override
@Test
public void removeFromEntrySet() {
super.removeFromEntrySet();
for (int i = 1; i < COLLISIONS.size(); i++) {
MutableMap<Integer, Integer> map = this.mapWithCollisionsOfSize(i);
Integer biggestValue = COLLISIONS.get(i - 1);
Assert.assertTrue(map.entrySet().remove(ImmutableEntry.of(biggestValue, biggestValue)));
Assert.assertEquals(this.mapWithCollisionsOfSize(i - 1), map);
Assert.assertFalse(map.entrySet().remove(ImmutableEntry.of(COLLISION_10, COLLISION_10)));
Assert.assertEquals(this.mapWithCollisionsOfSize(i - 1), map);
Assert.assertFalse(map.entrySet().remove(null));
}
}
@Override
@Test
public void forEachWith() {
super.forEachWith();
for (int i = 1; i < COLLISIONS.size(); i++) {
MutableMap<Integer, Integer> map = this.mapWithCollisionsOfSize(i);
final Object sentinal = new Object();
final UnifiedSet<Integer> result = UnifiedSet.newSet();
map.forEachWith(
new Procedure2<Integer, Object>() {
public void value(Integer argument1, Object argument2) {
Assert.assertSame(sentinal, argument2);
result.add(argument1);
}
},
sentinal);
Assert.assertEquals(map.keySet(), result);
}
}
@Override
@Test
public void equalsAndHashCode() {
super.equalsAndHashCode();
for (int i = 1; i < COLLISIONS.size(); i++) {
MutableMap<Integer, Integer> map = this.mapWithCollisionsOfSize(i);
Map<Integer, Integer> expectedMap = new HashMap<Integer, Integer>(map);
Verify.assertEqualsAndHashCode(expectedMap, map);
MutableMap<Integer, Integer> clone1 = map.clone();
clone1.put(COLLISION_10, COLLISION_10);
Verify.assertNotEquals(expectedMap, clone1);
MutableMap<Integer, Integer> clone2 = map.clone();
clone2.put(null, null);
Verify.assertNotEquals(expectedMap, clone2);
expectedMap.put(null, null);
Verify.assertNotEquals(expectedMap, map);
expectedMap.remove(null);
expectedMap.put(COLLISION_10, COLLISION_10);
Verify.assertNotEquals(expectedMap, map);
}
MutableMap<Integer, Integer> mapA = this.mapWithCollisionsOfSize(3);
MutableMap<Integer, Integer> mapB = this.mapWithCollisionsOfSize(3);
// map with a chain, compare the null key (and value) with a non-null key
mapA.put(null, null);
mapB.put(42, 84);
Verify.assertNotEquals(mapA, mapB);
Verify.assertNotEquals(mapA.hashCode(), mapB.hashCode());
// map with a chain, compare the two null keys with different values (one null, one not)
mapB.remove(42);
mapB.put(null, 42);
Verify.assertNotEquals(mapA, mapB);
// map with a chain, compare a non-null key (null value) with a non-null key and value
mapB.remove(null);
mapB.remove(42);
mapA.remove(null);
mapA.put(17, null);
Verify.assertNotEquals(mapA, mapB);
MutableMap<Integer, String> mapC = this.newMapWithKeysValues(1, "One", 2, "Two", null, null);
MutableMap<Integer, String> mapD = this.newMapWithKeysValues(1, "One", 2, "Two", 3, "Three");
// compare the null key (and value) with a non-null key
Verify.assertNotEquals(mapC, mapD);
// compare a non-null key (and null value) with a non-null key
mapC.remove(null);
mapC.put(3, null);
Verify.assertNotEquals(mapC, mapD);
// reset
mapC.remove(3);
mapC.put(null, null);
// compare the null key (and null value) with a null key (and non-null value)
mapD.remove(3);
mapD.put(null, "Three");
// compare the two null keys with different values (one null, one not)
Verify.assertNotEquals(mapC, mapD);
Assert.assertEquals(0, this.newMapWithKeyValue(null, null).hashCode());
}