public void testAddAll() { int attemptsCount = 10; int maxSize = 2048; for (int attempt = 0; attempt < attemptsCount; attempt++) { myArray = new LongCyclicQueue(); int firstCount = myRand.nextInt(maxSize / 2); int secondCount = firstCount + myRand.nextInt(maxSize / 2); myArray.addAll(range(firstCount)); CHECK.order(myArray, range(firstCount)); // ensureCapacity myArray.addAll(range(firstCount, secondCount)); CHECK.order(myArray, range(secondCount)); } }
public void testPutIfAbsent() { checkPutIfAbsent(LongProgression.range(20)); checkPutIfAbsent(concatLists(LongProgression.range(20), LongProgression.range(20))); checkPutIfAbsent(concatLists(LongProgression.range(20), LongProgression.range(19, 0, -1))); int attemptsCount = 10, size = 300, max = size * 3 / 2; for (int attempt = 0; attempt < attemptsCount; attempt++) { checkPutIfAbsent(generateRandomLongArray(size, UNORDERED, max)); } }
public void testRetainSimple2() { set = new LongTreeSet(); set.addAll(range(20)); set.removeAll(range(0, 20, 2)); checkSet(set, range(1, 20, 2)); set = new LongTreeSet(); for (int i = 0; i < 2; i++) { set.addAll(range(2, 25, 2)); set.retain(LongTreeSet.createFromSortedUnique(range(3, 25, 3))); checkSet(set, range(6, 25, 6)); set.clear(); } } }
public void testSize() { int attemptsCount = 10, addCount = 20, tempSize = 20; for (int attempt = 0; attempt < attemptsCount; attempt++) { int stop = 0; LongSetBuilder b = new LongSetBuilder(tempSize); for (int i = 0; i < addCount; i++) { int start = stop; stop = start + myRand.nextInt(tempSize * 2); b.addAll(LongProgression.range(start, stop)); assertEquals(stop, b.size()); } } }
public void testRemoveAndResizeSimple() { set = new LongOpenHashSet(16); assertEquals(12, set.getThreshold()); set.addAll(range(11)); set.remove(5); set.add(11); set.add(12); // This one leads to resize set.add(13); LongArray expected = new LongArray(range(14)); expected.removeSorted(5); checkSet(set, expected); }
public void testToNativeArray2() { for (T set : createSets(LongProgression.range(20, 40))) { long[] ar = new long[40]; set.toNativeArray(ar, 3); LongArray actual = new LongArray(new LongArray(ar).subList(3, 23)); LongList expected = LongProgression.range(20, 40); CHECK.unordered(actual, expected); set.removeAll(LongIterators.range(20, 40, 2)); set.toNativeArray(ar, 4); expected = LongProgression.range(21, 40, 2); actual = new LongArray(new LongArray(ar).subList(4, 4 + expected.size())); CHECK.unordered(actual, expected); } }
public void testEnsureRoomToAdd() { myArray = new LongCyclicQueue(); assertEquals(0, myArray.getCapacity()); int[] counts = {20, 50, 110}; for (int count : counts) { myArray.ensureRoomToAdd(count); int cap = myArray.getCapacity(); myArray.addAll(range(count)); assertEquals(cap, myArray.getCapacity()); myArray.removeFirst(10); myArray.addAll(range(10)); assertEquals(cap, myArray.getCapacity()); } } }
public void testCreateForAdd() { int minSize = 15, maxSize = 266; float[] loadFactors = {0.1f, 0.3f, 0.5f, 0.75f, 1.0f, 1.5f, 2f}; for (float loadFactor : loadFactors) { for (int size = minSize; size <= maxSize; size++) { set = LongChainHashSet.createForAdd(size, loadFactor); int curThreshold = set.getThreshold(); assertTrue(set.getThreshold() + "<" + size + "; load factor = " + loadFactor, set.getThreshold() >= size); LongList expected = range(size); set.addAll(expected); checkSet(set, expected); assertEquals(curThreshold, set.getThreshold()); } } }
public void testContainsAny() { for (T set : createSets(LongList.EMPTY)) { assertFalse(set.containsAny(set)); assertFalse(set.containsAny(LongSet.EMPTY)); assertFalse(set.containsAny(LongList.EMPTY)); assertFalse(set.containsAny(LongIterator.EMPTY)); } LongArray check = collectIterables(create(Long.MIN_VALUE, Long.MAX_VALUE, 239), LongProgression.range(10)); check.sortUnique(); LongArray list = new LongArray(LongProgression.range(0, 10, 2)); for (T set : createSets(list)) { for (LongArray array : LongCollections.allSubLists(check)) { assertEquals(hasIntersection(list, check), set.containsAny(check)); } } }
public void testGetSimple() { IntArray prepared = IntArray.create(2); prepareSortedIndices(prepared); LongListRemovingDecorator rem = createFromPrepared(range(0, 4), prepared); LongListIterator it = rem.iterator(); it.next(); assertEquals(3, it.get(2)); it.next(); assertEquals(3, it.get(1)); }
public void testCreateForAdd() { int minSize = 16, maxSize = 266; float[] loadFactors = {0.1f, 0.3f, 0.5f, 0.75f, 0.99f}; for (float loadFactor : loadFactors) { for (int size = minSize; size <= maxSize; size++) { set = LongOpenHashSet.createForAdd(size, loadFactor); int curThreshold = set.getThreshold(); assertTrue(set.getThreshold() + "<" + size + "; load factor = " + loadFactor, set.getThreshold() >= size); LongList expected = range(size); set.addAll(expected); checkSet(set, expected); assertEquals(curThreshold, set.getThreshold()); } } }
public void testIteratorHasMethods() { for (T set : createSets(LongProgression.range(1, 8))) { LongIterator iterator = set.iterator(); assertFalse(iterator.hasValue()); assertTrue(iterator.hasNext()); iterator.next(); assertTrue(iterator.hasValue()); for (int i = 0; i < 6; i++) { iterator.next(); } assertTrue(iterator.hasValue()); assertFalse(iterator.hasNext()); } }
public void testIterator() { LongArray keys = new LongArray(range(0, 10, 1)); LongArray values = new LongArray(LongCollections.map(SQR, range(10, 0, -1))); for (LongLongIterator it : new LongLongPairIterator(keys, values)) { map.put(it.left(), it.right()); } CHECK.order(map.keysIterator(), keys.iterator()); CHECK.order(LongCollections.toSortedUnique(values).iterator(), map.valuesIterator()); LongLongIterator mapIt = map.iterator(), it = new LongLongPairIterator(keys, values); while (mapIt.hasNext()) { assertTrue(it.hasNext()); mapIt.next(); it.next(); assertEquals(it.left(), mapIt.left()); assertEquals(it.right(), mapIt.right()); } } }
public void testSimpleResize() { long[] values0 = {-1, 0, 10, -10, 20, 30}; LongArray values = new LongArray(values0); LongArray toAdd = LongArray.create(0, -4, -10, 20); LongList expected = LongCollections.concatLists(values, toAdd); for (WritableLongList list : createWritableLongLists(values0)) { CHECK.order(values, list); list.addAll(toAdd); CHECK.order(expected, list); } LongList valuesList = LongProgression.range(1024); values0 = valuesList.toNativeArray(); long[] expected0 = LongCollections.collectLists(valuesList, new LongList.Single(1025)).extractHostArray(); for (WritableLongList list : createWritableLongLists(values0)) { list.add(1025); CHECK.order(list, expected0); } }
public void testIterators2() { if (!isSortedSet()) return; for (T set : createSets(range(10))) { LongIterator it1 = set.iterator(); for (int i = 0; i < 5; i++) { assertEquals(i, it1.nextValue()); } // call coalesce CHECK.order(new LongArray(ap(0, 10, 1)), set.toArray()); CHECK.order(new LongArray(ap(0, 10, 1)).iterator(), set.iterator()); CHECK.order(new LongArray(ap(5, 5, 1)).iterator(), it1); } }
public void testAddRemove2() { LongArray array = new LongArray(LongProgression.range(0, 7)); for (LongArray a : allSubLists(array)) { for (LongArray b : allSubLists(array)) { for (int i = 0; i < 2; i++) { set = new LongAmortizedSet(); LongArray expected = LongArray.copy(a); expected.removeAll(b); set.addAll(a); if (i % 2 == 0) { set.coalesce(); } set.removeAll(b); assertEquals(expected.isEmpty(), set.isEmpty()); assertEquals(expected.size(), set.size()); } } } }
public void testPiteratorIndex() { myArray.addAll(LongIterators.range(15)); CHECK.order(range(15), myArray); LongCyclicQueue.PinnedIterator it = myArray.pinnedIterator(); try { it.index(); fail(); } catch (NoSuchElementException _) { // ok } assertEquals(0, it.age()); for (int i = 0; i < 10; i++) { it.next(); assertEquals(i, it.index()); } myArray.addAll(15, 16, 17); assertEquals(9, it.index()); for (int i = 1; i < 10; i++) { myArray.removeFirst(); assertEquals(9 - i, it.index()); } }
public void testCopyClone() { array.addAll(LongProgression.range(10240)); myEnv.clear(); array.addAll(array.clone()); checkList(array, ap(0, 10240, 1), ap(0, 10240, 1)); assertEquals(0, myEnv.copied); array.setAll(100, array, 100, 100); checkList(array, ap(0, 10240, 1), ap(0, 10240, 1)); array.setAll(100, array.clone(200, 300)); checkList(array, ap(0, 100, 1), ap(200, 100, 1), ap(200, 10040, 1), ap(0, 10240, 1)); array.insertAll(5000, array.clone(3000, 5000)); checkList(array, ap(0, 100, 1), ap(200, 100, 1), ap(200, 4800, 1), ap(3000, 2000, 1), ap(5000, 5240, 1), ap(0, 10240, 1)); }