@Override protected LongTreeSet createSet(LongList sortedUniqueList) { return LongTreeSet.createFromSortedUnique(sortedUniqueList); }
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); } }
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 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); } }
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 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)); } }
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 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)); }