public void testLimitSpecification() { LongIteratorSpecificationChecker.checkIterator(myRand, new LongIteratorSpecificationChecker.IteratorGetter<LongIterator>() { @Override public List<LongIterator> get(long... values) { LongArray valuesArray2 = LongCollections.collectLists(LongArray.create(values), LongArray.create(10, 20)); return Arrays.asList( limit(new LongArray(values), values.length), limit(valuesArray2, values.length)); } }); }
private LongList createRand(int len, int maxElem, int factor) { maxElem = maxElem / factor; LongArray larr = new LongArray(len); for (int i = 0; i < len; ++i) { int elem = myRand.nextInt(maxElem) * factor; larr.add(elem); } larr.sortUnique(); return larr; }
public LongIterable get(LongArray ... arrays) { LongArray expected = new LongArray(); for (LongArray array : arrays) { expected.addAll(array); } expected.sortUnique(); return expected; } }
public void checkRemove(long[] test, long valueToRemove, LongList actual) { LongArray expected = new LongArray(); for (long val : test) { if (val != valueToRemove) { expected.add(val); } } CHECK.order(expected, actual); }
public void testCreate() { List<LongArray> list = new ArrayList<LongArray>(); list.add(LongArray.create(1, 2, 5, 10, 20)); list.add(LongArray.create(1, 5, 21, 30, 40)); LongArray intersection = new LongArray(new LongIntersectionIterator(list)); CHECK.order(intersection, 1, 5); }
public void testCreate() { List<LongArray> list = new ArrayList<LongArray>(); list.add(LongArray.create(1, 2, 5, 10)); list.add(LongArray.create(-3, 2, 3, 4, 11)); LongArray union = new LongArray(new LongUnionIterator(list)); CHECK.order(union, -3, 1, 2, 3, 4, 5, 10, 11); }
public void testToNativeArray() { long[][] arrays = {{}, {0}, {0, 1, 2}, {Long.MIN_VALUE, 0, Long.MAX_VALUE}, {0, 1, 2, 3, 4}}; for (long[] expected: arrays) { checkToNativeArray(new LongArray(expected)); } for (int attempt = 0; attempt < 10; attempt++) { checkToNativeArray(generateRandomLongArray(100, IntegersFixture.SortedStatus.SORTED_UNIQUE)); } }
protected void checkCollectionM(LongList collection, long[]... ints) { LongArray t = new LongArray(); for (long[] ar : ints) { t.addAll(ar); } checkCollection(collection, t.toNativeArray()); }
@Override protected LongSet createSet(LongList sortedUniqueList) { LongIntMap map = new LongIntListMap( new LongArray(sortedUniqueList), new IntArray(repeat(0, sortedUniqueList.size()))); return map.keySet(); }
protected void checkList(LongList collection, long[]... v) { LongArray r = new LongArray(); for (long[] ints : v) { r.addAll(ints); } long[] expected = r.toNativeArray(); CHECK.order(collection.iterator(), expected); }
public void testExpand() { array = new LongArray(); array = LongArray.create(0, 1, 2, 3); array.expand(1, 4); CHECK.order(array, LongArray.create(0, 1, 2, 3, 0, 1, 2, 3)); }
public void testIndexOf() { for (WritableLongList list: createWritableLongLists( new LongArray(LongProgression.arithmetic(99, 100, -1)).extractHostArray())) { for (int i = 0; i < 100; i++) { assertEquals(99 - i, list.indexOf(i)); } } }
@Override public void retain(LongList values) { LongArray res = new LongArray(); for (LongIterator it: values) { long value = it.value(); if (contains(value)) res.add(value); } clear(); addAll(res); }
protected void checkSet(LongList collection, long[]... v) { LongArray r = new LongArray(); for (long[] ints : v) { r.addAll(ints); } r.sortUnique(); long[] expected = r.toNativeArray(); CHECK.order(collection.iterator(), expected); }
@Override public LongIterable get(LongArray... arrays) { assert arrays[0].isSortedUnique() && arrays[1].isSortedUnique(); LongArray expected = new LongArray(arrays[0].size()); expected.addAll(new LongMinusIterator(arrays[0], arrays[1])); expected.addAll(new LongMinusIterator(arrays[1], arrays[0])); expected.sortUnique(); return expected; } }
public void testSimple() { LongArray a = LongArray.create(1, 2, 5, 10), b = LongArray.create(-3, 2, 3, 4, 11), expected = LongArray.copy(a); expected.addAll(b); expected.sortUnique(); LongArray union = new LongArray(new LongUnionIteratorOfTwo(a, b)); CHECK.order(union, expected); }
public void testIterator() { LongArray source = LongArray.create(10,13,15,14,11,12,16,17,18), expected = LongArray.create(10,15,14,12,16,18), result = new LongArray(); IntArray indices = IntArray.create(1, 4, 7); prepareSortedIndices(indices); LongListRemovingDecorator tst2 = createFromPrepared(source, indices); result.addAll(tst2.iterator()); assertEquals(expected, result); }
public void testRemoveAllAtSorted() { LongArray a = new LongArray(LongProgression.arithmetic(0, 20)); LongCollections.removeAllAtSorted(a, IntArray.create(0, 3, 4, 7, 10, 11, 12, 13, 19)); CHECK.order(a.iterator(), 1, 2, 5, 6, 8, 9, 14, 15, 16, 17, 18); LongCollections.removeAllAtSorted(a, IntArray.create(1, 2, 3, 4, 9)); CHECK.order(a.iterator(), 1, 9, 14, 15, 16, 18); }
public void testRemoveAndResizeSimple() { set = new LongChainHashSet(16); set.addAll(range(11)); set.remove(5); set.add(11); // This one leads to resize set.add(12); set.add(13); LongArray expected = new LongArray(range(14)); expected.removeSorted(5); checkSet(set, expected); }
public void testCopyInsertList() { for (WritableLongList list: empty()) { list.addAll(LongProgression.arithmetic(0, 10240, 1)); LongArray src = new LongArray(); src.addAll(list); list.insertAll(2000, src, 100, 10000); checkList(list, ap(0, 2000, 1), ap(100, 10000, 1), ap(2000, 8240, 1)); list.setAll(5000, src); checkList(list, ap(0, 2000, 1), ap(100, 3000, 1), ap(0, 10240, 1), ap(5240, 5000, 1)); } }