@Test
public void forEachWithIndexUsingFromToWithOptimisableList() {
ArrayList<Integer> optimisableList = Interval.oneTo(105).addAllTo(new ArrayList<Integer>());
final ArrayList<Integer> expected = Interval.oneTo(105).addAllTo(new ArrayList<Integer>());
ArrayList<Integer> results = new ArrayList<Integer>();
ArrayListIterate.forEachWithIndex(
optimisableList,
0,
104,
ObjectIntProcedures.fromProcedure(CollectionAddProcedure.on(results)));
Assert.assertEquals(expected, results);
MutableList<Integer> reverseResults = Lists.mutable.of();
final ObjectIntProcedure<Integer> objectIntProcedure =
ObjectIntProcedures.fromProcedure(CollectionAddProcedure.on(reverseResults));
ArrayListIterate.forEachWithIndex(expected, 104, 0, objectIntProcedure);
Assert.assertEquals(ListIterate.reverseThis(expected), reverseResults);
Verify.assertThrows(
IndexOutOfBoundsException.class,
new Runnable() {
public void run() {
ArrayListIterate.forEachWithIndex(expected, 104, -1, objectIntProcedure);
}
});
Verify.assertThrows(
IndexOutOfBoundsException.class,
new Runnable() {
public void run() {
ArrayListIterate.forEachWithIndex(expected, -1, 104, objectIntProcedure);
}
});
}
@Test
public void testForEachUsingSet() {
// Tests the default batch size calculations
IntegerSum sum = new IntegerSum(0);
MutableSet<Integer> set = Interval.toSet(1, 10000);
ParallelIterate.forEach(set, new SumProcedure(sum), new SumCombiner(sum));
Assert.assertEquals(50005000, sum.getSum());
// Testing batch size 1
IntegerSum sum2 = new IntegerSum(0);
UnifiedSet<Integer> set2 = UnifiedSet.newSet(Interval.oneTo(100));
ParallelIterate.forEach(
set2, new SumProcedure(sum2), new SumCombiner(sum2), 1, set2.getBatchCount(set2.size()));
Assert.assertEquals(5050, sum2.getSum());
// Testing an uneven batch size
IntegerSum sum3 = new IntegerSum(0);
UnifiedSet<Integer> set3 = UnifiedSet.newSet(Interval.oneTo(100));
ParallelIterate.forEach(
set3, new SumProcedure(sum3), new SumCombiner(sum3), 1, set3.getBatchCount(13));
Assert.assertEquals(5050, sum3.getSum());
// Testing divideByZero exception by passing 1 as batchSize
IntegerSum sum4 = new IntegerSum(0);
UnifiedSet<Integer> set4 = UnifiedSet.newSet(Interval.oneTo(100));
ParallelIterate.forEach(set4, new SumProcedure(sum4), new SumCombiner(sum4), 1);
Assert.assertEquals(5050, sum4.getSum());
}
@Before
public void setUp() {
this.dropIterable = new DropIterable<>(Interval.oneTo(5), 2);
this.emptyListDropIterable = new DropIterable<>(FastList.<Integer>newList(), 2);
this.zeroCountDropIterable = new DropIterable<>(Interval.oneTo(5), 0);
this.nearCountDropIterable = new DropIterable<>(Interval.oneTo(5), 4);
this.sameCountDropIterable = new DropIterable<>(Interval.oneTo(5), 5);
this.higherCountDropIterable = new DropIterable<>(Interval.oneTo(5), 6);
}
@Test
public void take() {
ArrayList<Integer> list = this.getIntegerList();
Assert.assertEquals(FastList.newListWith(5, 4), ArrayListIterate.take(list, 2));
Verify.assertSize(0, ArrayListIterate.take(list, 0));
Verify.assertSize(5, ArrayListIterate.take(list, 5));
Verify.assertSize(0, ArrayListIterate.take(new ArrayList<Integer>(), 2));
ArrayList<Integer> list1 = new ArrayList<Integer>(130);
list1.addAll(Interval.oneTo(120));
Verify.assertListsEqual(Interval.oneTo(120), ArrayListIterate.take(list1, 125));
}
@Test
public void collectOver100() {
ArrayList<Integer> list = new ArrayList<Integer>(Interval.oneTo(101));
ArrayList<Class<?>> newCollection = ArrayListIterate.collect(list, Functions.getToClass());
Verify.assertSize(101, newCollection);
Verify.assertContains(Integer.class, newCollection);
}
@Test
public void reverseForEach() {
ArrayList<Integer> integers = Interval.oneTo(5).addAllTo(new ArrayList<Integer>());
MutableList<Integer> reverseResults = Lists.mutable.of();
ArrayListIterate.reverseForEach(integers, CollectionAddProcedure.on(reverseResults));
Assert.assertEquals(ListIterate.reverseThis(integers), reverseResults);
}
@Test
public void forEachUsingFromTo() {
final ArrayList<Integer> integers = Interval.oneTo(5).addAllTo(new ArrayList<Integer>());
ArrayList<Integer> results = new ArrayList<Integer>();
ArrayListIterate.forEach(integers, 0, 4, CollectionAddProcedure.on(results));
Assert.assertEquals(integers, results);
MutableList<Integer> reverseResults = Lists.mutable.of();
final CollectionAddProcedure<Integer> procedure = CollectionAddProcedure.on(reverseResults);
ArrayListIterate.forEach(integers, 4, 0, procedure);
Assert.assertEquals(ListIterate.reverseThis(integers), reverseResults);
Verify.assertThrows(
IndexOutOfBoundsException.class,
new Runnable() {
public void run() {
ArrayListIterate.forEach(integers, 4, -1, procedure);
}
});
Verify.assertThrows(
IndexOutOfBoundsException.class,
new Runnable() {
public void run() {
ArrayListIterate.forEach(integers, -1, 4, procedure);
}
});
}
@Test
public void selectInstancesOfOver100() {
ArrayList<Number> list = new ArrayList<Number>(Interval.oneTo(101));
list.add(102.0);
MutableList<Double> results = ArrayListIterate.selectInstancesOf(list, Double.class);
Assert.assertEquals(iList(102.0), results);
}
@Test
public void collectIfOver100() {
ArrayList<Integer> list = new ArrayList<Integer>(Interval.oneTo(101));
ArrayList<Class<?>> result =
ArrayListIterate.collectIf(list, Predicates.equal(101), Functions.getToClass());
Assert.assertEquals(FastList.newListWith(Integer.class), result);
}
@Test
public void rejectWithOver100() {
ArrayList<Integer> list = new ArrayList<Integer>(Interval.oneTo(101));
ArrayList<Integer> results =
ArrayListIterate.rejectWith(list, Predicates2.instanceOf(), Integer.class);
Verify.assertEmpty(results);
}
@Test
public void selectOver100() {
ArrayList<Integer> list = new ArrayList<Integer>(Interval.oneTo(101));
ArrayList<Integer> results =
ArrayListIterate.select(list, Predicates.instanceOf(Integer.class));
Verify.assertSize(101, results);
}
@Test
public void noneSatisfyWithOver100() {
ArrayList<Integer> list = new ArrayList<Integer>(Interval.oneTo(101));
Assert.assertFalse(
ArrayListIterate.noneSatisfyWith(list, Predicates2.instanceOf(), Integer.class));
Predicate2<Integer, Integer> greaterThanPredicate = Predicates2.greaterThan();
Assert.assertTrue(ArrayListIterate.noneSatisfyWith(list, greaterThanPredicate, 150));
}
@Test
public void testForEachWithIndexWithFromToWithCommandoPatternOptimization() {
MutableList<Integer> result2 = Lists.mutable.of();
// Requires list of 100+ elements to engage commando pattern optimization
ArrayListAdapter.adapt(new ArrayList<>(Interval.oneTo(200)))
.forEachWithIndex(99, 199, new AddToList(result2));
Verify.assertSize(101, result2);
}
@Test
public void countWithOver100() {
ArrayList<Integer> list = new ArrayList<Integer>(Interval.oneTo(101));
Assert.assertEquals(
101, ArrayListIterate.countWith(list, Predicates2.instanceOf(), Integer.class));
Assert.assertEquals(
0, ArrayListIterate.countWith(list, Predicates2.instanceOf(), Double.class));
}
@Test
public void testForEachWithIndexToArrayUsingArrayList() {
Integer[] array = new Integer[200];
List<Integer> list = new ArrayList<>(Interval.oneTo(200));
Assert.assertTrue(ArrayIterate.allSatisfy(array, Predicates.isNull()));
ParallelIterate.forEachWithIndex(list, (each, index) -> array[index] = each, 10, 10);
Assert.assertArrayEquals(array, list.toArray(new Integer[] {}));
}
@Test
public void anySatisfyWithOver100() {
ArrayList<Integer> list = new ArrayList<Integer>(Interval.oneTo(101));
Assert.assertTrue(
ArrayListIterate.anySatisfyWith(list, Predicates2.instanceOf(), Integer.class));
Assert.assertFalse(
ArrayListIterate.anySatisfyWith(list, Predicates2.instanceOf(), Double.class));
}
@Test
public void partitionOver100() {
ArrayList<Integer> list = new ArrayList<Integer>(Interval.oneTo(101));
PartitionMutableList<Integer> result =
ArrayListIterate.partition(list, Predicates.in(Lists.immutable.of(1)));
Verify.assertSize(1, result.getSelected());
Verify.assertSize(100, result.getRejected());
}
@Test
public void selectAndRejectWithOver100() {
ArrayList<Integer> list = new ArrayList<Integer>(Interval.oneTo(101));
Twin<MutableList<Integer>> result =
ArrayListIterate.selectAndRejectWith(list, Predicates2.in(), Lists.immutable.of(1));
Verify.assertSize(1, result.getOne());
Verify.assertSize(100, result.getTwo());
}
@Test
public void toSet() {
MutableSet<String> expectedSet =
this.numKeys() == 0
? UnifiedSet.<String>newSet()
: Interval.oneTo(this.numKeys()).collect(String::valueOf).toSet();
Assert.assertEquals(expectedSet, this.newBag().toSet());
}
@Test
public void forEachOver100() {
ArrayList<Integer> list = new ArrayList<Integer>(Interval.oneTo(101));
Iterate.sortThis(list);
FastList<Integer> result = FastList.newList(101);
ArrayListIterate.forEach(list, CollectionAddProcedure.<Integer>on(result));
Verify.assertListsEqual(list, result);
}
@Test
public void updateValue() {
MutableMapIterable<Integer, Integer> map = this.newMap();
Iterate.forEach(
Interval.oneTo(1000), each -> map.updateValue(each % 10, () -> 0, integer -> integer + 1));
Assert.assertEquals(Interval.zeroTo(9).toSet(), map.keySet());
Assert.assertEquals(
FastList.newList(Collections.nCopies(10, 100)), FastList.newList(map.values()));
}
@Test
public void toSortedMap() {
MutableSortedMap<Integer, String> map =
this.newBag().toSortedMap(Integer::valueOf, Functions.<String>getPassThru());
Verify.assertMapsEqual(
this.newBag().toMap(Integer::valueOf, Functions.<String>getPassThru()), map);
Verify.assertListsEqual(Interval.oneTo(this.numKeys()), map.keySet().toList());
}
@Test
public void flatCollect() {
ImmutableMap<Integer, Integer> map = this.newMapWithKeysValues(1, 1, 2, 2, 3, 3, 4, 4);
if (map.isEmpty()) {
Function<Integer, Iterable<Object>> fail =
each -> {
throw new AssertionError();
};
Assert.assertEquals(Bags.immutable.empty(), map.flatCollect(fail));
Assert.assertEquals(Bags.immutable.empty(), map.flatCollect(fail, HashBag.newBag()));
} else {
MutableBag<Integer> expected =
Interval.oneTo(map.size()).flatCollect(each -> Interval.oneTo(each)).toBag();
Assert.assertEquals(expected, map.flatCollect(each -> Interval.oneTo(each)));
Assert.assertEquals(
expected, map.flatCollect(each -> Interval.oneTo(each), HashBag.newBag()));
}
}
@Before
public void setUp() {
Interval interval = Interval.oneTo(20000);
this.iterables =
Lists.immutable.of(
interval.toList(),
interval.toList().asUnmodifiable(),
interval.toList().asSynchronized(),
interval.toList().toImmutable(),
interval.toSet(),
interval.toSet().asUnmodifiable(),
interval.toSet().asSynchronized(),
interval.toSet().toImmutable(),
interval.toBag(),
interval.toBag().asUnmodifiable(),
interval.toBag().asSynchronized(),
interval.toBag().toImmutable(),
interval.toSortedSet(),
interval.toSortedSet().asUnmodifiable(),
interval.toSortedSet().asSynchronized(),
interval.toSortedSet().toImmutable(),
interval.toMap(Functions.<Integer>getPassThru(), Functions.<Integer>getPassThru()),
interval
.toMap(Functions.<Integer>getPassThru(), Functions.<Integer>getPassThru())
.asUnmodifiable(),
interval
.toMap(Functions.<Integer>getPassThru(), Functions.<Integer>getPassThru())
.asSynchronized(),
interval
.toMap(Functions.<Integer>getPassThru(), Functions.<Integer>getPassThru())
.toImmutable(),
ArrayListAdapter.<Integer>newList().withAll(interval),
ArrayListAdapter.<Integer>newList().withAll(interval).asUnmodifiable(),
ArrayListAdapter.<Integer>newList().withAll(interval).asSynchronized(),
new CompositeFastList<Integer>().withAll(interval.toList()),
new CompositeFastList<Integer>().withAll(interval.toList()).asUnmodifiable(),
new CompositeFastList<Integer>().withAll(interval.toList()).asSynchronized(),
new CompositeFastList<Integer>().withAll(interval.toList()).toImmutable(),
ListAdapter.adapt(new LinkedList<Integer>()).withAll(interval),
ListAdapter.adapt(new LinkedList<Integer>()).withAll(interval).asUnmodifiable(),
ListAdapter.adapt(new LinkedList<Integer>()).withAll(interval).asSynchronized(),
UnifiedSetWithHashingStrategy.<Integer>newSet(HashingStrategies.defaultStrategy())
.withAll(interval),
UnifiedSetWithHashingStrategy.<Integer>newSet(HashingStrategies.defaultStrategy())
.withAll(interval)
.asUnmodifiable(),
UnifiedSetWithHashingStrategy.<Integer>newSet(HashingStrategies.defaultStrategy())
.withAll(interval)
.asSynchronized(),
UnifiedSetWithHashingStrategy.<Integer>newSet(HashingStrategies.defaultStrategy())
.withAll(interval)
.toImmutable());
}
@Test
public void forEachWithIndexOver100() {
ArrayList<Integer> list = new ArrayList<Integer>(Interval.oneTo(101));
Iterate.sortThis(list);
ArrayListIterate.forEachWithIndex(
list,
new ObjectIntProcedure<Integer>() {
public void value(Integer object, int index) {
Assert.assertEquals(index, object - 1);
}
});
}
@Test
public void updateValue_collisions() {
MutableMapIterable<Integer, Integer> map = this.newMap();
MutableList<Integer> list = Interval.oneTo(2000).toList();
Collections.shuffle(list);
Iterate.forEach(list, each -> map.updateValue(each % 1000, () -> 0, integer -> integer + 1));
Assert.assertEquals(Interval.zeroTo(999).toSet(), map.keySet());
Assert.assertEquals(
HashBag.newBag(map.values()).toStringOfItemToCount(),
FastList.newList(Collections.nCopies(1000, 2)),
FastList.newList(map.values()));
}
@Override
@Test
public void forEach() {
super.forEach();
MutableList<Integer> list = FastList.newList();
CompositeFastList<Integer> iterables = new CompositeFastList<Integer>();
iterables.addComposited(Interval.oneTo(5).toList());
iterables.addComposited(Interval.fromTo(6, 10).toList());
iterables.forEach(CollectionAddProcedure.on(list));
Verify.assertSize(10, list);
Verify.assertAllSatisfy(list, Predicates.greaterThan(0).and(Predicates.lessThan(11)));
}
@Override
@Test
public void reverseThis() {
super.reverseThis();
CompositeFastList<Integer> composite = new CompositeFastList<Integer>();
composite.addAll(FastList.newListWith(9, 8, 7));
composite.addAll(FastList.newListWith(6, 5, 4));
composite.addAll(FastList.newListWith(3, 2, 1));
CompositeFastList<Integer> reversed = composite.reverseThis();
Assert.assertSame(composite, reversed);
Assert.assertEquals(Interval.oneTo(9), reversed);
}
@Override
@Test
public void forEachWith() {
super.forEachWith();
MutableList<Integer> list = FastList.newList();
CompositeFastList<Integer> iterables = new CompositeFastList<Integer>();
iterables.addComposited(Interval.fromTo(6, 10).toList());
iterables.addComposited(Interval.oneTo(5).toList());
iterables.forEachWith((each, parameter) -> list.add(parameter.intValue(), each), 0);
Verify.assertSize(10, list);
Verify.assertAllSatisfy(list, Predicates.greaterThan(0).and(Predicates.lessThan(11)));
Verify.assertStartsWith(list, 5, 4, 3, 2, 1, 10, 9, 8, 7, 6);
}
@Override
@Test
public void forEachWithIndex() {
super.forEachWithIndex();
MutableList<Integer> list = FastList.newList();
CompositeFastList<Integer> iterables = new CompositeFastList<Integer>();
iterables.addComposited(Interval.fromTo(6, 10).toList());
iterables.addComposited(Interval.oneTo(5).toList());
iterables.forEachWithIndex((each, index) -> list.add(index, each));
Verify.assertSize(10, list);
Verify.assertAllSatisfy(list, Predicates.greaterThan(0).and(Predicates.lessThan(11)));
Verify.assertStartsWith(list, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5);
}