@Override public int size() { return keys.size(); }
public int size() { return list.size(); }
private void check(LongList expectedValues) { assertEquals(expectedValues.size(), set.size()); checkSet(set, expectedValues); } });
@Override protected List<LongChainHashSet> createSets(LongList sortedUniqueList) { List<LongChainHashSet> sets = new ArrayList<LongChainHashSet>(); sets.add(LongChainHashSet.createFrom(sortedUniqueList)); set = LongChainHashSet.createForAdd(sortedUniqueList.size(), 0.5f); set.addAll(sortedUniqueList); sets.add(set); return sets; }
@Override protected List<LongOpenHashSet> createSets(LongList sortedUniqueList) { List<LongOpenHashSet> sets = new ArrayList<LongOpenHashSet>(); sets.add(LongOpenHashSet.createFrom(sortedUniqueList)); set = LongOpenHashSet.createForAdd(sortedUniqueList.size(), 0.5f); set.addAll(sortedUniqueList); sets.add(set); return sets; }
private int getChangeCount(LongList expected) { int changeCount = 0; for (int i = 1; i < expected.size(); i++) { if (expected.get(i) != expected.get(i - 1)) changeCount++; } return changeCount; }
@Override protected List<WritableLongIntMapProjection> createSets(LongList sortedUniqueList) { IntList repeatContains = repeat(DEFAULT_CONTAINS_VALUE, sortedUniqueList.size()); List<T> maps = createMapsFromLists(sortedUniqueList, repeatContains); List<WritableLongIntMapProjection> sets = new ArrayList(); for (T map0 : maps) { sets.add(new WritableLongIntMapProjection(map0)); } return sets; }
private IntIterator getNextDifferentValueIndex(LongList list) { WritableIntList resultingIndices = new IntArray(); for (int i = 0; i < list.size(); i = list.getNextDifferentValueIndex(i)) { assertTrue("exceeded the list size!", i < list.size()); resultingIndices.add(i); } return resultingIndices.iterator(); }
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)); }
@Override protected WritableLongIntMapProjection createSet(LongList sortedUniqueList) { T map0 = createMap(); map0.putAll(sortedUniqueList, repeat(DEFAULT_CONTAINS_VALUE, sortedUniqueList.size())); return new WritableLongIntMapProjection(map0); }
@Override protected LongSet createSet(LongList sortedUniqueList) { LongIntMap map = new LongIntListMap( new LongArray(sortedUniqueList), new IntArray(repeat(0, sortedUniqueList.size()))); return map.keySet(); }
protected void checkGetMethods(long... values) { LongList expected = LongArray.create(values); for (LongList arr : createLongListVariants(values)) { for (int i = 0; i < arr.size(); i++) { assertEquals(expected.get(i), arr.get(i)); } for (int i = 0; i < arr.size(); i++) { for (int j = -1; j < 2; j++) { long value = arr.get(i) + j; assertEquals(expected.indexOf(value), arr.indexOf(value)); assertEquals(expected.contains(value), arr.contains(value)); } } } }
public void checkMap(T map, LongList keys, IntList values) { assertEquals(keys.size(), map.size()); assertEquals(keys.isEmpty(), map.isEmpty()); for (int i = 0; i < keys.size(); i++) { assertEquals(values.get(i), map.get(keys.get(i))); } LongArray mapKeys = collectIterable(map.size(), map.keysIterator()); CHECK.unordered(mapKeys, keys); IntArray mapValues = IntCollections.collectIterable(map.size(), map.valuesIterator()); CHECK.unordered(mapValues, values); }
public void testGet() { for (int attempt = 0; attempt < 10; attempt++) { long[] values = generateRandomLongArray(1000, UNORDERED).extractHostArray(); for (LongList list: createLongListVariants(values)) { if (!(list instanceof AbstractLongList)) return; IntArray indices = generateRandomIntArray(100, UNORDERED, 0, 1000); AbstractLongList abstractList = (AbstractLongList)list; LongList actual = abstractList.get(indices); for (int j = 0; j < actual.size(); j++) { assertEquals(abstractList.get(indices.get(j)), actual.get(j)); } } } }
public void testGetNextDifferentValueIndex() { for (LongList arr : createLongListVariants(0, 1, 1, 2, 2, 2, 3, 4, 5, 5, 5)) { assertEquals(1, arr.getNextDifferentValueIndex(0)); assertEquals(3, arr.getNextDifferentValueIndex(1)); assertEquals(6, arr.getNextDifferentValueIndex(3)); assertEquals(7, arr.getNextDifferentValueIndex(6)); assertEquals(arr.size(), arr.getNextDifferentValueIndex(8)); } }
public void testToNativeArray2() { for (T set : createSets(LongProgression.range(20, 40))) { long[] ar = new long[40]; set.toNativeArray(ar, 3); LongArray actual = new LongArray(new LongArray(ar).subList(3, 23)); LongList expected = LongProgression.range(20, 40); CHECK.unordered(actual, expected); set.removeAll(LongIterators.range(20, 40, 2)); set.toNativeArray(ar, 4); expected = LongProgression.range(21, 40, 2); actual = new LongArray(new LongArray(ar).subList(4, 4 + expected.size())); CHECK.unordered(actual, expected); } }