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