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 testSimple() { LongList[] lists = {LongList.EMPTY, new LongList.Single(10), LongArray.create(0, 1, 2), LongProgression.Arithmetic.range(3), null}; for (LongList list : lists) { assertEquals(0, comparator.compare(list, list)); } assertEquals(-1, comparator.compare(null, LongArray.create(0, 1, 2))); assertEquals(0, comparator.compare(lists[2], lists[3])); assertEquals(0, comparator.compare(lists[2], lists[2].iterator())); } }
public void testIteratorSetValue() { LongParallelListMap.Iterator it = myMap.iterator(1); assertNotNull(it.iterator()); assertFalse(it.hasValue()); for (; it.hasNext(); it.next()) { it.setRight(1, it.getRight(1) - 11); } assertTrue(it.hasValue()); LongIterator expected = LongArray.create(1, 0, 10, 20, 30).iterator(); CHECK.order(myMap.valuesIterator(0, myMap.size()), expected); }
private static void testRevPerm(IntArray perms) { IntArray rev = new IntArray(perms); IntegersUtils.reversePerm(rev); int n = perms.size(); IntArray e = new IntArray(n); for (int i = 0; i < n; ++i) { e.add(perms.get(rev.get(i))); } CHECK.order(IntProgression.arithmetic(0, n).iterator(), e.iterator()); }
public void testIteratorRemove2() { for (WritableLongList list: createWritableLongLists(ap(0, 10, 1))) { WritableLongListIterator it = list.iterator(); it.next().next().next().next(); assertEquals(3, it.value()); it.remove(); checkJustRemoved(it); assertEquals(4, it.nextValue()); } }
public void checkToNativeArray(LongArray array) { long[] expected = array.toNativeArray(); LongSet set = LongTreeSet.createFromSortedUnique(array); LongIterable[] iterables = {array, set, array.iterator(), set.iterator(), LongIterators.unionIterator(array, array.isEmpty() ? LongIterator.EMPTY : array.subList(0, 1))}; for (LongIterable iterable: iterables) { CHECK.order(expected, LongCollections.toNativeArray(iterable)); } }
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 testGet() { long[] expected = {0, 1, 2, 5, 6, 7}; CHECK.order(indices.iterator(), decorator.getIndices().iterator()); CHECK.order(source.iterator(), decorator.getSource().iterator()); checkCollection(decorator, expected); }
public void testPiteratorSimple() { LongCyclicQueue clq = new LongCyclicQueue(); clq.addAll(LongIterators.range(15)); LongCyclicQueue.PinnedIterator ii = clq.pinnedIterator(3); clq.removeFirst(3); ii.next(); assertEquals(0, ii.index()); ii = clq.pinnedIterator().next(); assertEquals(0, ii.index()); }
private IntIterator getNextDifferentValueIndex(LongList list) { WritableIntList resultingIndices = new IntArray(); for (int i = 0; i < list.size(); i = list.getNextDifferentValueIndex(i)) { assertTrue("exceeded the list size!", i < list.size()); resultingIndices.add(i); } return resultingIndices.iterator(); }
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 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)); } } }
public void testNoSuchElementExceptionCase() { LongArray list = LongArray.create(2, 3, 9); IntIterator indices = IntArray.create(0, 2).iterator(); LongIndexedIterator res = new LongIndexedIterator(list, indices); while (res.hasNext()) { res.nextValue(); } try { res.nextValue(); fail("not caught NSEE"); } catch(NoSuchElementException ex) { } }
public void testSimpleCreateFromSorted2() { LongList base = LongArray.create(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); WritableIntList indices = IntArray.create(0, 2, 4, 6, 8); LongListRemovingDecorator.prepareSortedIndices(indices); LongListRemovingDecorator arr = LongListRemovingDecorator.createFromPrepared(base, indices); CHECK.order(arr.iterator(), 1, 3, 5, 7, 9); }
private void checkToMethods(long... values) { LongList expected = LongArray.create(values); int length = values.length; long[] tmp = new long[length]; for (LongList arr : createLongListVariants(values)) { CHECK.order(expected.toNativeArray(0, tmp, 0, length), arr.toNativeArray(0, tmp, 0, length)); CHECK.order(expected.toNativeArray(), arr.toNativeArray()); CHECK.order(expected.toList(), arr.toList()); } }
private void checkNewSetCreator(LongArray... arrays) { CHECK.order(creator.get(arrays).iterator(), expected.get(arrays).iterator()); if (arrays.length == 2 && getCurrentStatus(0) == getCurrentStatus(1)) { CHECK.order(creator.get(arrays[1], arrays[0]).iterator(), expected.get(arrays[1], arrays[0]).iterator()); } }
public void testRandom() { LongArray[] arrays = new LongArray[5]; for (int i = 0; i < 20; i++) { for (int j = 0; j < arrays.length; j++) { arrays[j] = generateRandomLongArray(30, IntegersFixture.SortedStatus.UNORDERED); } CHECK.order(collectIterables(300, arrays).iterator(), LongIterators.concat(arrays)); } } }