mirror of
https://github.com/MinecraftForge/MinecraftForge.git
synced 2026-11-19 19:59:42 +00:00
Fixed issue with MutableHashedLinkedMap when removing multiple sequential entries in the middle of the map.
Added Unit tests for MutableHashLinkedMap Added support for removing using the iterator Added concurrent modification detection to the iterator Added default constructor with basic hashing strategy. Closes #9426
This commit is contained in:
2 files changed
+612
-6
No files matched your search
@@ -0,0 +1,523 @@
|
||||
/*
|
||||
* Copyright (c) Forge Development LLC and contributors
|
||||
* SPDX-License-Identifier: LGPL-2.1-only
|
||||
*/
|
||||
|
||||
package net.minecraftforge.test;
|
||||
|
||||
import it.unimi.dsi.fastutil.Hash.Strategy;
|
||||
import net.minecraftforge.common.util.MutableHashedLinkedMap;
|
||||
|
||||
import org.junit.jupiter.api.MethodOrderer;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.TestMethodOrder;
|
||||
|
||||
import java.util.ConcurrentModificationException;
|
||||
import java.util.Map;
|
||||
import java.util.function.BiPredicate;
|
||||
import java.util.function.ToIntFunction;
|
||||
import java.util.stream.Collector;
|
||||
import java.util.stream.Stream;
|
||||
import java.util.stream.StreamSupport;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertThrows;
|
||||
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
|
||||
|
||||
@TestMethodOrder(MethodOrderer.MethodName.class)
|
||||
public class MutableHashedLinkedMapTest {
|
||||
private static final Strategy<? super String> FIRST_CHARACTER = strat(
|
||||
k -> k == null ? 0 : Character.hashCode(k.charAt(0)),
|
||||
(a, b) -> a == null ? b == null : b == null ? false : a.charAt(0) == b.charAt(0)
|
||||
);
|
||||
|
||||
@Test
|
||||
void retainsInsertOrder() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
assertArrayEquals(arr("first", "second", "third"), keysArray(map));
|
||||
assertArrayEquals(arr(1, 2, 3), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void retainsInsertOrderAfterOverride() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
var old = map.put("second", 5);
|
||||
|
||||
assertEquals(old, 2);
|
||||
assertArrayEquals(arr("first", "second", "third"), keysArray(map));
|
||||
assertArrayEquals(arr(1, 5, 3), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void retainsInsertOrderAfterOverrideWithStrategy() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>(FIRST_CHARACTER);
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
var old = map.put("should override", 5);
|
||||
|
||||
assertEquals(old, 2);
|
||||
assertArrayEquals(arr("first", "second", "third"), keysArray(map));
|
||||
assertArrayEquals(arr(1, 5, 3), valuesArray(map));
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
void strategyCollisionDoesNotOverwriteKey() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>(FIRST_CHARACTER);
|
||||
map.put("static", 1);
|
||||
|
||||
var old = map.put("shouldn't change the name, but should change the value", 5);
|
||||
|
||||
assertEquals(old, 1);
|
||||
assertArrayEquals(arr("static"), keysArray(map));
|
||||
assertArrayEquals(arr(5), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void putFirst() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
var old = map.putFirst("first", 1);
|
||||
|
||||
assertNull(old);
|
||||
assertArrayEquals(arr("first", "second", "third"), keysArray(map));
|
||||
assertArrayEquals(arr(1, 2, 3), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void putAfter() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("third", 3);
|
||||
|
||||
var old = map.putAfter("first", "second", 2);
|
||||
|
||||
assertNull(old);
|
||||
assertArrayEquals(arr("first", "second", "third"), keysArray(map));
|
||||
assertArrayEquals(arr(1, 2, 3), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void putAfterWithStrategy() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>(FIRST_CHARACTER);
|
||||
map.put("first", 1);
|
||||
map.put("third", 3);
|
||||
|
||||
var old = map.putAfter("first entry", "second", 2);
|
||||
|
||||
assertNull(old);
|
||||
assertArrayEquals(arr("first", "second", "third"), keysArray(map));
|
||||
assertArrayEquals(arr(1, 2, 3), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void putBefore() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("third", 3);
|
||||
|
||||
var old = map.putBefore("third", "second", 2);
|
||||
|
||||
assertNull(old);
|
||||
assertArrayEquals(arr("first", "second", "third"), keysArray(map));
|
||||
assertArrayEquals(arr(1, 2, 3), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void putBeforeWithStrategy() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>(FIRST_CHARACTER);
|
||||
map.put("first", 1);
|
||||
map.put("third", 3);
|
||||
|
||||
var old = map.putBefore("third entry", "second", 2);
|
||||
|
||||
assertNull(old);
|
||||
assertArrayEquals(arr("first", "second", "third"), keysArray(map));
|
||||
assertArrayEquals(arr(1, 2, 3), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void isEmpty() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
assertTrue(map.isEmpty(), "Freshly initalized map is not empty!");
|
||||
map.put("entry", 1);
|
||||
assertFalse(map.isEmpty(), "Map is empty, but contains an element");
|
||||
map.remove("entry");
|
||||
assertTrue(map.isEmpty(), "Map is not empty after removing its only entry");
|
||||
}
|
||||
|
||||
@Test
|
||||
void get() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
assertEquals(1, map.get("first"));
|
||||
assertEquals(2, map.get("second"));
|
||||
assertEquals(3, map.get("third"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void getWithStrategy() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>(FIRST_CHARACTER);
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
assertEquals(1, map.get("first entry"));
|
||||
assertEquals(2, map.get("second entry"));
|
||||
assertEquals(3, map.get("third entry"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void contains() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
assertTrue(map.contains("first"));
|
||||
assertTrue(map.contains("second"));
|
||||
assertTrue(map.contains("third"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void containsWithStrategy() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>(FIRST_CHARACTER);
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
assertTrue(map.contains("first entry"));
|
||||
assertTrue(map.contains("second entry"));
|
||||
assertTrue(map.contains("third entry"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void removeHead() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
var old = map.remove("first");
|
||||
|
||||
assertEquals(1, old);
|
||||
assertArrayEquals(arr("second", "third"), keysArray(map));
|
||||
assertArrayEquals(arr(2, 3), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void removeHeadWithStrategy() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>(FIRST_CHARACTER);
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
var old = map.remove("first entry");
|
||||
|
||||
assertEquals(1, old);
|
||||
assertArrayEquals(arr("second", "third"), keysArray(map));
|
||||
assertArrayEquals(arr(2, 3), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void removeMiddle() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
var old = map.remove("second");
|
||||
|
||||
assertEquals(2, old);
|
||||
assertArrayEquals(arr("first", "third"), keysArray(map));
|
||||
assertArrayEquals(arr(1, 3), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void removeMiddleWithStrategy() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>(FIRST_CHARACTER);
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
var old = map.remove("second entry");
|
||||
|
||||
assertEquals(2, old);
|
||||
assertArrayEquals(arr("first", "third"), keysArray(map));
|
||||
assertArrayEquals(arr(1, 3), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void removeMultipleMiddle() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
map.put("forth", 4);
|
||||
map.put("fifth", 5);
|
||||
map.put("sixth", 6);
|
||||
|
||||
assertEquals(2, map.remove("second"));
|
||||
assertEquals(3, map.remove("third"));
|
||||
assertEquals(4, map.remove("forth"));
|
||||
|
||||
assertArrayEquals(arr("first", "fifth", "sixth"), keysArray(map));
|
||||
assertArrayEquals(arr(1, 5, 6), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void removeMultipleMiddleWithStrategy() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>(FIRST_CHARACTER);
|
||||
map.put("1st", 1);
|
||||
map.put("2nd", 2);
|
||||
map.put("3rd", 3);
|
||||
map.put("4th", 4);
|
||||
map.put("5th", 5);
|
||||
map.put("6th", 6);
|
||||
|
||||
assertEquals(2, map.remove("2nd entry"));
|
||||
assertEquals(3, map.remove("3rd entry"));
|
||||
assertEquals(4, map.remove("4th entry"));
|
||||
|
||||
assertArrayEquals(arr("1st", "5th", "6th"), keysArray(map));
|
||||
assertArrayEquals(arr(1, 5, 6), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void removeTail() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
var old = map.remove("third");
|
||||
|
||||
assertEquals(3, old);
|
||||
assertArrayEquals(arr("first", "second"), keysArray(map));
|
||||
assertArrayEquals(arr(1, 2), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void removeTailWithStrategy() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>(FIRST_CHARACTER);
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
var old = map.remove("third entry");
|
||||
|
||||
assertEquals(3, old);
|
||||
assertArrayEquals(arr("first", "second"), keysArray(map));
|
||||
assertArrayEquals(arr(1, 2), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void iteratorInOrder() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
var itr = map.iterator();
|
||||
|
||||
assertEquals("first", itr.next().getKey());
|
||||
assertEquals("second", itr.next().getKey());
|
||||
assertEquals("third", itr.next().getKey());
|
||||
assertFalse(itr.hasNext());
|
||||
}
|
||||
|
||||
@Test
|
||||
void iteratorRemoveHead() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
var itr = map.iterator();
|
||||
while (itr.hasNext()) {
|
||||
var next = itr.next();
|
||||
if (next.getKey().equals("first"))
|
||||
itr.remove();
|
||||
}
|
||||
|
||||
assertArrayEquals(arr("second", "third"), keysArray(map));
|
||||
assertArrayEquals(arr(2, 3), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void iteratorRemoveMiddle() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
var itr = map.iterator();
|
||||
while (itr.hasNext()) {
|
||||
var next = itr.next();
|
||||
if (next.getKey().equals("second"))
|
||||
itr.remove();
|
||||
}
|
||||
|
||||
assertArrayEquals(arr("first", "third"), keysArray(map));
|
||||
assertArrayEquals(arr(1, 3), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void iteratorRemoveEnd() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
var itr = map.iterator();
|
||||
while (itr.hasNext()) {
|
||||
var next = itr.next();
|
||||
if (next.getKey().equals("third"))
|
||||
itr.remove();
|
||||
}
|
||||
|
||||
assertArrayEquals(arr("first", "second"), keysArray(map));
|
||||
assertArrayEquals(arr(1, 2), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void iteratorRemoveAll() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
var itr = map.iterator();
|
||||
while (itr.hasNext()) {
|
||||
itr.next();
|
||||
itr.remove();
|
||||
}
|
||||
|
||||
assertTrue(map.isEmpty());
|
||||
assertArrayEquals(arr(), keysArray(map));
|
||||
assertArrayEquals(arr(), valuesArray(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
void iteratorRemoveRequiresNext() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
var itr = map.iterator();
|
||||
assertThrows(IllegalStateException.class, () -> itr.remove());
|
||||
}
|
||||
|
||||
@Test
|
||||
void iteratorNextThrowsOnAdded() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
var itr = map.iterator();
|
||||
map.put("forth", 4);
|
||||
|
||||
assertThrows(ConcurrentModificationException.class, () -> itr.next());
|
||||
}
|
||||
|
||||
@Test
|
||||
void iteratorNextThrowsOnRemoved() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
var itr = map.iterator();
|
||||
map.remove("first");
|
||||
|
||||
assertThrows(ConcurrentModificationException.class, () -> itr.next());
|
||||
}
|
||||
|
||||
@Test
|
||||
void iteratorRemoveThrowsOnAdded() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
var itr = map.iterator();
|
||||
itr.next();
|
||||
map.put("forth", 4);
|
||||
|
||||
assertThrows(ConcurrentModificationException.class, () -> itr.remove());
|
||||
}
|
||||
|
||||
@Test
|
||||
void iteratorRemoveThrowsOnRemoved() {
|
||||
var map = new MutableHashedLinkedMap<String, Integer>();
|
||||
map.put("first", 1);
|
||||
map.put("second", 2);
|
||||
map.put("third", 3);
|
||||
|
||||
var itr = map.iterator();
|
||||
itr.next();
|
||||
map.remove("first");
|
||||
|
||||
assertThrows(ConcurrentModificationException.class, () -> itr.remove());
|
||||
}
|
||||
|
||||
@Test
|
||||
void paintingsTest() {
|
||||
var map = new MutableHashedLinkedMap<Character, Integer>();
|
||||
for (char x = 'a'; x <= 'z'; x++)
|
||||
map.put(x, (int)x);
|
||||
map.remove('i');
|
||||
map.remove('j');
|
||||
map.remove('k');
|
||||
map.remove('l');
|
||||
var keys = stream(map).map(e->e.getKey()).collect(Collector.of(StringBuilder::new, StringBuilder::append, StringBuilder::append, StringBuilder::toString));
|
||||
assertEquals("abcdefghmnopqrstuvwxyz", keys);
|
||||
}
|
||||
|
||||
|
||||
|
||||
private static <K> Strategy<K> strat(ToIntFunction<K> hash, BiPredicate<K,K> equals) {
|
||||
return new Strategy<K>() {
|
||||
@Override public int hashCode(K o) { return hash.applyAsInt(o); }
|
||||
@Override public boolean equals(K a, K b) { return equals.test(a, b); }
|
||||
};
|
||||
}
|
||||
|
||||
@SafeVarargs
|
||||
private static <T> T[] arr(T... values) {
|
||||
return values;
|
||||
}
|
||||
|
||||
private static <K,V> Stream<Map.Entry<K,V>> stream(MutableHashedLinkedMap<K,V> map) {
|
||||
return StreamSupport.stream(map.spliterator(), false);
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private static <K> K[] keysArray(MutableHashedLinkedMap<K, ?> map) {
|
||||
return (K[])stream(map).map(e -> e.getKey()).toArray();
|
||||
}
|
||||
@SuppressWarnings("unchecked")
|
||||
private static <V> V[] valuesArray(MutableHashedLinkedMap<?, V> map) {
|
||||
return (V[])stream(map).map(e -> e.getValue()).toArray();
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user