@Override protected List<T> createLongListVariants(long... values) { return createWritableLongLists(values); }
protected List<T> empty() { return createWritableLongLists(); }
private void testReverse(long[] array, long[] expected) { for (WritableLongList list: createWritableLongLists(array)) { list.reverse(); checkCollection(list, expected); } }
public void testExpandComplex() { int arrayLength = 200, maxValue = Integer.MAX_VALUE; int maxExpandCount = 10, attempts = 10; for (int attempt = 0; attempt < attempts; attempt++) { long[] elements = generateRandomLongArray(arrayLength, UNORDERED, maxValue).extractHostArray(); for (WritableLongList list: createWritableLongLists(elements)) { int index = myRand.nextInt(elements.length); checkExpand(elements, index, myRand.nextInt(maxExpandCount), list); } } }
public void testRemoveRangeSimple() { for (WritableLongList list : createWritableLongLists(0, 0, 1, 1, 0, 0)) { list.removeRange(2, 4); checkCollection(list, 0, 0, 0, 0); } }
public void testSort() { int arrayLength = 200, maxValue = arrayLength * 2; for (int attempt = 0; attempt < 10; attempt++) { long[] res = generateRandomLongArray(arrayLength, UNORDERED, maxValue).extractHostArray(); for (WritableLongList list: createWritableLongLists(res)) { list.sort(); long[] expectedNative = Arrays.copyOf(res, res.length); Arrays.sort(expectedNative); LongArray expected = new LongArray(expectedNative); CHECK.order(expected, list); } } }
public void testSet() { for (WritableLongList list: createWritableLongLists(0, 1, 2, -1, 1, 3)) { list.set(0, 10); list.setAll(3, LongArray.create(5, 31, 36, 100), 1, 2); checkCollection(list, 10, 1, 2, 31, 36, 3); } }
public void testSortUnique() { int arrayLength = 200, maxValue = arrayLength * 2; for (int attempt = 0; attempt < 10; attempt++) { long[] res = generateRandomLongArray(arrayLength, UNORDERED, maxValue).extractHostArray(); for (WritableLongList list: createWritableLongLists(res)) { list.sortUnique(); long[] expectedNative = Arrays.copyOf(res, res.length); Arrays.sort(expectedNative); int newSize = LongCollections.removeSubsequentDuplicates(expectedNative, 0, expectedNative.length); LongArray expected = new LongArray(expectedNative, newSize); CHECK.order(expected, list); } } }
public void testApply() { for (WritableLongList list: createWritableLongLists(ap(0, 10, 1))) { long[] expected = ap(0, 10, 1); list.apply(2, 8, new LongToLong() { @Override public long invoke(long a) { return a * a - 1; } }); for (int i = 2; i < 8; i++) { expected[i] = expected[i] * expected[i] - 1; } checkList(list, expected); } }
public void testIteratorWrite2() { long[] values = {1, 1, 1, 2, 2, 3, 3}; long[] newValues = {2, 5, 5, -1, -1, -1, 4}; assert values.length == newValues.length; for (int i = 0; i < values.length; i++) { for (WritableLongList list : createWritableLongLists(values)) { WritableLongListIterator it = list.iterator(); it.move(i); for (int j = 0; j < values.length; j++) { it.set(-i + j + 1, newValues[j]); } checkCollection(list, newValues); } } }
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 testInsertException() { for (WritableLongList list: createWritableLongLists(ap(0, 10, 1))) { try { list.insert(-1, 10); fail(); } catch (IndexOutOfBoundsException ex) {} try { list.insert(15, 10); fail(); } catch (IndexOutOfBoundsException ex) {} } }
public void testUpdate() { int size = 100, maxVal = Integer.MAX_VALUE; for (int attempt = 0; attempt < 10; attempt++) { long[] array = generateRandomLongArray(size, UNORDERED, maxVal).extractHostArray(); for (WritableLongList list: createWritableLongLists(array)) { long[] values = Arrays.copyOf(array, array.length); if (!(list instanceof AbstractWritableLongList)) return; AbstractWritableLongList abstractList = (AbstractWritableLongList)list; int index = myRand.nextInt(size); abstractList.update(index, myRand.nextInt(), LongFunctions.NEG); values[index] = -values[index]; CHECK.order(abstractList, values); int count = myRand.nextInt(size); long value = myRand.nextInt(); abstractList.update(size + count, value, LongFunctions.NEG); assertEquals(size + count + 1, abstractList.size()); CHECK.order(abstractList.subList(0, size), values); int newSize = abstractList.size() - 1; CHECK.order(LongCollections.repeat(value, count), abstractList.subList(size, newSize)); assertEquals(abstractList.get(size + count), -value); } } }
public void testRemoveLast() { int size = 10, maxVal = Integer.MAX_VALUE; for (int attempt = 0; attempt < 10; attempt++) { LongArray expected = generateRandomLongArray(size, UNORDERED, maxVal); long[] array = new long[expected.size() + 1]; expected.toNativeArray(0, array, 0, expected.size()); for (WritableLongList list: createWritableLongLists(array)) { if (!(list instanceof AbstractWritableLongList)) return; AbstractWritableLongList abstractList = (AbstractWritableLongList)list; abstractList.removeLast(); CHECK.order(expected, abstractList); } } }
public void testSetRange() { for (WritableLongList list: createWritableLongLists(ap(0, 20, 1))) { long[] expected = ap(0, 20, 1); list.setRange(0, 5, -1); for (int i = 0; i < 5; i++) { expected[i] = -1; } checkList(list, expected); list.setRange(5, 10, 4); for (int i = 5; i < 10; i++) { expected[i] = 4; } checkList(list, expected); } }
public void testIteratorWrite() { long[] values = {1, 1, 1, 2, 2, 3, 3, 3, 3}; LongArray expected = LongArray.create(values); for (WritableLongList source : createWritableLongLists(values)) { LongArray result = new LongArray(); for (WritableLongListIterator it : source.write()) { result.add(it.value()); it.set(0, -1); } CHECK.order(source, LongCollections.repeat(-1, source.size())); assertEquals(expected, result); } }
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 testRemove() { for (WritableLongList list: createWritableLongLists(ap(1, 10, 1))) { checkCollection(list, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10); list.remove(5); checkCollection(list, 1, 2, 3, 4, 6, 7, 8, 9, 10); list.removeRange(6, 8); checkCollection(list, 1, 2, 3, 4, 6, 7, 10); list.removeRange(5, 7); checkCollection(list, 1, 2, 3, 4, 6); list.removeRange(0, 3); checkCollection(list, 4, 6); list.removeRange(0, 2); checkCollection(list); } }
public void testExpandException() { for (int size = 0; size < 5; size++) { for (WritableLongList list: createWritableLongLists( LongCollections.repeat(10, size).toNativeArray())) { try { list.expand(list.size() + 1, 0); fail(); } catch (IndexOutOfBoundsException ex) {} try { list.expand(-1, 0); fail(); } catch (IndexOutOfBoundsException ex) {} try { list.expand(0, -10); fail(); } catch (IllegalArgumentException ex) {} if (size > 0) { list.expand(1, 0); CHECK.order(LongCollections.repeat(10, size), list); } } } }
public void testIteratorRemove3() { for (WritableLongList list: createWritableLongLists(ap(0, 10, 1))) { WritableLongListIterator it = list.iterator(); it.next().next(); it.remove(); checkJustRemoved(it); assertEquals(2, it.nextValue()); it.move(7); assertEquals(9, it.value()); it.remove(); assertFalse(it.hasValue()); checkCollection(list, 0, 2, 3, 4, 5, 6, 7, 8); } }