test/java/util/stream/test/org/openjdk/tests/java/util/stream/GroupByOpTest.java

Print this page
rev 7597 : 8015318: Extend Collector with 'finish' operation
Reviewed-by:
Contributed-by: brian.goetz@oracle.com


  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 package org.openjdk.tests.java.util.stream;
  24 
  25 import java.util.Arrays;
  26 import java.util.Collection;
  27 import java.util.HashSet;
  28 import java.util.Iterator;
  29 import java.util.List;
  30 import java.util.Map;
  31 import java.util.Objects;
  32 import java.util.Set;
  33 import java.util.function.Function;
  34 import java.util.stream.Collector;
  35 import java.util.stream.Collectors;
  36 import java.util.stream.LambdaTestHelpers;
  37 import java.util.stream.OpTestCase;
  38 import java.util.stream.Stream;
  39 import java.util.stream.StreamOpFlagTestHelper;
  40 import java.util.stream.StreamTestDataProvider;
  41 import java.util.stream.TestData;
  42 
  43 import org.testng.annotations.Test;
  44 
  45 import static java.util.stream.LambdaTestHelpers.countTo;
  46 import static java.util.stream.LambdaTestHelpers.mDoubler;
  47 import static java.util.stream.LambdaTestHelpers.mId;
  48 import static java.util.stream.LambdaTestHelpers.mZero;
  49 import static java.util.stream.LambdaTestHelpers.pEven;
  50 import static java.util.stream.LambdaTestHelpers.pFalse;
  51 import static java.util.stream.LambdaTestHelpers.pOdd;
  52 import static java.util.stream.LambdaTestHelpers.pTrue;
  53 
  54 /**
  55  * GroupByOpTest
  56  *
  57  */
  58 @Test
  59 public class GroupByOpTest extends OpTestCase {
  60 
  61     public void testBypassCollect() {
  62         Collector<Integer, Map<Boolean, List<Integer>>> collector
  63                 = Collectors.groupingBy(LambdaTestHelpers.forPredicate(pEven, true, false));

  64 
  65         Map<Boolean, List<Integer>> m = collector.resultSupplier().get();
  66         int[] ints = countTo(10).stream().mapToInt(e -> (int) e).toArray();
  67         for (int i : ints)
  68             m = collector.accumulator().apply(m, i);
  69 
  70         assertEquals(2, m.keySet().size());
  71         for(Collection<Integer> group : m.values()) {
  72             int count = 0;
  73             Stream<Integer> stream = group.stream();
  74             Iterator<Integer> it = stream.iterator();
  75             while (it.hasNext()) {
  76                 it.next();
  77                 ++count;
  78             }
  79             assertEquals(5, count);
  80         }
  81     }
  82 
  83     public void testGroupBy() {
  84         Map<Boolean,List<Integer>> result = countTo(10).stream().collect(Collectors.groupingBy(LambdaTestHelpers.forPredicate(pEven, true, false)));
  85 
  86         assertEquals(2, result.keySet().size());
  87         for(Collection<Integer> group : result.values()) {
  88             int count = 0;


 113             new MapperData<>(mId, uniqueSize),
 114             new MapperData<>(mZero, Math.min(1, data.size())),
 115             new MapperData<>(mDoubler, uniqueSize),
 116             new MapperData<>(LambdaTestHelpers.compose(mId, mDoubler), uniqueSize),
 117             new MapperData<>(LambdaTestHelpers.compose(mDoubler, mDoubler), uniqueSize),
 118 
 119             new MapperData<>(LambdaTestHelpers.forPredicate(pFalse, true, false), Math.min(1, uniqueSize)),
 120             new MapperData<>(LambdaTestHelpers.forPredicate(pTrue, true, false), Math.min(1, uniqueSize)),
 121             new MapperData<>(LambdaTestHelpers.forPredicate(pEven, true, false), Math.min(2, uniqueSize)),
 122             new MapperData<>(LambdaTestHelpers.forPredicate(pOdd, true, false), Math.min(2, uniqueSize))
 123         );
 124     }
 125 
 126     @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
 127     public void testOps(String name, TestData.OfRef<Integer> data) {
 128         // @@@ More things to test here:
 129         //     - Every value in data is present in right bucket
 130         //     - Total number of values equals size of data
 131 
 132         for (MapperData<Integer, ?> md : getMapperData(data)) {
 133             Collector<Integer, Map<Object, List<Integer>>> tab = Collectors.groupingBy(md.m);
 134             Map<Object, List<Integer>> result =
 135                     withData(data)
 136                     .terminal(s -> s, s -> s.collect(tab))
 137                     .resultAsserter((act, exp, ord, par) -> {
 138                         if (par & !ord) {
 139                             GroupByOpTest.assertMultiMapEquals(act, exp);
 140                         }
 141                         else {
 142                             GroupByOpTest.assertObjectEquals(act, exp);
 143                         }
 144                     })
 145                     .exercise();
 146             assertEquals(result.keySet().size(), md.expectedSize);
 147         }
 148     }
 149 
 150     static void assertObjectEquals(Object a, Object b) {
 151         assertTrue(Objects.equals(a, b));
 152     }
 153 


  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 package org.openjdk.tests.java.util.stream;
  24 
  25 import java.util.Arrays;
  26 import java.util.Collection;
  27 import java.util.HashSet;
  28 import java.util.Iterator;
  29 import java.util.List;
  30 import java.util.Map;
  31 import java.util.Objects;
  32 import java.util.Set;
  33 import java.util.function.Function;
  34 import java.util.stream.Collector;
  35 import java.util.stream.Collectors;
  36 import java.util.stream.LambdaTestHelpers;
  37 import java.util.stream.OpTestCase;
  38 import java.util.stream.Stream;

  39 import java.util.stream.StreamTestDataProvider;
  40 import java.util.stream.TestData;
  41 
  42 import org.testng.annotations.Test;
  43 
  44 import static java.util.stream.LambdaTestHelpers.countTo;
  45 import static java.util.stream.LambdaTestHelpers.mDoubler;
  46 import static java.util.stream.LambdaTestHelpers.mId;
  47 import static java.util.stream.LambdaTestHelpers.mZero;
  48 import static java.util.stream.LambdaTestHelpers.pEven;
  49 import static java.util.stream.LambdaTestHelpers.pFalse;
  50 import static java.util.stream.LambdaTestHelpers.pOdd;
  51 import static java.util.stream.LambdaTestHelpers.pTrue;
  52 
  53 /**
  54  * GroupByOpTest
  55  *
  56  */
  57 @Test
  58 public class GroupByOpTest extends OpTestCase {
  59 
  60     public void testBypassCollect() {
  61         @SuppressWarnings("unchecked")
  62         Collector<Integer, Map<Boolean, List<Integer>>, Map<Boolean, List<Integer>>> collector
  63                 = (Collector<Integer, Map<Boolean, List<Integer>>, Map<Boolean, List<Integer>>>) Collectors.groupingBy(LambdaTestHelpers.forPredicate(pEven, true, false));
  64 
  65         Map<Boolean, List<Integer>> m = collector.supplier().get();
  66         int[] ints = countTo(10).stream().mapToInt(e -> (int) e).toArray();
  67         for (int i : ints)
  68             collector.accumulator().accept(m, i);
  69 
  70         assertEquals(2, m.keySet().size());
  71         for(Collection<Integer> group : m.values()) {
  72             int count = 0;
  73             Stream<Integer> stream = group.stream();
  74             Iterator<Integer> it = stream.iterator();
  75             while (it.hasNext()) {
  76                 it.next();
  77                 ++count;
  78             }
  79             assertEquals(5, count);
  80         }
  81     }
  82 
  83     public void testGroupBy() {
  84         Map<Boolean,List<Integer>> result = countTo(10).stream().collect(Collectors.groupingBy(LambdaTestHelpers.forPredicate(pEven, true, false)));
  85 
  86         assertEquals(2, result.keySet().size());
  87         for(Collection<Integer> group : result.values()) {
  88             int count = 0;


 113             new MapperData<>(mId, uniqueSize),
 114             new MapperData<>(mZero, Math.min(1, data.size())),
 115             new MapperData<>(mDoubler, uniqueSize),
 116             new MapperData<>(LambdaTestHelpers.compose(mId, mDoubler), uniqueSize),
 117             new MapperData<>(LambdaTestHelpers.compose(mDoubler, mDoubler), uniqueSize),
 118 
 119             new MapperData<>(LambdaTestHelpers.forPredicate(pFalse, true, false), Math.min(1, uniqueSize)),
 120             new MapperData<>(LambdaTestHelpers.forPredicate(pTrue, true, false), Math.min(1, uniqueSize)),
 121             new MapperData<>(LambdaTestHelpers.forPredicate(pEven, true, false), Math.min(2, uniqueSize)),
 122             new MapperData<>(LambdaTestHelpers.forPredicate(pOdd, true, false), Math.min(2, uniqueSize))
 123         );
 124     }
 125 
 126     @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
 127     public void testOps(String name, TestData.OfRef<Integer> data) {
 128         // @@@ More things to test here:
 129         //     - Every value in data is present in right bucket
 130         //     - Total number of values equals size of data
 131 
 132         for (MapperData<Integer, ?> md : getMapperData(data)) {
 133             Collector<Integer, ?, Map<Object, List<Integer>>> tab = Collectors.groupingBy(md.m);
 134             Map<Object, List<Integer>> result =
 135                     withData(data)
 136                     .terminal(s -> s, s -> s.collect(tab))
 137                     .resultAsserter((act, exp, ord, par) -> {
 138                         if (par & !ord) {
 139                             GroupByOpTest.assertMultiMapEquals(act, exp);
 140                         }
 141                         else {
 142                             GroupByOpTest.assertObjectEquals(act, exp);
 143                         }
 144                     })
 145                     .exercise();
 146             assertEquals(result.keySet().size(), md.expectedSize);
 147         }
 148     }
 149 
 150     static void assertObjectEquals(Object a, Object b) {
 151         assertTrue(Objects.equals(a, b));
 152     }
 153