public void testEveryMapShape() {
assertCountSum(
StreamSupport.stream(countTo(1000))
.mapToInt(i -> i - 1)
.mapToObj(i -> i + 1)
.mapToLong(i -> i - 1)
.mapToObj(i -> i + 1)
.mapToDouble(i -> i - 1)
.mapToObj(i -> i + 1)
.mapToInt(i -> (int) (double) i)
.mapToLong(i -> i)
.mapToDouble(i -> i)
.mapToLong(i -> (long) i)
.mapToInt(i -> (int) i)
.mapToObj(i -> i),
1000,
StreamSupport.stream(countTo(1000)).mapToInt(i -> i).sum());
}
private void testEntrySetSizeRemove2(String name, Set<Map.Entry<Integer, Integer>> c) {
Map.Entry<Integer, Integer> first = c.iterator().next();
assertTrue(c.remove(first));
Stream<Map.Entry<Integer, Integer>> stream = StreamSupport.stream(c, 0, false);
Map.Entry<Integer, Integer> second = c.iterator().next();
assertTrue(c.remove(second));
Object[] result = stream.toArray();
assertEquals(result.length, c.size());
}
public void testNoEvaluationForSizedStream() {
{
AtomicInteger ai = new AtomicInteger();
StreamSupport.of(1, 2, 3, 4).peek(e -> ai.getAndIncrement()).count();
assertEquals(ai.get(), 0);
StreamSupport.of(1, 2, 3, 4).peek(e -> ai.getAndIncrement()).parallel().count();
assertEquals(ai.get(), 0);
}
{
AtomicInteger ai = new AtomicInteger();
IntStreams.of(1, 2, 3, 4).peek(e -> ai.getAndIncrement()).count();
assertEquals(ai.get(), 0);
IntStreams.of(1, 2, 3, 4).peek(e -> ai.getAndIncrement()).parallel().count();
assertEquals(ai.get(), 0);
}
{
AtomicInteger ai = new AtomicInteger();
LongStreams.of(1, 2, 3, 4).peek(e -> ai.getAndIncrement()).count();
assertEquals(ai.get(), 0);
LongStreams.of(1, 2, 3, 4).peek(e -> ai.getAndIncrement()).parallel().count();
assertEquals(ai.get(), 0);
}
{
AtomicInteger ai = new AtomicInteger();
DoubleStreams.of(1, 2, 3, 4).peek(e -> ai.getAndIncrement()).count();
assertEquals(ai.get(), 0);
DoubleStreams.of(1, 2, 3, 4).peek(e -> ai.getAndIncrement()).parallel().count();
assertEquals(ai.get(), 0);
}
}
private void testEntrySetSizeRemove(String name, final Set<Map.Entry<Integer, Integer>> c) {
Iterator<Map.Entry<Integer, Integer>> testIter = c.iterator();
Map.Entry<Integer, Integer> first = testIter.next();
assertTrue(c.remove(first));
Supplier<Spliterator<Map.Entry<Integer, Integer>>> late =
new Supplier<Spliterator<Map.Entry<Integer, Integer>>>() {
@Override
public Spliterator<Map.Entry<Integer, Integer>> get() {
return Spliterators.spliterator(c, 0);
}
};
Stream<Map.Entry<Integer, Integer>> stream = StreamSupport.stream(late, 0, false);
Map.Entry<Integer, Integer> second = c.iterator().next();
assertTrue(c.remove(second));
Object[] result = stream.toArray();
assertEquals(result.length, c.size());
}
public void testMap() {
assertCountSum(StreamSupport.stream(countTo(0)).map(mId), 0, 0);
assertCountSum(StreamSupport.stream(countTo(10)).map(mId), 10, 55);
assertCountSum(StreamSupport.stream(countTo(10)).map(mZero), 10, 0);
assertCountSum(StreamSupport.stream(countTo(0)).map(mDoubler), 0, 0);
assertCountSum(StreamSupport.stream(countTo(10)).map(mDoubler), 10, 110);
assertCountSum(StreamSupport.stream(countTo(10)).map(mDoubler).map(mDoubler), 10, 220);
exerciseOps(countTo(0), s -> s.map(LambdaTestHelpers.identity()), countTo(0));
exerciseOps(countTo(1000), s -> s.map(LambdaTestHelpers.identity()), countTo(1000));
// @@@ Force cast to integer so output is Stream<Integer> rather an IntStream
// this just ensures that no warnings are logged about boxing
// when the result is compared with the output
exerciseOps(countTo(1000), s -> s.map(e -> (Integer) (1000 + e)), range(1001, 2000));
}
@Override
public Stream<PostponingReasons> streamAllPostponingReasons(boolean compat) {
final HashMap<UtcDay, HashSet<CurrencyUnit>> accumulator =
new HashMap<UtcDay, HashSet<CurrencyUnit>>(100);
Schema.POSTPONED_CURRENCY_EXCHANGE_EVENTS
.streamAll()
.forEach(
new Consumer<PostponedExchange>() {
@Override
public void accept(PostponedExchange postponedExchange) {
final HashSet<CurrencyUnit> units =
getUnitsAcc(accumulator, new UtcDay(postponedExchange.timestamp));
units.add(postponedExchange.toBuyAccount.getUnit());
units.add(postponedExchange.sellAccount.getUnit());
}
});
Schema.POSTPONED_FUNDS_MUTATION_EVENTS
.streamAll()
.forEach(
new Consumer<PostponedMutationEvent>() {
@Override
public void accept(PostponedMutationEvent postponedMutationEvent) {
final HashSet<CurrencyUnit> units =
getUnitsAcc(
accumulator, new UtcDay(postponedMutationEvent.mutationEvent.timestamp));
units.add(postponedMutationEvent.mutationEvent.amount.getCurrencyUnit());
units.add(postponedMutationEvent.conversionUnit);
}
});
return StreamSupport.stream(accumulator.entrySet())
.map(
new Function<Map.Entry<UtcDay, HashSet<CurrencyUnit>>, PostponingReasons>() {
@Override
public PostponingReasons apply(Map.Entry<UtcDay, HashSet<CurrencyUnit>> entry) {
return new PostponingReasons(entry.getKey(), ImmutableSet.copyOf(entry.getValue()));
}
});
}