public LongIterable get(LongArray ... arrays) { LongArray expected = new LongArray(); for (int i = 0; i < arrays[0].size(); i++) { boolean exist = true; long value = arrays[0].get(i); for (int j = 1; j < arrays.length && exist; j++) { if (isSorted) { if (arrays[j].binarySearch(value) < 0) exist = false; } else { if (!arrays[j].contains(value)) exist = false; } } if (exist) expected.add(value); } expected.sortUnique(); return expected; } }
public void testCreateSimple() { int count = 4; LongArray values = LongArray.create(0, 2, 4); LongArray expected = new LongArray(values.size() * count); for (int i = 0; i < values.size(); i++) { expected.addAll(LongCollections.repeat(values.get(i), count)); } list = LongSameValuesList.create(values, IntCollections.repeat(4, values.size())); CHECK.order(expected, list); expected = LongArray.create(1, 1, 2, 2, 3, 3, 3, 3, 3, 4); list = LongSameValuesList.create(expected); CHECK.order(expected, list); }
public void testAddAllNotMore() { array.addAllNotMore(LongArray.create(3, 4, 10, 20), 2); CHECK.order(LongArray.create(3, 4), array); array.addAllNotMore(LongArray.create(5, 6, 10, 20), 2); CHECK.order(LongArray.create(3, 4, 5, 6), array); assertEquals(2, array.addAllNotMore(LongArray.create(10, 20, 30, 50, 100).iterator(), 2)); CHECK.order(LongArray.create(3, 4, 5, 6, 10, 20), array); assertEquals(1, array.addAllNotMore(LongArray.create(30).iterator(), 4)); CHECK.order(LongArray.create(3, 4, 5, 6, 10, 20, 30), array); assertEquals(7, array.addAllNotMore(array, 20)); CHECK.order(LongArray.create(3, 4, 5, 6, 10, 20, 30, 3, 4, 5, 6, 10, 20, 30), array); assertEquals(0, array.addAllNotMore(LongIterator.EMPTY, 2)); CHECK.order(LongArray.create(3, 4, 5, 6, 10, 20, 30, 3, 4, 5, 6, 10, 20, 30), array); }
@Override public LongIterable get(LongArray... arrays) { LongArray res = LongArray.copy(arrays[0]); res.retainSorted(arrays[1]); res.sortUnique(); return res; } }, new SetOperationsChecker.IntersectionGetter(true), true, UNORDERED, SORTED);
@Override public LongIterable get(LongArray... arrays) { LongArray copy = LongArray.copy(arrays[0]); copy.ensureCapacity(arrays[0].size() + arrays[1].size()); copy.mergeWithSameLength(arrays[1]); return copy; } }, unionGetter, true, SORTED_UNIQUE);
public void testRandom(int maxVal, int setSize, int listSize, int nAttempts) { LongArray toAdd = new LongArray(listSize); for (int attempt = 0; attempt < nAttempts; ++attempt) { if (attempt % 3 == 0) set = createSet(); LongArray expected = generateRandomLongArray(setSize, UNORDERED, maxVal); set.clear(); set.addAll(expected); expected.sortUnique(); checkSet(set, expected); toAdd.clear(); toAdd.addAll(generateRandomLongArray(listSize, SORTED_UNIQUE, maxVal)); for (LongIterator it: set) { toAdd.removeAllSorted(it.value()); } set.addAll(toAdd); LongArray expected2 = LongArray.copy(expected); expected2.merge(toAdd); checkSet(set, expected2); set.removeAll(toAdd); checkSet(set, expected); } }
public void testContains2() { int arSize = 45, maxVal = Integer.MAX_VALUE, attempts = 10; for (int attempt = 0; attempt < attempts; attempt++) { LongArray arr = generateRandomLongArray(arSize, SORTED_UNIQUE, maxVal); LongArray arr2 = LongCollections.collectLists(arr, map(LongFunctions.INC, arr), map(LongFunctions.DEC, arr)); arr2.sortUnique(); for (WritableLongSet curSet : createSets(arr)) { for (int i = 0; i < arr2.size(); i++) { long value = arr2.get(i); assertEquals(arr.binarySearch(value) >= 0, curSet.contains(value)); } } } }
public void checkRetain(LongList list, LongList values, boolean isSorted) { LongArray array = new LongArray(list); LongArray expected = new LongArray(array.size()); for (int i = 0; i < array.size(); i++) { long value = array.get(i); if ((isSorted && values.binarySearch(value) >= 0) || (!isSorted && values.contains(value))) { expected.add(value); } } if (isSorted) { array.retainSorted(values); } else { array.retain(values); } CHECK.order(expected, array); }
public void testToBoundedString() { LongArray array = new LongArray(); array.addAll(LongIterators.range(10)); checkToBoundedString("(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)", 5, array); array.add(10); checkToBoundedString("[11] (0, 1, 2, 3, 4, ..., 6, 7, 8, 9, 10)", 5, array); array.addAll(LongIterators.range(11, 21)); checkToBoundedString("[21] (0, 1, 2, 3, 4, ..., 16, 17, 18, 19, 20)", 5, array); array.addAll(LongIterators.range(21, 40)); StringBuilder expected = new StringBuilder().append("(0"); for (int i = 1; i < 40; i++) { expected.append(", ").append(i); } expected.append(')'); checkToBoundedString(expected.toString(), 20, array); array = LongArray.create(0, 1, 2, 3, 4); checkToBoundedString("[5] (0, 1, ..., 3, 4)", 2, array); }
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 testFromSortedList() throws Exception { int testNumber = 10; int arraySize = 10000; for (int i = 0; i < testNumber; i++) { LongArray res = generateRandomLongArray(arraySize, SORTED_UNIQUE); LongArray res2 = new LongArray(res.size() * 3 + 1); for (int j = 0, n = res.size(); j < n; j++) { long val = res.get(j); res2.addAll(val - 1, val, val + 1); } res2.sortUnique(); for (LongSet set : createSets(res)) { for (int j = 0; j < res2.size(); j++) { long val = res2.get(j); assertEquals(res.binarySearch(val) >= 0, set.contains(val)); } } } }
public void testSortPairs() { try { LongCollections.sortPairs(LongArray.create(0, 1, 2), LongArray.create(10, 20)); fail(); } catch (IllegalArgumentException e) {} int attempts = 10; int len = 100; int maxVal = 200; for (int attempt = 0; attempt < attempts; attempt++) { LongArray[] actual = new LongArray[2]; for (int i = 0; i < 2; i++) { actual[i] = generateRandomLongArray(len, UNORDERED, maxVal); } LongArray expected = new LongArray(len); for (int i = 0; i < len; i++) { expected.add(actual[0].get(i) * maxVal + actual[1].get(i)); } expected.sort(); LongCollections.sortPairs(actual[0], actual[1]); for (int i = 0; i < len; i++) { assertEquals(expected.get(i), actual[0].get(i) * maxVal + actual[1].get(i)); } } }
public void testTailIteratorRandom() { if (!isSortedSet()) return; final int size = 200, testCount = 5; LongArray expected; LongArray testValues; for (int i = 0; i < testCount; i++) { expected = new LongArray(LongIterators.limit(randomIterator(), size)); expected.sortUnique(); testValues = LongCollections.collectLists( expected, map(LongFunctions.INC, expected), map(LongFunctions.DEC, expected)); testValues.sortUnique(); for (T set0 : createSets(expected)) { LongSortedSet sortedSet = (LongSortedSet) set0; for (int j = 0; j < testValues.size(); j++) { long key = testValues.get(j); int ind = expected. binarySearch(key); CHECK.order(sortedSet.tailIterator(key), expected.iterator(ind >= 0 ? ind : -ind - 1)); } } } }
@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 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 testToSortedSimple() { int arrLength = 10; LongArray arr = new LongArray(LongProgression.arithmetic(0, arrLength, 1)); arr.add(arrLength++); for (int i = 0; i < arrLength; i++) { LongList expected = arr.subList(i, arr.size()); for (boolean uniqueStatus: new boolean[]{false, true}) { LongList actual = LongCollections.toSorted(uniqueStatus, arr.subList(i, arr.size()).iterator()); CHECK.order(actual, expected); actual = LongCollections.toSorted(uniqueStatus, arr.subList(i, arr.size())); CHECK.order(actual, expected); } } }
public void testAdd() { int attempts = 12; int addCount = 100, maxVal = Integer.MAX_VALUE; LongArray expected = new LongArray(addCount); for (int attempt = 0; attempt < attempts; attempt++) { if (attempt % 3 == 0) set = createSet(); set.clear(); expected.clear(); for (int i = 0, n = myRand.nextInt(addCount); i < n; i++) { int value = myRand.nextInt(maxVal); set.add(value); expected.add(value); } expected.sortUnique(); checkSet(set, expected); } }
public void testAdd() { LongSetBuilder b = new LongSetBuilder(); assertTrue(b.isEmpty()); for (int i = 0; i < 8; i++) { b.add(i * 2); } assertFalse(b.isEmpty()); b.addAll(10, 100, 200); b.addAll(LongArray.create(-5, 9, 3)); b.addAll(LongArray.create(7, 15, 4).iterator()); LongArray expected = LongArray.create(); for (int i = 0; i < 8; i++) { expected.add(i * 2); } expected.addAll(10, 100, 200, -5, 9, 3, 7, 15, 4); expected.sortUnique(); LongList collection = b.toList(); CHECK.order(collection.iterator(), expected.iterator()); }