public void testEdgeCasesWithCompactify() { set = new LongTreeSet(); assertFalse(set.exclude(MIN)); assertFalse(set.exclude(0)); set.removeAll(12, 23, 12, 51); assertTrue(set.isEmpty()); set.compactify(); assertTrue(set.isEmpty()); LongList ll = new LongArray(); LongTreeSet set2 = LongTreeSet.createFromSortedUnique(ll); assertTrue(set2.isEmpty()); set.addAll(1, 3, 2, MIN, Long.MAX_VALUE); assertTrue(new LongArray(set.toArray()).isSorted(true)); assertTrue(set.contains(1)); assertTrue(set.contains(MIN)); assertFalse(set.contains(0)); set.clear(); set.add(MIN); assertTrue(set.contains(MIN)); assertFalse(set.contains(MIN + 1)); assertFalse(set.contains(0)); }
protected List<LongTreeSet> createSets(LongList sortedUniqueList) { set = new LongTreeSet(); set.addAll(sortedUniqueList); LongTreeSet set2 = new LongTreeSet(); set2.addAll(sortedUniqueList.iterator()); return Arrays.asList(set, set2, LongTreeSet.createFromSortedUnique(sortedUniqueList), LongTreeSet.createFromSortedUnique(sortedUniqueList, sortedUniqueList.size(), TO_ADD), LongTreeSet.createFromSortedUnique(sortedUniqueList, sortedUniqueList.size(), TO_REMOVE)); }
public void testRetainSimple2() { set = new LongTreeSet(); set.addAll(range(20)); set.removeAll(range(0, 20, 2)); checkSet(set, range(1, 20, 2)); set = new LongTreeSet(); for (int i = 0; i < 2; i++) { set.addAll(range(2, 25, 2)); set.retain(LongTreeSet.createFromSortedUnique(range(3, 25, 3))); checkSet(set, range(6, 25, 6)); set.clear(); } } }
public void testRandom2() { int setSize = 510, listSize = 510; int nAttempts = 10; LongArray toAdd = new LongArray(listSize); for (int attempt = 0; attempt < nAttempts; ++attempt) { LongTreeSet treeSet = new LongTreeSet(setSize); LongArray expected = generateRandomLongArray(setSize, IntegersFixture.SortedStatus.UNORDERED); treeSet.addAll(expected); expected.sortUnique(); toAdd.clear(); toAdd.addAll(generateRandomLongArray(listSize, IntegersFixture.SortedStatus.SORTED_UNIQUE)); for (LongIterator it: treeSet) { toAdd.removeAllSorted(it.value()); } treeSet.addAll(toAdd); treeSet.removeAll(toAdd); treeSet.compactify(); CHECK.order(expected, treeSet.toArray()); } }
@Override protected LongTreeSet createSet(LongList sortedUniqueList) { return LongTreeSet.createFromSortedUnique(sortedUniqueList); }
protected LongTreeSet createSetWithCapacity(int capacity) { LongTreeSet newSet; newSet = capacity == -1 ? new LongTreeSet() : new LongTreeSet(capacity); try { setFinalStatic(newSet, "SHRINK_FACTOR", 6); setFinalStatic(newSet, "SHRINK_MIN_LENGTH", 4); Field field = newSet.getClass().getDeclaredField("SHRINK_FACTOR"); field.setAccessible(true); return newSet; } catch (Exception ex) { return new LongTreeSet(); } }
public void testStaticConstructorsRandom() { int listSize = 510, nAttempts = 12; LongTreeSet.ColoringType[] types = {TO_ADD, TO_REMOVE, BALANCED}; for (int attempt = 0; attempt < nAttempts; attempt++) { LongArray sortedUniqueArray = generateRandomLongArray(listSize, IntegersFixture.SortedStatus.SORTED_UNIQUE); if (attempt % 4 == 0) { set = LongTreeSet.createFromSortedUnique(sortedUniqueArray); } else { set = LongTreeSet.createFromSortedUnique( sortedUniqueArray.iterator(), myRand.nextInt(listSize * 2), types[attempt % 4 - 1]); } checkSet(set, sortedUniqueArray); } }
public void testConstructors() { int attemptsCount = 10; // more than 512 int size = 600; for (int attempt = 0; attempt < attemptsCount; attempt++) { // LongAmortizedSet.createFromSortedUnique LongArray res = generateRandomLongArray(size, SORTED_UNIQUE); set = LongAmortizedSet.createFromSortedUnique(res); checkSet(set, res); set.coalesce(); checkSet(set, res); // LongAmortizedSet.createFromSortedUniqueArray res = generateRandomLongArray(size, SORTED_UNIQUE); LongArray expected = LongArray.copy(res); set = LongAmortizedSet.createFromSortedUniqueArray(res); checkSet(set, expected); set.coalesce(); checkSet(set, expected); // LongAmortizedSet(WritableLongSortedSet, WritableLongSet, int) set = new LongAmortizedSet(0, new LongTreeSet(), new LongTreeSet(), 128); set.addAll(expected); checkSet(set, expected); set.coalesce(); checkSet(set, expected); } }
public void testStaticConstructorsSimple() { for (LongArray array : LongCollections.allSubLists(LongArray.create(Long.MIN_VALUE, Long.MIN_VALUE + 1, -1, 0, 1, Long.MAX_VALUE))) { checkSet(LongTreeSet.createFromSortedUnique(array), array); } }
set = new LongAmortizedSet(new LongTreeSet(), new LongTreeSet()); set.addAll(sortedUniqueList); sets.add(set);
public void checkToBoundedString(String expected, int lim, LongArray array) { WritableLongSet set = LongTreeSet.createFromSortedUnique(array); LongIterable[] iterables = {array, set, array.iterator(), set.iterator(), LongIterators.unionIterator(array, array.subList(0, 1))}; for (LongIterable iterable : iterables) { assertEquals(iterable.toString(), expected, LongCollections.toBoundedString(iterable, lim)); } }
public void testIntersectionUnionSets() { int attempts = 10, maxVal = Integer.MAX_VALUE, size = 1000; WritableLongSet[][] allSets = {{new LongTreeSet(), new LongOpenHashSet()}, {new LongTreeSet(), new LongOpenHashSet()}}; LongArray[] arrays = new LongArray[2]; LongArray expected, actual; for (int attempt = 0; attempt < attempts; attempt++) { for (WritableLongSet set0: allSets[0]) { for (WritableLongSet set1: allSets[1]) { WritableLongSet[] sets = {set0, set1}; for (int j = 0; j < 2; j++) { arrays[j] = generateRandomLongArray(size, IntegersFixture.SortedStatus.SORTED_UNIQUE, maxVal); sets[j].clear(); sets[j].addAll(arrays[j]); } expected = LongArray.copy(arrays[0]); expected.retain(arrays[1]); IntegersFixture.checkSet(toSortedIntersection(sets[0], sets[1]), expected); IntegersFixture.checkSet(intersection(sets[0], sets[1]), expected); expected = LongArray.copy(arrays[0]); expected.merge(arrays[1]); IntegersFixture.checkSet(union(sets[0], sets[1]), expected); } } } }
public void testUnionSortedSets() { int maxSize = 1000, attemptsCount = 30; WritableLongSet[] sets = new WritableLongSet[2]; LongArray[] arrays = new LongArray[2]; LongArray expected, actual; for (int attempt = 0; attempt < attemptsCount; attempt++) { for (int j = 0; j < 2; j++) { arrays[j] = generateRandomLongArray(maxSize, IntegersFixture.SortedStatus.SORTED_UNIQUE); sets[j] = (myRand.nextBoolean()) ? LongTreeSet.createFromSortedUnique(arrays[j]) : LongOpenHashSet.createFrom(arrays[j]); } expected = new LongArray(maxSize * 2); expected.addAll(arrays[0]); expected.merge(arrays[1]); actual = toSortedUnion(sets[0], sets[1]).toArray(); CHECK.order(expected, actual); } }
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)); } }