@Test
public void testForEachUsingMap() {
// Test the default batch size calculations
IntegerSum sum1 = new IntegerSum(0);
MutableMap<String, Integer> map1 =
Interval.fromTo(1, 10000).toMap(String::valueOf, Functions.getIntegerPassThru());
ParallelIterate.forEach(map1, new SumProcedure(sum1), new SumCombiner(sum1));
Assert.assertEquals(50005000, sum1.getSum());
// Testing batch size 1
IntegerSum sum2 = new IntegerSum(0);
UnifiedMap<String, Integer> map2 =
(UnifiedMap<String, Integer>)
Interval.fromTo(1, 100).toMap(String::valueOf, Functions.getIntegerPassThru());
ParallelIterate.forEach(
map2, new SumProcedure(sum2), new SumCombiner(sum2), 1, map2.getBatchCount(map2.size()));
Assert.assertEquals(5050, sum2.getSum());
// Testing an uneven batch size
IntegerSum sum3 = new IntegerSum(0);
UnifiedMap<String, Integer> set3 =
(UnifiedMap<String, Integer>)
Interval.fromTo(1, 100).toMap(String::valueOf, Functions.getIntegerPassThru());
ParallelIterate.forEach(
set3, new SumProcedure(sum3), new SumCombiner(sum3), 1, set3.getBatchCount(13));
Assert.assertEquals(5050, sum3.getSum());
}
@Test
public void groupByEach() {
MutableMap<String, Integer> map = this.newMapWithKeysValues("1", 1, "2", 2, "3", 3);
NegativeIntervalFunction function = new NegativeIntervalFunction();
MutableMultimap<Integer, Integer> expected = FastListMultimap.newMultimap();
for (int i = 1; i < map.size(); i++) {
expected.putAll(-i, Interval.fromTo(i, map.size()));
}
Multimap<Integer, Integer> actual = map.groupByEach(function);
expected.forEachKey(
each -> {
Assert.assertTrue(actual.containsKey(each));
MutableList<Integer> values = actual.get(each).toList();
Verify.assertNotEmpty(values);
Assert.assertTrue(expected.get(each).containsAllIterable(values));
});
Multimap<Integer, Integer> actualFromTarget =
map.groupByEach(function, FastListMultimap.<Integer, Integer>newMultimap());
expected.forEachKey(
each -> {
Assert.assertTrue(actualFromTarget.containsKey(each));
MutableList<Integer> values = actualFromTarget.get(each).toList();
Verify.assertNotEmpty(values);
Assert.assertTrue(expected.get(each).containsAllIterable(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)));
}
@Test
public void toSortedMap_with_comparator() {
MutableSortedMap<Integer, String> map =
this.newBag()
.toSortedMap(
Comparators.<Integer>reverseNaturalOrder(),
Integer::valueOf,
Functions.<String>getPassThru());
Verify.assertMapsEqual(
this.newBag().toMap(Integer::valueOf, Functions.<String>getPassThru()), map);
Verify.assertListsEqual(Interval.fromTo(this.numKeys(), 1), map.keySet().toList());
}
@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);
}
@Test
public void groupByEach() {
MutableMultimap<Integer, Integer> expected = FastListMultimap.newMultimap();
for (int i = 1; i < 8; i++) {
expected.putAll(-i, Interval.fromTo(i, 7));
}
Multimap<Integer, Integer> actual =
this.lazyIterable.groupByEach(new NegativeIntervalFunction());
Assert.assertEquals(expected, actual);
Multimap<Integer, Integer> actualWithTarget =
this.lazyIterable.groupByEach(
new NegativeIntervalFunction(), FastListMultimap.<Integer, Integer>newMultimap());
Assert.assertEquals(expected, actualWithTarget);
}
@Test
public void groupByEach() {
ImmutableBag<Integer> immutableBag = this.newBag().collect(Integer::valueOf);
MutableMultimap<Integer, Integer> expected = HashBagMultimap.newMultimap();
int keys = this.numKeys();
immutableBag.forEachWithOccurrences(
(each, parameter) -> {
HashBag<Integer> bag = HashBag.newBag();
Interval.fromTo(each, keys)
.forEach((int eachInt) -> bag.addOccurrences(eachInt, eachInt));
expected.putAll(-each, bag);
});
Multimap<Integer, Integer> actual = immutableBag.groupByEach(new NegativeIntervalFunction());
Assert.assertEquals(expected, actual);
Multimap<Integer, Integer> actualWithTarget =
immutableBag.groupByEach(
new NegativeIntervalFunction(), HashBagMultimap.<Integer, Integer>newMultimap());
Assert.assertEquals(expected, actualWithTarget);
}
