public void testToTableString() { long[][] keysArray = {{}, {-1}, {0, 1, 2, 3}, {10, 20, 30}, {1, 3, 5, 7, 11, 13}}; for (long[] keys : keysArray) { IntArray values = new IntArray(keys.length); for (long key : keys) { values.add((int) (key * key)); } for (T map : createMapsFromLists(new LongArray(keys), values)) { String output; if (map instanceof AbstractWritableLongIntMap) { output = ((AbstractWritableLongIntMap) map).toTableString(); } else if (map instanceof WritableLongIntMapFromLongObjMap) { output = ((WritableLongIntMapFromLongObjMap) map).toTableString(); } else { continue; } int idx = 0, commasCount = 0; for (; idx < output.length() && output.charAt(idx) != '\n'; idx++) { if (output.charAt(idx) == ',') commasCount++; } assertEquals(Math.max(0, keys.length - 1), commasCount); assertFalse(idx == output.length()); idx++; for (; idx < output.length() && output.charAt(idx) != '\n'; idx++) { if (output.charAt(idx) == ',') commasCount--; } assertEquals(0, commasCount); } } }
public void checkPutIfAbsent(LongList keys) { map.clear(); for (int i = 0; i < keys.size(); i++) { long key = keys.get(i); int idx = keys.subList(0, i).indexOf(key); if (idx >= 0) { assertEquals(idx, map.get(key)); assertFalse(map.putIfAbsent(key, i)); assertEquals(idx, map.get(key)); } else { assertEquals(LongIntMap.DEFAULT_VALUE, map.get(key)); assertTrue(map.putIfAbsent(key, i)); assertEquals(i, map.get(key)); } } }
public void checkMap(T map, LongList keys, IntList values) { assertEquals(keys.size(), map.size()); assertEquals(keys.isEmpty(), map.isEmpty()); for (int i = 0; i < keys.size(); i++) { assertEquals(values.get(i), map.get(keys.get(i))); } LongArray mapKeys = collectIterable(map.size(), map.keysIterator()); CHECK.unordered(mapKeys, keys); IntArray mapValues = IntCollections.collectIterable(map.size(), map.valuesIterator()); CHECK.unordered(mapValues, values); }
public void testRemoveKey() { int size = 400, attempts = 10, maxVal = 1000; for (int attempt = 0; attempt < attempts; attempt++) { LongArray keys = generateRandomLongArray(size, SortedStatus.UNORDERED, maxVal); IntArray values = new IntArray(keys.size()); for (int i = 0; i < keys.size(); i++) { long key = keys.get(i); values.add((int) (-key * key)); } map.putAll(keys, values); keys.sortUnique(); for (int i = 0; i < maxVal; i++) { if (keys.binarySearch(i) >= 0) { assertEquals(-i * i, map.remove(i)); } else { assertEquals(0, map.remove(i)); } } } }
public void testEquals2() { int attemptsCount = 20; int maxVal = 10; int mapSize = 200; for (int attempt = 0; attempt < attemptsCount; attempt++) { LongArray keys = generateRandomLongArray(mapSize, SORTED_UNIQUE); IntArray values = generateRandomIntArray(keys.size(), UNORDERED, maxVal); for (T map0 : createMapsFromLists(keys, values)) { assertTrue(map0.equals(map0)); assertFalse(map0.equals(null)); assertFalse(map0.equals(LongIntMap.EMPTY)); assertTrue(map0.equals(map0)); T expected = createMap(); expected.putAllKeys(keys.subList(0, keys.size() - 1), values); expected.put(keys.getLast(0), values.getLast(0) != 0 ? 0 : 1); assertFalse(map0.equals(expected)); for (T map1 : createMapsFromLists(keys, values)) { assertEquals(map1, map0); } } } } }
@Override public void testHashCode() { int attemptsCount = 10, shuffleCount = 10; int sizeMax = 600, step = 50; for (int attempt = 0; attempt < attemptsCount; attempt++) { for (int mSize = step; mSize < sizeMax; mSize += step) { LongArray keys = generateRandomLongArray(mSize, SORTED_UNIQUE); int size = keys.size(); IntArray values = generateRandomIntArray(size, UNORDERED); int expectedHash = 0; for (int i = 0; i < size; i++) { expectedHash += IntegersUtils.hash(keys.get(i)) + IntegersUtils.hash(values.get(i)); } for (T map0 : createMapsFromLists(keys, values)) { assertEquals(expectedHash, map0.hashCode()); } IntArray indices = new IntArray(IntProgression.range(size)); for (int i = 0; i < shuffleCount; i++) { map = createMap(); map.putAll(keys.get(indices), values.get(indices)); assertEquals(expectedHash, map.hashCode()); indices.shuffle(myRand); } } } }
public void testPut() { int size = 100, attempts = 10, maxVal = 1000; for (int attempt = 0; attempt < attempts; attempt++) { map.clear(); LongArray keys = generateRandomLongArray(size, SortedStatus.SORTED_UNIQUE, maxVal); LongArray shuffledKeys = LongCollections.collectLists(keys, keys); shuffledKeys.shuffle(myRand); for (int i = 0; i < shuffledKeys.size(); i++) { long key = shuffledKeys.get(i); long prevValue = map.get(key); assertEquals(prevValue, map.put(key, (int) (-key * key))); } } }
public void testSimpleMap() { for (int i = 0; i < 10; i++) { map.put(i, i * i); } LongArray expected = new LongArray(range(0, 10)); assertEquals(10, map.size()); assertTrue(map.containsKeys(expected)); LongArray actual = new LongArray(10); for (LongIterator keysIt : map.keysIterator()) { actual.add(keysIt.value()); } actual.sort(); CHECK.order(actual.iterator(), expected.iterator()); for (LongIterator it : expected) { long value = it.value(); assertEquals(value * value, map.get(value)); } }
public void testValuesIterator() { IntArray expected = IntArray.create(1, 1, 2, 2, 3, 3); map.putAll(LongArray.create(0, 2, 4, 6, 8, 10), expected); IntArray actual = IntCollections.collectIterable(expected.size(), map.valuesIterator()); actual.sort(); assertEquals(expected, actual); int size = 20, attempts = 10; for (int attempt = 0; attempt < attempts; attempt++) { map.clear(); LongArray keys = generateRandomLongArray(size, SortedStatus.SORTED_UNIQUE, 100, 200); keys.shuffle(myRand); expected = new IntArray(size); for (int i = 0; i < keys.size(); i++) { long key = keys.get(i); expected.add((int) (key * key)); } map.putAll(keys, expected); actual = new IntArray(map.valuesIterator()); actual.sort(); expected.sort(); CHECK.order(actual.toNativeArray(), expected.toNativeArray()); } }