1 /* 2 * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 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 24 /* 25 * @test 26 * @summary Test mapMulti(BiConsumer) and primitive stream operations 27 */ 28 29 package org.openjdk.tests.java.util.stream; 30 31 import org.testng.annotations.DataProvider; 32 import org.testng.annotations.Test; 33 34 import java.util.Arrays; 35 import java.util.Collection; 36 import java.util.function.BiConsumer; 37 import java.util.function.Consumer; 38 import java.util.function.Function; 39 import java.util.stream.DefaultMethodStreams; 40 import java.util.stream.DoubleStream; 41 import java.util.stream.DoubleStreamTestDataProvider; 42 import java.util.stream.IntStream; 43 import java.util.stream.IntStreamTestDataProvider; 44 import java.util.stream.LongStream; 45 import java.util.stream.LongStreamTestDataProvider; 46 import java.util.stream.OpTestCase; 47 import java.util.stream.Stream; 48 import java.util.stream.StreamTestDataProvider; 49 import java.util.stream.TestData; 50 51 import static java.util.stream.DefaultMethodStreams.delegateTo; 52 import static java.util.stream.LambdaTestHelpers.LONG_STRING; 53 import static java.util.stream.LambdaTestHelpers.assertConcat; 54 import static java.util.stream.LambdaTestHelpers.assertContents; 55 import static java.util.stream.LambdaTestHelpers.assertCountSum; 56 import static java.util.stream.LambdaTestHelpers.countTo; 57 import static java.util.stream.LambdaTestHelpers.flattenChars; 58 import static java.util.stream.LambdaTestHelpers.mfId; 59 import static java.util.stream.LambdaTestHelpers.mfLt; 60 import static java.util.stream.LambdaTestHelpers.mfNull; 61 import static java.util.stream.ThrowableHelper.checkNPE; 62 63 @Test 64 public class mapMultiOpTest extends OpTestCase { 65 66 BiConsumer<Integer, Consumer<Integer>> nullConsumer = 67 (e, sink) -> mfNull.apply(e).forEach(sink); 68 BiConsumer<Integer, Consumer<Integer>> idConsumer = 69 (e, sink) -> mfId.apply(e).forEach(sink); 70 BiConsumer<Integer, Consumer<Integer>> listConsumer = 71 (e, sink) -> mfLt.apply(e).forEach(sink); 72 BiConsumer<String, Consumer<Character>> charConsumer = 73 (e, sink) -> flattenChars.apply(e).forEach(sink); 74 BiConsumer<Integer, Consumer<Integer>> emptyStreamConsumer = 75 (e, sink) -> Stream.empty().forEach(i -> sink.accept((Integer) i)); 76 BiConsumer<Integer, Consumer<Integer>> intRangeConsumer = 77 (e, sink) -> IntStream.range(0, e).boxed().forEach(sink); 78 BiConsumer<Integer, Consumer<Integer>> rangeConsumerWithLimit = 79 (e, sink) -> IntStream.range(0, e).boxed().limit(10).forEach(sink); 80 81 @DataProvider(name = "Stream<Integer>") streamProvider()82 public Object[][] streamProvider() { 83 return new Object[][]{ 84 {Stream.of(0, 1, 2)}, 85 {DefaultMethodStreams.delegateTo(Stream.of(0, 1, 2))} 86 }; 87 } 88 89 @Test(dataProvider = "Stream<Integer>") testNullMapper(Stream<Integer> s)90 public void testNullMapper(Stream<Integer> s) { 91 checkNPE(() -> s.mapMulti(null)); 92 checkNPE(() -> s.mapMultiToInt(null)); 93 checkNPE(() -> s.mapMultiToDouble(null)); 94 checkNPE(() -> s.mapMultiToLong(null)); 95 } 96 97 @Test testMapMulti()98 public void testMapMulti() { 99 String[] stringsArray = {"hello", "there", "", "yada"}; 100 Stream<String> strings = Arrays.asList(stringsArray).stream(); 101 102 assertConcat(strings.mapMulti(charConsumer) 103 .iterator(), "hellothereyada"); 104 assertCountSum((countTo(10).stream().mapMulti(idConsumer)), 105 10, 55); 106 assertCountSum(countTo(10).stream().mapMulti(nullConsumer), 107 0, 0); 108 assertCountSum(countTo(3).stream().mapMulti(listConsumer), 109 6, 4); 110 111 exerciseOps(TestData.Factory.ofArray("stringsArray", 112 stringsArray), s -> s.mapMulti(charConsumer)); 113 exerciseOps(TestData.Factory.ofArray("LONG_STRING", 114 new String[]{LONG_STRING}), s -> s.mapMulti(charConsumer)); 115 } 116 117 @Test testDefaultMapMulti()118 public void testDefaultMapMulti() { 119 String[] stringsArray = {"hello", "there", "", "yada"}; 120 Stream<String> strings = Arrays.stream(stringsArray); 121 122 assertConcat(delegateTo(strings) 123 .mapMulti(charConsumer).iterator(), "hellothereyada"); 124 assertCountSum(delegateTo(countTo(10).stream()) 125 .mapMulti(idConsumer), 10, 55); 126 assertCountSum(delegateTo(countTo(10).stream()) 127 .mapMulti(nullConsumer), 0, 0); 128 assertCountSum(delegateTo(countTo(3).stream()) 129 .mapMulti(listConsumer), 6, 4); 130 131 exerciseOps(TestData.Factory.ofArray("stringsArray", 132 stringsArray), s -> delegateTo(s).mapMulti(charConsumer)); 133 exerciseOps(TestData.Factory.ofArray("LONG_STRING", 134 new String[]{LONG_STRING}), s -> delegateTo(s).mapMulti(charConsumer)); 135 } 136 137 @Test(dataProvider = "StreamTestData<Integer>", 138 dataProviderClass = StreamTestDataProvider.class) testOps(String name, TestData.OfRef<Integer> data)139 public void testOps(String name, TestData.OfRef<Integer> data) { 140 testOps(name, data, s -> s); 141 testOps(name, data, s -> delegateTo(s)); 142 } 143 testOps(String name, TestData.OfRef<Integer> data, Function<Stream<Integer>, Stream<Integer>> sf)144 private void testOps(String name, 145 TestData.OfRef<Integer> data, 146 Function<Stream<Integer>, Stream<Integer>> sf) { 147 Collection<Integer> result; 148 result = exerciseOps(data, s -> sf.apply(s).mapMulti(idConsumer)); 149 assertEquals(data.size(), result.size()); 150 151 result = exerciseOps(data, s -> sf.apply(s).mapMulti(nullConsumer)); 152 assertEquals(0, result.size()); 153 154 result = exerciseOps(data, s -> sf.apply(s).mapMulti(emptyStreamConsumer)); 155 assertEquals(0, result.size()); 156 } 157 158 @Test(dataProvider = "StreamTestData<Integer>.small", 159 dataProviderClass = StreamTestDataProvider.class) testOpsX(String name, TestData.OfRef<Integer> data)160 public void testOpsX(String name, TestData.OfRef<Integer> data) { 161 exerciseOps(data, s -> s.mapMulti(listConsumer)); 162 exerciseOps(data, s -> s.mapMulti(intRangeConsumer)); 163 exerciseOps(data, s -> s.mapMulti(rangeConsumerWithLimit)); 164 } 165 166 @Test(dataProvider = "StreamTestData<Integer>.small", 167 dataProviderClass = StreamTestDataProvider.class) testDefaultOpsX(String name, TestData.OfRef<Integer> data)168 public void testDefaultOpsX(String name, TestData.OfRef<Integer> data) { 169 exerciseOps(data, s -> delegateTo(s).mapMulti(listConsumer)); 170 exerciseOps(data, s -> delegateTo(s).mapMulti(intRangeConsumer)); 171 exerciseOps(data, s -> delegateTo(s).mapMulti(rangeConsumerWithLimit)); 172 } 173 174 // Int 175 176 @DataProvider(name = "IntStream") intStreamProvider()177 public Object[][] intStreamProvider() { 178 return new Object[][]{ 179 {IntStream.of(0, 1, 2)}, 180 {DefaultMethodStreams.delegateTo(IntStream.of(0, 1, 2))} 181 }; 182 } 183 184 @Test(dataProvider = "IntStream") testIntNullMapper(IntStream s)185 public void testIntNullMapper(IntStream s) { 186 checkNPE(() -> s.mapMulti(null)); 187 } 188 189 @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class) testIntOps(String name, TestData.OfInt data)190 public void testIntOps(String name, TestData.OfInt data) { 191 testIntOps(name, data, s -> s); 192 testIntOps(name, data, s -> delegateTo(s)); 193 } 194 testIntOps(String name, TestData.OfInt data, Function<IntStream, IntStream> sf)195 private void testIntOps(String name, 196 TestData.OfInt data, 197 Function<IntStream, IntStream> sf) { 198 Collection<Integer> result = exerciseOps(data, s -> sf.apply(s).mapMulti((i, sink) -> IntStream.of(i).forEach(sink))); 199 assertEquals(data.size(), result.size()); 200 assertContents(data, result); 201 202 result = exerciseOps(data, s -> sf.apply(s).boxed().mapMultiToInt((i, sink) -> IntStream.of(i).forEach(sink))); 203 assertEquals(data.size(), result.size()); 204 assertContents(data, result); 205 206 result = exerciseOps(data, s -> sf.apply(s).mapMulti((i, sink) -> IntStream.empty().forEach(sink))); 207 assertEquals(0, result.size()); 208 } 209 210 @Test(dataProvider = "IntStreamTestData.small", dataProviderClass = IntStreamTestDataProvider.class) testIntOpsX(String name, TestData.OfInt data)211 public void testIntOpsX(String name, TestData.OfInt data) { 212 exerciseOps(data, s -> s.mapMulti((e, sink) -> IntStream.range(0, e).forEach(sink))); 213 exerciseOps(data, s -> s.mapMulti((e, sink) -> IntStream.range(0, e).limit(10).forEach(sink))); 214 215 exerciseOps(data, s -> s.boxed().mapMultiToInt((e, sink) -> IntStream.range(0, e).forEach(sink))); 216 exerciseOps(data, s -> s.boxed().mapMultiToInt((e, sink) -> IntStream.range(0, e).limit(10).forEach(sink))); 217 } 218 219 @Test(dataProvider = "IntStreamTestData.small", dataProviderClass = IntStreamTestDataProvider.class) testDefaultIntOpsX(String name, TestData.OfInt data)220 public void testDefaultIntOpsX(String name, TestData.OfInt data) { 221 exerciseOps(data, s -> delegateTo(s).mapMulti((e, sink) -> IntStream.range(0, e).forEach(sink))); 222 exerciseOps(data, s -> delegateTo(s).mapMulti((e, sink) -> IntStream.range(0, e).limit(10).forEach(sink))); 223 224 exerciseOps(data, s -> delegateTo(s).boxed().mapMultiToInt((e, sink) -> IntStream.range(0, e).forEach(sink))); 225 exerciseOps(data, s -> delegateTo(s).boxed().mapMultiToInt((e, sink) -> IntStream.range(0, e).limit(10).forEach(sink))); 226 } 227 228 // Double 229 230 @DataProvider(name = "DoubleStream") doubleStreamProvider()231 public Object[][] doubleStreamProvider() { 232 return new Object[][]{ 233 {DoubleStream.of(0, 1, 2)}, 234 {DefaultMethodStreams.delegateTo(DoubleStream.of(0, 1, 2))} 235 }; 236 } 237 238 @Test(dataProvider = "DoubleStream") testDoubleNullMapper(DoubleStream s)239 public void testDoubleNullMapper(DoubleStream s) { 240 checkNPE(() -> s.mapMulti(null)); 241 } 242 243 @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class) testDoubleOps(String name, TestData.OfDouble data)244 public void testDoubleOps(String name, TestData.OfDouble data) { 245 testDoubleOps(name, data, s -> s); 246 testDoubleOps(name, data, s -> delegateTo(s)); 247 } 248 testDoubleOps(String name, TestData.OfDouble data, Function<DoubleStream, DoubleStream> sf)249 private void testDoubleOps(String name, 250 TestData.OfDouble data, 251 Function<DoubleStream, DoubleStream> sf) { 252 Collection<Double> result = exerciseOps(data, s -> sf.apply(s).mapMulti((i, sink) -> DoubleStream.of(i).forEach(sink))); 253 assertEquals(data.size(), result.size()); 254 assertContents(data, result); 255 256 result = exerciseOps(data, s -> sf.apply(s).boxed().mapMultiToDouble((i, sink) -> DoubleStream.of(i).forEach(sink))); 257 assertEquals(data.size(), result.size()); 258 assertContents(data, result); 259 260 result = exerciseOps(data, s -> sf.apply(s).mapMulti((i, sink) -> DoubleStream.empty().forEach(sink))); 261 assertEquals(0, result.size()); 262 } 263 264 @Test(dataProvider = "DoubleStreamTestData.small", dataProviderClass = DoubleStreamTestDataProvider.class) testDoubleOpsX(String name, TestData.OfDouble data)265 public void testDoubleOpsX(String name, TestData.OfDouble data) { 266 exerciseOps(data, s -> s.mapMulti((e, sink) -> IntStream.range(0, (int) e).asDoubleStream().forEach(sink))); 267 exerciseOps(data, s -> s.mapMulti((e, sink) -> IntStream.range(0, (int) e).limit(10).asDoubleStream().forEach(sink))); 268 } 269 270 @Test(dataProvider = "DoubleStreamTestData.small", dataProviderClass = DoubleStreamTestDataProvider.class) testDefaultDoubleOpsX(String name, TestData.OfDouble data)271 public void testDefaultDoubleOpsX(String name, TestData.OfDouble data) { 272 exerciseOps(data, s -> delegateTo(s).mapMulti((e, sink) -> IntStream.range(0, (int) e).asDoubleStream().forEach(sink))); 273 exerciseOps(data, s -> delegateTo(s).mapMulti((e, sink) -> IntStream.range(0, (int) e).limit(10).asDoubleStream().forEach(sink))); 274 } 275 276 // Long 277 278 @DataProvider(name = "LongStream") longStreamProvider()279 public Object[][] longStreamProvider() { 280 return new Object[][]{ 281 {LongStream.of(0, 1, 2)}, 282 {DefaultMethodStreams.delegateTo(LongStream.of(0, 1, 2))} 283 }; 284 } 285 286 @Test(dataProvider = "LongStream") testLongNullMapper(LongStream s)287 public void testLongNullMapper(LongStream s) { 288 checkNPE(() -> s.mapMulti(null)); 289 } 290 291 @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class) testLongOps(String name, TestData.OfLong data)292 public void testLongOps(String name, TestData.OfLong data) { 293 testLongOps(name, data, s -> s); 294 testLongOps(name, data, s -> delegateTo(s)); 295 } 296 testLongOps(String name, TestData.OfLong data, Function<LongStream, LongStream> sf)297 private void testLongOps(String name, 298 TestData.OfLong data, 299 Function<LongStream, LongStream> sf) { 300 Collection<Long> result = exerciseOps(data, s -> sf.apply(s).mapMulti((i, sink) -> LongStream.of(i).forEach(sink))); 301 assertEquals(data.size(), result.size()); 302 assertContents(data, result); 303 304 result = exerciseOps(data, s -> sf.apply(s).boxed().mapMultiToLong((i, sink) -> LongStream.of(i).forEach(sink))); 305 assertEquals(data.size(), result.size()); 306 assertContents(data, result); 307 308 result = exerciseOps(data, s -> sf.apply(s).mapMulti((i, sink) -> LongStream.empty().forEach(sink))); 309 assertEquals(0, result.size()); 310 } 311 312 @Test(dataProvider = "LongStreamTestData.small", dataProviderClass = LongStreamTestDataProvider.class) testLongOpsX(String name, TestData.OfLong data)313 public void testLongOpsX(String name, TestData.OfLong data) { 314 exerciseOps(data, s -> s.mapMulti((e, sink) -> LongStream.range(0, e).forEach(sink))); 315 exerciseOps(data, s -> s.mapMulti((e, sink) -> LongStream.range(0, e).limit(10).forEach(sink))); 316 } 317 318 @Test(dataProvider = "LongStreamTestData.small", dataProviderClass = LongStreamTestDataProvider.class) testDefaultLongOpsX(String name, TestData.OfLong data)319 public void testDefaultLongOpsX(String name, TestData.OfLong data) { 320 exerciseOps(data, s -> delegateTo(s).mapMulti((e, sink) -> LongStream.range(0, e).forEach(sink))); 321 exerciseOps(data, s -> delegateTo(s).mapMulti((e, sink) -> LongStream.range(0, e).limit(10).forEach(sink))); 322 } 323 } 324