public void unordered(LongList actual, LongList expected) { unordered(actual.toNativeArray(), expected.toNativeArray()); }
public void unordered(LongList actual, LongList expected) { unordered(actual.toNativeArray(), expected.toNativeArray()); }
public void order(LongList expected, LongList actual) { order(actual.toNativeArray(), expected.toNativeArray()); }
public void order(LongList actual, long ... expected) { order(actual.toNativeArray(), expected); }
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()); } }
@Override public long[] generateValues(Random random, int size) { return LongCollections.asLongList(generateRandomIntArray(random, size, SortedStatus.UNORDERED)).toNativeArray(); }
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 testToNativeArray() { int attemptsCount = 5, length = 25; for (int attempt = 0; attempt < attemptsCount; attempt++) { long[] values = generateRandomLongArray(length, UNORDERED).extractHostArray(); for (T list : createLongListVariants(values)) { for (int startIdx = 0; startIdx < length; startIdx++) { for(int endIdx = startIdx + 1; endIdx < length; endIdx++) { long[] expected = LongCollections.repeat(-1, length).toNativeArray(); long[] actual = Arrays.copyOf(expected, expected.length); int len = endIdx - startIdx; System.arraycopy(values, startIdx, expected, startIdx, len); list.toNativeArray(startIdx, actual, startIdx, len); CHECK.order(actual, expected); } } } } }
public void testToNativeArray() { int start = 10, step = 3, count = 31; long[] values = new long[count]; for (int i = 0; i < count; i++) values[i] = start + step * i; LongProgression list = LongProgression.arithmetic(start, count, step); for (int startIdx = 0; startIdx < count; startIdx++) { for (int endIdx = startIdx + 1; endIdx < count; endIdx++) { long[] expected = LongCollections.repeat(-1, count).toNativeArray(); long[] actual = LongCollections.repeat(-1, count).toNativeArray(); int len = endIdx - startIdx; System.arraycopy(values, startIdx, expected, startIdx, len); list.toNativeArray(startIdx, actual, startIdx, len); CHECK.order(actual, expected); } } } }
public void testCreateListAccessor() { myList.insert(0, 0, 1); myList.insert(1, 2, 3); myList.insert(2, 4, 5); checkStorage(0, 1, 2, 3, 4, 5); LongList values = myList.createListAccessor(0); long[] res = values.toNativeArray(); long[] expected = {0, 2, 4}; CHECK.order(res, expected); }
public void testRepeat() { LongList array = LongCollections.repeat(-5, 3); CHECK.order(array, -5, -5, -5); array = LongCollections.repeat(0, 4); CHECK.order(array, 0, 0, 0, 0); assertEquals(0, LongCollections.repeat(3, 0).size()); long[] expected = new long[10]; Arrays.fill(expected, 3, 10, -1); long[] actual = new long[10]; LongCollections.repeat(-1, 10).toNativeArray(3, actual, 3, 7); CHECK.order(expected, actual); try { LongCollections.repeat(3, -1); fail("must throw IAE"); } catch(IllegalArgumentException ex) { // ok } }
prefix.toNativeArray(0, r, 0, prefix.size()); suffix.toNativeArray(0, r, r.length - suffix.size(), suffix.size());
public void testPutRandom() { final int N_KEYS = 1000; LongArray keySet = new LongArray(N_KEYS); int prime0 = 47; for (int n = 0; n < N_KEYS; ++n) { int key = myRand.nextInt(N_KEYS); boolean hasAdded = keySet.contains(key); assertEquals(hasAdded, map.containsKey(key)); if (!hasAdded) { int value = key % prime0; long added = map.put(key, value); assertEquals(value, added); keySet.add(key); } } keySet.sort(); compare.order(keySet.toNativeArray(), map.getKeys().toNativeArray()); checkMapValuesEqualKeysMod(prime0); int[] primes = new int[] { 53, 59, 61, 67, 71 }; int oldPrime = prime0; for (int prime : primes) { for (Long key : map.getKeys().toList()) { long put = map.put(key, key % prime); assertEquals("key=" + key + " | prime=" + prime, put, key % oldPrime); } compare.order(keySet.toNativeArray(), map.getKeys().toNativeArray()); checkMapValuesEqualKeysMod(prime); oldPrime = prime; } }
public void testInsertAllSimple() { map.insertAll(LongArray.create(0, 3, 1, 4, 2), LongArray.create(0, 30, 10, 40, 20)); for (int i = 0; i < 5; ++i) assertEquals(i*10, map.get(i)); map.clear(); assertEquals(0, map.size()); assertTrue(map.isEmpty()); assertEquals(0, map.put(0, 0)); assertEquals(50, map.put(5, 50)); assertEquals(80, map.put(8, 80)); compare.order(map.getKeys().toNativeArray(), 0, 5, 8); compare.order(map.getValues().toNativeArray(), 0, 50, 80); map.insertAll(LongArray.create(3, 7, 1, 4, 9, 2, 6), LongArray.create(30, 70, 10, 40, 90, 20, 60)); compare.order(map.getKeys().toNativeArray(), arithmetic(0, 10).toNativeArray()); for (int i = 0; i < 10; ++i) assertEquals(i*10, map.get(i)); map.clear(); map.insertAllRo(LongProgression.arithmetic(0, 10), LongProgression.arithmetic(0, 10, 10)); for (int i = 0; i < 10; ++i) assertEquals(i*10, map.get(i)); }
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 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); } }
protected void checkCollection(LongList collection, long... ints) { if (ints == null) ints = IntegersUtils.EMPTY_LONGS; CHECK.order(collection.toNativeArray(), ints); assertEquals(collection.size(), ints.length); CHECK.order(collection.iterator(), ints); assertEquals(ints.length, checker.index); long[] array = new long[ints.length - i + 1]; collection.toNativeArray(i, array, 1, collection.size() - i); CHECK.order(LongCollections.arrayCopy(array, 1, array.length - 1), LongCollections.arrayCopy(ints, i, ints.length - i));
public void testAddRemoveSimple2() { set.addAll(3, 1, 5, 2, 0, 4); LongList expected = LongProgression.arithmetic(0, 6); checkSet(set, expected); set.removeAll(expected.toNativeArray()); assertTrue(set.isEmpty()); set.clear(); set.addAll(1, 2, 5, 7, 8, 11, 14, 15); assertEquals(8, set.size()); set.remove(11); assertFalse(set.contains(11)); assertEquals(7, set.size()); set.remove(256); assertFalse(set.contains(256)); assertEquals(7, set.size()); set.removeAll(1,2,5); assertEquals(4, set.size()); }
public void testRemoveAllValues() { map.insertAllRo(LongProgression.arithmetic(0, 10), apply(swap(MOD), 3)); LongList notInMap; notInMap = map.removeAllValues(LongArray.create(2, 0)); compare.empty(notInMap.toNativeArray()); compare.order(map.getKeys().iterator(), 1, 4, 7); checkMapValuesEqualKeysMod(3); map.removeAllValues(LongArray.create(1)); assertEquals(0, map.size()); map.clear(); map.insertAllRo(LongProgression.arithmetic(0, 10, 2), apply(swap(MOD), 13)); // Important: specify one of the values not in the map notInMap = map.removeAllValues(LongArray.create(6, 7, 8, 9, 10)); compare.order(notInMap.iterator(), 7, 9); compare.order(map.getKeys().iterator(), 0, 2, 4, 12, 14, 16, 18); checkMapValuesEqualKeysMod(13); }