public void init(LongArray values) { length = values.size(); arr = values.toNativeArray(); }
public void init(LongArray values) { list = createLongListVariants(values.toNativeArray()).get(0); }
public void order(LongIterator actual, long ... expected) { order(LongCollections.collectIterable(expected.length, actual).toNativeArray(), expected); }
public void testFromCollection() { List<Long> l = new ArrayList<Long>(); l.add(2L); l.add(3L); l.add(9L); LongArray a = LongArray.create(l); CHECK.order(a.toNativeArray(), 2, 3, 9); LongList il = LongCollections.asLongList(l); CHECK.order(il.toNativeArray(), 2, 3, 9); }
public void testToWritableSortedUnique() { long[][] arrays = {{}, {0}, {0, 1, 2}, {Long.MIN_VALUE, 0, Long.MAX_VALUE}, {0, 1, 2, 3, 4}, {0, 0, 1, 2, 3}, {0, 1, 2, 2, 3, 4}, {0, 1, 2, 3, 4, 4}}; for (long[] array : arrays) { checkToWritableSortedUnique(array); } for (int attempt = 0; attempt < 10; attempt++) { LongArray array = generateRandomLongArray(100, UNORDERED, 150); checkToWritableSortedUnique(array.toNativeArray()); array.sort(); checkToWritableSortedUnique(array.toNativeArray()); array.removeDuplicates(); checkToWritableSortedUnique(array.toNativeArray()); } }
public void testAddThis() { int arraySize = 100; for (int attempt = 0; attempt < 10; attempt++) { for (WritableLongList list: empty()) { LongArray values = generateRandomLongArray(arraySize, UNORDERED); long[] nativeArray = new long[arraySize * 2]; values.toNativeArray(0, nativeArray, 0, arraySize); values.toNativeArray(0, nativeArray, arraySize, arraySize); list.addAll(values); list.addAll(list); checkCollection(list, nativeArray); } } }
protected void checkCollectionM(LongList collection, long[]... ints) { LongArray t = new LongArray(); for (long[] ar : ints) { t.addAll(ar); } checkCollection(collection, t.toNativeArray()); }
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); }
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); }
public void testMap() { int attemptsCount = 10; int size = 200; int maxVal = 10000; for (int attempt = 0; attempt < attemptsCount; attempt++) { LongArray values = generateRandomLongArray(size, UNORDERED, maxVal); LongToLong[] functions = {LongFunctions.SQR, LongFunctions.INC, LongFunctions.DEC, LongFunctions.NEG}; for (LongToLong fun : functions) { long[] expected = values.toNativeArray(); for (int i = 0; i < expected.length; i++) { expected[i] = fun.invoke(expected[i]); } checkCollection(LongCollections.map(fun, values), expected); } } } }
@Override public long[] generateValues(Random random, int size) { LongArray array = generateRandomLongArray(random, size, SortedStatus.SORTED); array.addAll(array.get(IntProgression.range(0, size, 3))); array.sort(); return array.toNativeArray(); }
public void testAddRandom() { for (int i = 0; i < 20; i++) { // replace 100 with 20 to make test run faster on build agent int size = myRand.nextInt(16000) + 10; int factor = myRand.nextInt(10) + 1; int count = size * factor / 2; LongArray set = new LongArray(); LongSetBuilder builder = new LongSetBuilder(5); for (int j = 0; j < count; j++) { int v = myRand.nextInt(size); set.add(v); builder.add(v); } assertEquals(count, set.size()); set.sortUnique(); CHECK.order(builder.commitToArray().iterator(), set.toNativeArray()); } }
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 testAddAllRandom() { int elementsCount = 300; for (int i = 0; i < 3; i++) { int size = myRand.nextInt(1600) + 10; int factor = myRand.nextInt(10) + 1; int count = size * factor / 2; LongArray set = new LongArray(); LongSetBuilder builder = new LongSetBuilder(100); for (int j = 0; j < count; j++) { LongArray v = generateRandomLongArray(elementsCount, IntegersFixture.SortedStatus.UNORDERED, size); set.addAll(v); builder.addAll(v); } assertEquals(elementsCount * count, set.size()); set.sortUnique(); CHECK.order(builder.commitToArray().iterator(), set.toNativeArray()); } }
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 testToSorted() { int arrLength = 100; int maxVal = 300; int attempts = 10; LongArray expected; LongArray arr; for (int attempt = 0; attempt < attempts; attempt++) { if (attempt != attempts - 1) { arr = generateRandomLongArray(arrLength, UNORDERED, maxVal); } else { arr = new LongArray(); } expected = LongArray.copy(arr); expected.sort(); CHECK.order(LongCollections.toSorted(false, arr), expected); CHECK.order(LongCollections.toSortedNativeArray(arr), expected.toNativeArray()); expected.sortUnique(); CHECK.order(LongCollections.toSorted(true, arr), expected); CHECK.order(LongCollections.toSortedUnique(arr), expected); CHECK.order(LongCollections.toSortedUnique(arr.toNativeArray()), expected); } }
public void testValueComplexCase() { IntArray keys = new IntArray(IntProgression.arithmetic(0, 1000, 1)); LongArray values0 = new LongArray(LongProgression.arithmetic(0, 1000, 1)); LongArray values = new LongArray(values0.toNativeArray()); values.apply(0, 1000, new LongToLong() { @Override public long invoke(long a) { return a * a - a; } }); res = IntLongIterators.pair(keys.iterator(), values.iterator()); for (int i = 0; i < 1000; i++) { res.next(); int v1 = res.left(); long v2 = res.right(); assertEquals(i, v1); assertEquals(i * i - i, v2); } } }
public void testAddAll() { LongArray expected = LongArray.create(ap(1, 10, 2)); set.addAll(expected); checkSet(set, expected); expected.addAll(ap(0, 10, 2)); set.addAll(expected.toNativeArray()); expected.sortUnique(); checkSet(set, expected); set.removeAll(expected); assertTrue(set.isEmpty()); expected = generateRandomLongArray(10, UNORDERED); set.addAll(expected.iterator()); expected.sortUnique(); checkSet(set, expected); }
public void testReverse() { testReverse(new long[]{}, new long[]{}); testReverse(new long[]{4, 4, 1, 2, 2, 2, 3, 3, 3, 3}, new long[]{3, 3, 3, 3, 2, 2, 2, 1, 4, 4}); testReverse(new long[]{4, 4, 1, 2, 2, 2, 0, 0, 0, 0}, new long[]{0, 0, 0, 0, 2, 2, 2, 1, 4, 4}); testReverse(new long[]{2, 4, 4, 5, 5, 5, 7, 7, 7, 7}, new long[]{7, 7, 7, 7, 5, 5, 5, 4, 4, 2}); testReverse(new long[]{2, 2, 3, 3, 3}, new long[]{3, 3, 3, 2, 2}); testReverse(new long[]{1, 1, 1}, new long[]{1, 1, 1}); testReverse(new long[]{1, 1, 0}, new long[]{0, 1, 1}); testReverse(new long[]{0}, new long[]{0}); testReverse(new long[]{0, 1, 3, 6, 10, 15, 21, 28, 36}, new long[]{36, 28, 21, 15, 10, 6, 3, 1, 0}); testReverse(new long[]{0, 1, 3, 6, 10, 15, 21, 28, 36}, new long[]{36, 28, 21, 15, 10, 6, 3, 1, 0}); testReverse(new long[]{0, 0, 1, 2, 2, 2, 3, 3, 3, 3}, new long[]{3, 3, 3, 3, 2, 2, 2, 1, 0, 0}); testReverse(new long[]{0, 0, 1, 2, 2, 2, 0, 0, 0, 0}, new long[]{0, 0, 0, 0, 2, 2, 2, 1, 0, 0}); testReverse(new long[]{0, 0, 0}, new long[]{0, 0, 0}); testReverse(new long[]{0, 0, 0, 1, 1}, new long[]{1, 1, 0, 0, 0}); testReverse(new long[]{0, 0, 0, 0, 1, 1, 0}, new long[]{0, 1, 1, 0, 0, 0, 0}); // have to use toNativeArray() instead of extractHostArray(), because of in the myArray may be duplicates for (WritableLongList list: createWritableLongLists(generateRandomLongArray(20, SORTED_UNIQUE, 200).toNativeArray())) { list.reverse(); for (int i = 1; i < list.size(); i++) { assertFalse(list.get(i - 1) <= list.get(i)); } } }
public void testPutAllRemoveAllSimple() { LongArray keys = new LongArray(LongProgression.arithmetic(1, 10, 2)); IntList values = getSqrValues(keys); map.putAll(keys, values); checkMap(map, keys, values); try { map.putAll(keys, values.subList(0, values.size() - 1)); fail(); } catch (IllegalArgumentException _) { // ok } checkMap(map, keys, values); keys.addAll(LongProgression.arithmetic(0, 10, 2)); values = getSqrValues(keys); map.putAll(keys.toNativeArray(), values.toNativeArray()); checkMap(map, keys, values); map.removeAll(keys); assertTrue(map.isEmpty()); keys = generateRandomLongArray(10, UNORDERED); values = getSqrValues(keys); map.putAll(LongIntIterators.pair(keys.iterator(), values.iterator())); checkMap(map, keys, values); }