| /* |
| * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| package org.openjdk.tests.java.util.stream; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Optional; |
| import java.util.Set; |
| import java.util.StringJoiner; |
| import java.util.TreeMap; |
| import java.util.concurrent.ConcurrentHashMap; |
| import java.util.concurrent.ConcurrentSkipListMap; |
| import java.util.function.BinaryOperator; |
| import java.util.function.Function; |
| import java.util.function.Predicate; |
| import java.util.function.Supplier; |
| import java.util.stream.Collector; |
| import java.util.stream.Collectors; |
| import java.util.stream.LambdaTestHelpers; |
| import java.util.stream.OpTestCase; |
| import java.util.stream.Stream; |
| import java.util.stream.StreamOpFlagTestHelper; |
| import java.util.stream.StreamTestDataProvider; |
| import java.util.stream.TestData; |
| |
| import org.testng.annotations.Test; |
| |
| import static java.util.stream.Collectors.collectingAndThen; |
| import static java.util.stream.Collectors.groupingBy; |
| import static java.util.stream.Collectors.groupingByConcurrent; |
| import static java.util.stream.Collectors.partitioningBy; |
| import static java.util.stream.Collectors.reducing; |
| import static java.util.stream.Collectors.toCollection; |
| import static java.util.stream.Collectors.toConcurrentMap; |
| import static java.util.stream.Collectors.toList; |
| import static java.util.stream.Collectors.toMap; |
| import static java.util.stream.Collectors.toSet; |
| import static java.util.stream.LambdaTestHelpers.assertContents; |
| import static java.util.stream.LambdaTestHelpers.assertContentsUnordered; |
| import static java.util.stream.LambdaTestHelpers.mDoubler; |
| |
| /** |
| * TabulatorsTest |
| * |
| * @author Brian Goetz |
| */ |
| @SuppressWarnings({"rawtypes", "unchecked"}) |
| public class TabulatorsTest extends OpTestCase { |
| |
| private static abstract class TabulationAssertion<T, U> { |
| abstract void assertValue(U value, |
| Supplier<Stream<T>> source, |
| boolean ordered) throws ReflectiveOperationException; |
| } |
| |
| @SuppressWarnings({"rawtypes", "unchecked"}) |
| static class GroupedMapAssertion<T, K, V, M extends Map<K, ? extends V>> extends TabulationAssertion<T, M> { |
| private final Class<? extends Map> clazz; |
| private final Function<T, K> classifier; |
| private final TabulationAssertion<T,V> downstream; |
| |
| protected GroupedMapAssertion(Function<T, K> classifier, |
| Class<? extends Map> clazz, |
| TabulationAssertion<T, V> downstream) { |
| this.clazz = clazz; |
| this.classifier = classifier; |
| this.downstream = downstream; |
| } |
| |
| void assertValue(M map, |
| Supplier<Stream<T>> source, |
| boolean ordered) throws ReflectiveOperationException { |
| if (!clazz.isAssignableFrom(map.getClass())) |
| fail(String.format("Class mismatch in GroupedMapAssertion: %s, %s", clazz, map.getClass())); |
| assertContentsUnordered(map.keySet(), source.get().map(classifier).collect(toSet())); |
| for (Map.Entry<K, ? extends V> entry : map.entrySet()) { |
| K key = entry.getKey(); |
| downstream.assertValue(entry.getValue(), |
| () -> source.get().filter(e -> classifier.apply(e).equals(key)), |
| ordered); |
| } |
| } |
| } |
| |
| static class ToMapAssertion<T, K, V, M extends Map<K,V>> extends TabulationAssertion<T, M> { |
| private final Class<? extends Map> clazz; |
| private final Function<T, K> keyFn; |
| private final Function<T, V> valueFn; |
| private final BinaryOperator<V> mergeFn; |
| |
| ToMapAssertion(Function<T, K> keyFn, |
| Function<T, V> valueFn, |
| BinaryOperator<V> mergeFn, |
| Class<? extends Map> clazz) { |
| this.clazz = clazz; |
| this.keyFn = keyFn; |
| this.valueFn = valueFn; |
| this.mergeFn = mergeFn; |
| } |
| |
| @Override |
| void assertValue(M map, Supplier<Stream<T>> source, boolean ordered) throws ReflectiveOperationException { |
| Set<K> uniqueKeys = source.get().map(keyFn).collect(toSet()); |
| assertTrue(clazz.isAssignableFrom(map.getClass())); |
| assertEquals(uniqueKeys, map.keySet()); |
| source.get().forEach(t -> { |
| K key = keyFn.apply(t); |
| V v = source.get() |
| .filter(e -> key.equals(keyFn.apply(e))) |
| .map(valueFn) |
| .reduce(mergeFn) |
| .get(); |
| assertEquals(map.get(key), v); |
| }); |
| } |
| } |
| |
| static class PartitionAssertion<T, D> extends TabulationAssertion<T, Map<Boolean,D>> { |
| private final Predicate<T> predicate; |
| private final TabulationAssertion<T,D> downstream; |
| |
| protected PartitionAssertion(Predicate<T> predicate, |
| TabulationAssertion<T, D> downstream) { |
| this.predicate = predicate; |
| this.downstream = downstream; |
| } |
| |
| void assertValue(Map<Boolean, D> map, |
| Supplier<Stream<T>> source, |
| boolean ordered) throws ReflectiveOperationException { |
| if (!Map.class.isAssignableFrom(map.getClass())) |
| fail(String.format("Class mismatch in PartitionAssertion: %s", map.getClass())); |
| assertEquals(2, map.size()); |
| downstream.assertValue(map.get(true), () -> source.get().filter(predicate), ordered); |
| downstream.assertValue(map.get(false), () -> source.get().filter(predicate.negate()), ordered); |
| } |
| } |
| |
| @SuppressWarnings({"rawtypes", "unchecked"}) |
| static class ListAssertion<T> extends TabulationAssertion<T, List<T>> { |
| @Override |
| void assertValue(List<T> value, Supplier<Stream<T>> source, boolean ordered) |
| throws ReflectiveOperationException { |
| if (!List.class.isAssignableFrom(value.getClass())) |
| fail(String.format("Class mismatch in ListAssertion: %s", value.getClass())); |
| Stream<T> stream = source.get(); |
| List<T> result = new ArrayList<>(); |
| for (Iterator<T> it = stream.iterator(); it.hasNext(); ) // avoid capturing result::add |
| result.add(it.next()); |
| if (StreamOpFlagTestHelper.isStreamOrdered(stream) && ordered) |
| assertContents(value, result); |
| else |
| assertContentsUnordered(value, result); |
| } |
| } |
| |
| @SuppressWarnings({"rawtypes", "unchecked"}) |
| static class CollectionAssertion<T> extends TabulationAssertion<T, Collection<T>> { |
| private final Class<? extends Collection> clazz; |
| private final boolean targetOrdered; |
| |
| protected CollectionAssertion(Class<? extends Collection> clazz, boolean targetOrdered) { |
| this.clazz = clazz; |
| this.targetOrdered = targetOrdered; |
| } |
| |
| @Override |
| void assertValue(Collection<T> value, Supplier<Stream<T>> source, boolean ordered) |
| throws ReflectiveOperationException { |
| if (!clazz.isAssignableFrom(value.getClass())) |
| fail(String.format("Class mismatch in CollectionAssertion: %s, %s", clazz, value.getClass())); |
| Stream<T> stream = source.get(); |
| Collection<T> result = clazz.newInstance(); |
| for (Iterator<T> it = stream.iterator(); it.hasNext(); ) // avoid capturing result::add |
| result.add(it.next()); |
| if (StreamOpFlagTestHelper.isStreamOrdered(stream) && targetOrdered && ordered) |
| assertContents(value, result); |
| else |
| assertContentsUnordered(value, result); |
| } |
| } |
| |
| static class ReduceAssertion<T, U> extends TabulationAssertion<T, U> { |
| private final U identity; |
| private final Function<T, U> mapper; |
| private final BinaryOperator<U> reducer; |
| |
| ReduceAssertion(U identity, Function<T, U> mapper, BinaryOperator<U> reducer) { |
| this.identity = identity; |
| this.mapper = mapper; |
| this.reducer = reducer; |
| } |
| |
| @Override |
| void assertValue(U value, Supplier<Stream<T>> source, boolean ordered) |
| throws ReflectiveOperationException { |
| Optional<U> reduced = source.get().map(mapper).reduce(reducer); |
| if (value == null) |
| assertTrue(!reduced.isPresent()); |
| else if (!reduced.isPresent()) { |
| assertEquals(value, identity); |
| } |
| else { |
| assertEquals(value, reduced.get()); |
| } |
| } |
| } |
| |
| private <T> ResultAsserter<T> mapTabulationAsserter(boolean ordered) { |
| return (act, exp, ord, par) -> { |
| if (par && (!ordered || !ord)) { |
| TabulatorsTest.nestedMapEqualityAssertion(act, exp); |
| } |
| else { |
| LambdaTestHelpers.assertContentsEqual(act, exp); |
| } |
| }; |
| } |
| |
| private<T, M extends Map> |
| void exerciseMapTabulation(TestData<T, Stream<T>> data, |
| Collector<T, ?, ? extends M> collector, |
| TabulationAssertion<T, M> assertion) |
| throws ReflectiveOperationException { |
| boolean ordered = !collector.characteristics().contains(Collector.Characteristics.UNORDERED); |
| |
| M m = withData(data) |
| .terminal(s -> s.collect(collector)) |
| .resultAsserter(mapTabulationAsserter(ordered)) |
| .exercise(); |
| assertion.assertValue(m, () -> data.stream(), ordered); |
| |
| m = withData(data) |
| .terminal(s -> s.unordered().collect(collector)) |
| .resultAsserter(mapTabulationAsserter(ordered)) |
| .exercise(); |
| assertion.assertValue(m, () -> data.stream(), false); |
| } |
| |
| private static void nestedMapEqualityAssertion(Object o1, Object o2) { |
| if (o1 instanceof Map) { |
| Map m1 = (Map) o1; |
| Map m2 = (Map) o2; |
| assertContentsUnordered(m1.keySet(), m2.keySet()); |
| for (Object k : m1.keySet()) |
| nestedMapEqualityAssertion(m1.get(k), m2.get(k)); |
| } |
| else if (o1 instanceof Collection) { |
| assertContentsUnordered(((Collection) o1), ((Collection) o2)); |
| } |
| else |
| assertEquals(o1, o2); |
| } |
| |
| private<T, R> void assertCollect(TestData.OfRef<T> data, |
| Collector<T, ?, R> collector, |
| Function<Stream<T>, R> streamReduction) { |
| R check = streamReduction.apply(data.stream()); |
| withData(data).terminal(s -> s.collect(collector)).expectedResult(check).exercise(); |
| } |
| |
| @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class) |
| public void testReduce(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException { |
| assertCollect(data, Collectors.reducing(0, Integer::sum), |
| s -> s.reduce(0, Integer::sum)); |
| assertCollect(data, Collectors.reducing(Integer.MAX_VALUE, Integer::min), |
| s -> s.min(Integer::compare).orElse(Integer.MAX_VALUE)); |
| assertCollect(data, Collectors.reducing(Integer.MIN_VALUE, Integer::max), |
| s -> s.max(Integer::compare).orElse(Integer.MIN_VALUE)); |
| |
| assertCollect(data, Collectors.reducing(Integer::sum), |
| s -> s.reduce(Integer::sum)); |
| assertCollect(data, Collectors.minBy(Comparator.naturalOrder()), |
| s -> s.min(Integer::compare)); |
| assertCollect(data, Collectors.maxBy(Comparator.naturalOrder()), |
| s -> s.max(Integer::compare)); |
| |
| assertCollect(data, Collectors.reducing(0, x -> x*2, Integer::sum), |
| s -> s.map(x -> x*2).reduce(0, Integer::sum)); |
| |
| assertCollect(data, Collectors.summingLong(x -> x * 2L), |
| s -> s.map(x -> x*2L).reduce(0L, Long::sum)); |
| assertCollect(data, Collectors.summingInt(x -> x * 2), |
| s -> s.map(x -> x*2).reduce(0, Integer::sum)); |
| assertCollect(data, Collectors.summingDouble(x -> x * 2.0d), |
| s -> s.map(x -> x * 2.0d).reduce(0.0d, Double::sum)); |
| |
| assertCollect(data, Collectors.averagingInt(x -> x * 2), |
| s -> s.mapToInt(x -> x * 2).average().orElse(0)); |
| assertCollect(data, Collectors.averagingLong(x -> x * 2), |
| s -> s.mapToLong(x -> x * 2).average().orElse(0)); |
| assertCollect(data, Collectors.averagingDouble(x -> x * 2), |
| s -> s.mapToDouble(x -> x * 2).average().orElse(0)); |
| |
| // Test explicit Collector.of |
| Collector<Integer, long[], Double> avg2xint = Collector.of(() -> new long[2], |
| (a, b) -> { |
| a[0] += b * 2; |
| a[1]++; |
| }, |
| (a, b) -> { |
| a[0] += b[0]; |
| a[1] += b[1]; |
| return a; |
| }, |
| a -> a[1] == 0 ? 0.0d : (double) a[0] / a[1]); |
| assertCollect(data, avg2xint, |
| s -> s.mapToInt(x -> x * 2).average().orElse(0)); |
| } |
| |
| @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class) |
| public void testJoin(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException { |
| withData(data) |
| .terminal(s -> s.map(Object::toString).collect(Collectors.joining())) |
| .expectedResult(join(data, "")) |
| .exercise(); |
| |
| Collector<String, StringBuilder, String> likeJoining = Collector.of(StringBuilder::new, StringBuilder::append, (sb1, sb2) -> sb1.append(sb2.toString()), StringBuilder::toString); |
| withData(data) |
| .terminal(s -> s.map(Object::toString).collect(likeJoining)) |
| .expectedResult(join(data, "")) |
| .exercise(); |
| |
| withData(data) |
| .terminal(s -> s.map(Object::toString).collect(Collectors.joining(","))) |
| .expectedResult(join(data, ",")) |
| .exercise(); |
| |
| withData(data) |
| .terminal(s -> s.map(Object::toString).collect(Collectors.joining(",", "[", "]"))) |
| .expectedResult("[" + join(data, ",") + "]") |
| .exercise(); |
| |
| withData(data) |
| .terminal(s -> s.map(Object::toString) |
| .collect(StringBuilder::new, StringBuilder::append, StringBuilder::append) |
| .toString()) |
| .expectedResult(join(data, "")) |
| .exercise(); |
| |
| withData(data) |
| .terminal(s -> s.map(Object::toString) |
| .collect(() -> new StringJoiner(","), |
| (sj, cs) -> sj.add(cs), |
| (j1, j2) -> j1.merge(j2)) |
| .toString()) |
| .expectedResult(join(data, ",")) |
| .exercise(); |
| |
| withData(data) |
| .terminal(s -> s.map(Object::toString) |
| .collect(() -> new StringJoiner(",", "[", "]"), |
| (sj, cs) -> sj.add(cs), |
| (j1, j2) -> j1.merge(j2)) |
| .toString()) |
| .expectedResult("[" + join(data, ",") + "]") |
| .exercise(); |
| } |
| |
| private<T> String join(TestData.OfRef<T> data, String delim) { |
| StringBuilder sb = new StringBuilder(); |
| boolean first = true; |
| for (T i : data) { |
| if (!first) |
| sb.append(delim); |
| sb.append(i.toString()); |
| first = false; |
| } |
| return sb.toString(); |
| } |
| |
| @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class) |
| public void testSimpleToMap(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException { |
| Function<Integer, Integer> keyFn = i -> i * 2; |
| Function<Integer, Integer> valueFn = i -> i * 4; |
| |
| List<Integer> dataAsList = Arrays.asList(data.stream().toArray(Integer[]::new)); |
| Set<Integer> dataAsSet = new HashSet<>(dataAsList); |
| |
| BinaryOperator<Integer> sum = Integer::sum; |
| for (BinaryOperator<Integer> op : Arrays.asList((u, v) -> u, |
| (u, v) -> v, |
| sum)) { |
| try { |
| exerciseMapTabulation(data, toMap(keyFn, valueFn), |
| new ToMapAssertion<>(keyFn, valueFn, op, HashMap.class)); |
| if (dataAsList.size() != dataAsSet.size()) |
| fail("Expected ISE on input with duplicates"); |
| } |
| catch (IllegalStateException e) { |
| if (dataAsList.size() == dataAsSet.size()) |
| fail("Expected no ISE on input without duplicates"); |
| } |
| |
| exerciseMapTabulation(data, toMap(keyFn, valueFn, op), |
| new ToMapAssertion<>(keyFn, valueFn, op, HashMap.class)); |
| |
| exerciseMapTabulation(data, toMap(keyFn, valueFn, op, TreeMap::new), |
| new ToMapAssertion<>(keyFn, valueFn, op, TreeMap.class)); |
| } |
| |
| // For concurrent maps, only use commutative merge functions |
| try { |
| exerciseMapTabulation(data, toConcurrentMap(keyFn, valueFn), |
| new ToMapAssertion<>(keyFn, valueFn, sum, ConcurrentHashMap.class)); |
| if (dataAsList.size() != dataAsSet.size()) |
| fail("Expected ISE on input with duplicates"); |
| } |
| catch (IllegalStateException e) { |
| if (dataAsList.size() == dataAsSet.size()) |
| fail("Expected no ISE on input without duplicates"); |
| } |
| |
| exerciseMapTabulation(data, toConcurrentMap(keyFn, valueFn, sum), |
| new ToMapAssertion<>(keyFn, valueFn, sum, ConcurrentHashMap.class)); |
| |
| exerciseMapTabulation(data, toConcurrentMap(keyFn, valueFn, sum, ConcurrentSkipListMap::new), |
| new ToMapAssertion<>(keyFn, valueFn, sum, ConcurrentSkipListMap.class)); |
| } |
| |
| @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class) |
| public void testSimpleGroupBy(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException { |
| Function<Integer, Integer> classifier = i -> i % 3; |
| |
| // Single-level groupBy |
| exerciseMapTabulation(data, groupingBy(classifier), |
| new GroupedMapAssertion<>(classifier, HashMap.class, |
| new ListAssertion<>())); |
| exerciseMapTabulation(data, groupingByConcurrent(classifier), |
| new GroupedMapAssertion<>(classifier, ConcurrentHashMap.class, |
| new ListAssertion<>())); |
| |
| // With explicit constructors |
| exerciseMapTabulation(data, |
| groupingBy(classifier, TreeMap::new, toCollection(HashSet::new)), |
| new GroupedMapAssertion<>(classifier, TreeMap.class, |
| new CollectionAssertion<Integer>(HashSet.class, false))); |
| exerciseMapTabulation(data, |
| groupingByConcurrent(classifier, ConcurrentSkipListMap::new, |
| toCollection(HashSet::new)), |
| new GroupedMapAssertion<>(classifier, ConcurrentSkipListMap.class, |
| new CollectionAssertion<Integer>(HashSet.class, false))); |
| } |
| |
| @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class) |
| public void testTwoLevelGroupBy(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException { |
| Function<Integer, Integer> classifier = i -> i % 6; |
| Function<Integer, Integer> classifier2 = i -> i % 23; |
| |
| // Two-level groupBy |
| exerciseMapTabulation(data, |
| groupingBy(classifier, groupingBy(classifier2)), |
| new GroupedMapAssertion<>(classifier, HashMap.class, |
| new GroupedMapAssertion<>(classifier2, HashMap.class, |
| new ListAssertion<>()))); |
| // with concurrent as upstream |
| exerciseMapTabulation(data, |
| groupingByConcurrent(classifier, groupingBy(classifier2)), |
| new GroupedMapAssertion<>(classifier, ConcurrentHashMap.class, |
| new GroupedMapAssertion<>(classifier2, HashMap.class, |
| new ListAssertion<>()))); |
| // with concurrent as downstream |
| exerciseMapTabulation(data, |
| groupingBy(classifier, groupingByConcurrent(classifier2)), |
| new GroupedMapAssertion<>(classifier, HashMap.class, |
| new GroupedMapAssertion<>(classifier2, ConcurrentHashMap.class, |
| new ListAssertion<>()))); |
| // with concurrent as upstream and downstream |
| exerciseMapTabulation(data, |
| groupingByConcurrent(classifier, groupingByConcurrent(classifier2)), |
| new GroupedMapAssertion<>(classifier, ConcurrentHashMap.class, |
| new GroupedMapAssertion<>(classifier2, ConcurrentHashMap.class, |
| new ListAssertion<>()))); |
| |
| // With explicit constructors |
| exerciseMapTabulation(data, |
| groupingBy(classifier, TreeMap::new, groupingBy(classifier2, TreeMap::new, toCollection(HashSet::new))), |
| new GroupedMapAssertion<>(classifier, TreeMap.class, |
| new GroupedMapAssertion<>(classifier2, TreeMap.class, |
| new CollectionAssertion<Integer>(HashSet.class, false)))); |
| // with concurrent as upstream |
| exerciseMapTabulation(data, |
| groupingByConcurrent(classifier, ConcurrentSkipListMap::new, groupingBy(classifier2, TreeMap::new, toList())), |
| new GroupedMapAssertion<>(classifier, ConcurrentSkipListMap.class, |
| new GroupedMapAssertion<>(classifier2, TreeMap.class, |
| new ListAssertion<>()))); |
| // with concurrent as downstream |
| exerciseMapTabulation(data, |
| groupingBy(classifier, TreeMap::new, groupingByConcurrent(classifier2, ConcurrentSkipListMap::new, toList())), |
| new GroupedMapAssertion<>(classifier, TreeMap.class, |
| new GroupedMapAssertion<>(classifier2, ConcurrentSkipListMap.class, |
| new ListAssertion<>()))); |
| // with concurrent as upstream and downstream |
| exerciseMapTabulation(data, |
| groupingByConcurrent(classifier, ConcurrentSkipListMap::new, groupingByConcurrent(classifier2, ConcurrentSkipListMap::new, toList())), |
| new GroupedMapAssertion<>(classifier, ConcurrentSkipListMap.class, |
| new GroupedMapAssertion<>(classifier2, ConcurrentSkipListMap.class, |
| new ListAssertion<>()))); |
| } |
| |
| @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class) |
| public void testGroupedReduce(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException { |
| Function<Integer, Integer> classifier = i -> i % 3; |
| |
| // Single-level simple reduce |
| exerciseMapTabulation(data, |
| groupingBy(classifier, reducing(0, Integer::sum)), |
| new GroupedMapAssertion<>(classifier, HashMap.class, |
| new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum))); |
| // with concurrent |
| exerciseMapTabulation(data, |
| groupingByConcurrent(classifier, reducing(0, Integer::sum)), |
| new GroupedMapAssertion<>(classifier, ConcurrentHashMap.class, |
| new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum))); |
| |
| // With explicit constructors |
| exerciseMapTabulation(data, |
| groupingBy(classifier, TreeMap::new, reducing(0, Integer::sum)), |
| new GroupedMapAssertion<>(classifier, TreeMap.class, |
| new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum))); |
| // with concurrent |
| exerciseMapTabulation(data, |
| groupingByConcurrent(classifier, ConcurrentSkipListMap::new, reducing(0, Integer::sum)), |
| new GroupedMapAssertion<>(classifier, ConcurrentSkipListMap.class, |
| new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum))); |
| |
| // Single-level map-reduce |
| exerciseMapTabulation(data, |
| groupingBy(classifier, reducing(0, mDoubler, Integer::sum)), |
| new GroupedMapAssertion<>(classifier, HashMap.class, |
| new ReduceAssertion<>(0, mDoubler, Integer::sum))); |
| // with concurrent |
| exerciseMapTabulation(data, |
| groupingByConcurrent(classifier, reducing(0, mDoubler, Integer::sum)), |
| new GroupedMapAssertion<>(classifier, ConcurrentHashMap.class, |
| new ReduceAssertion<>(0, mDoubler, Integer::sum))); |
| |
| // With explicit constructors |
| exerciseMapTabulation(data, |
| groupingBy(classifier, TreeMap::new, reducing(0, mDoubler, Integer::sum)), |
| new GroupedMapAssertion<>(classifier, TreeMap.class, |
| new ReduceAssertion<>(0, mDoubler, Integer::sum))); |
| // with concurrent |
| exerciseMapTabulation(data, |
| groupingByConcurrent(classifier, ConcurrentSkipListMap::new, reducing(0, mDoubler, Integer::sum)), |
| new GroupedMapAssertion<>(classifier, ConcurrentSkipListMap.class, |
| new ReduceAssertion<>(0, mDoubler, Integer::sum))); |
| } |
| |
| @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class) |
| public void testSimplePartition(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException { |
| Predicate<Integer> classifier = i -> i % 3 == 0; |
| |
| // Single-level partition to downstream List |
| exerciseMapTabulation(data, |
| partitioningBy(classifier), |
| new PartitionAssertion<>(classifier, new ListAssertion<>())); |
| exerciseMapTabulation(data, |
| partitioningBy(classifier, toList()), |
| new PartitionAssertion<>(classifier, new ListAssertion<>())); |
| } |
| |
| @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class) |
| public void testTwoLevelPartition(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException { |
| Predicate<Integer> classifier = i -> i % 3 == 0; |
| Predicate<Integer> classifier2 = i -> i % 7 == 0; |
| |
| // Two level partition |
| exerciseMapTabulation(data, |
| partitioningBy(classifier, partitioningBy(classifier2)), |
| new PartitionAssertion<>(classifier, |
| new PartitionAssertion(classifier2, new ListAssertion<>()))); |
| |
| // Two level partition with reduce |
| exerciseMapTabulation(data, |
| partitioningBy(classifier, reducing(0, Integer::sum)), |
| new PartitionAssertion<>(classifier, |
| new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum))); |
| } |
| |
| @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class) |
| public void testComposeFinisher(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException { |
| List<Integer> asList = exerciseTerminalOps(data, s -> s.collect(toList())); |
| List<Integer> asImmutableList = exerciseTerminalOps(data, s -> s.collect(collectingAndThen(toList(), Collections::unmodifiableList))); |
| assertEquals(asList, asImmutableList); |
| try { |
| asImmutableList.add(0); |
| fail("Expecting immutable result"); |
| } |
| catch (UnsupportedOperationException ignored) { } |
| } |
| |
| } |
