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;
envoy_service_discovery_v3_AdsDummy_new(upb_arena * arena)30
31 import org.testng.annotations.DataProvider;
32 import org.testng.annotations.Test;
envoy_service_discovery_v3_AdsDummy_parse(const char * buf,size_t size,upb_arena * arena)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;
envoy_service_discovery_v3_AdsDummy_parse_ex(const char * buf,size_t size,const upb_extreg * extreg,int options,upb_arena * arena)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;
envoy_service_discovery_v3_AdsDummy_serialize(const envoy_service_discovery_v3_AdsDummy * msg,upb_arena * arena,size_t * len)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>")
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>")
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
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
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)
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
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)
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)
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")
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")
185 public void testIntNullMapper(IntStream s) {
186 checkNPE(() -> s.mapMulti(null));
187 }
188
189 @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
190 public void testIntOps(String name, TestData.OfInt data) {
191 testIntOps(name, data, s -> s);
192 testIntOps(name, data, s -> delegateTo(s));
193 }
194
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)
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)
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")
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")
239 public void testDoubleNullMapper(DoubleStream s) {
240 checkNPE(() -> s.mapMulti(null));
241 }
242
243 @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
244 public void testDoubleOps(String name, TestData.OfDouble data) {
245 testDoubleOps(name, data, s -> s);
246 testDoubleOps(name, data, s -> delegateTo(s));
247 }
248
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)
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)
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")
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")
287 public void testLongNullMapper(LongStream s) {
288 checkNPE(() -> s.mapMulti(null));
289 }
290
291 @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
292 public void testLongOps(String name, TestData.OfLong data) {
293 testLongOps(name, data, s -> s);
294 testLongOps(name, data, s -> delegateTo(s));
295 }
296
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)
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)
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