1 /*
2 * Copyright (c) 2012, 2013, 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 package org.openjdk.tests.java.util.stream;
24
25 import java.util.Arrays;
26 import java.util.Comparator;
27 import java.util.List;
28 import java.util.Spliterator;
29 import java.util.function.Consumer;
30 import java.util.function.DoubleConsumer;
31 import java.util.function.Function;
32 import java.util.function.IntConsumer;
33 import java.util.function.LongConsumer;
34 import java.util.function.UnaryOperator;
35 import java.util.stream.DoubleStream;
36 import java.util.stream.DoubleStreamTestDataProvider;
37 import java.util.stream.IntStream;
38 import java.util.stream.IntStreamTestDataProvider;
39 import java.util.stream.LambdaTestHelpers;
40 import java.util.stream.LongStream;
41 import java.util.stream.LongStreamTestDataProvider;
42 import java.util.stream.OpTestCase;
43 import java.util.stream.SpliteratorTestHelper;
44 import java.util.stream.Stream;
45 import java.util.stream.StreamSupport;
46 import java.util.stream.StreamTestDataProvider;
47 import java.util.stream.TestData;
48
49 import org.testng.Assert;
50 import org.testng.annotations.Test;
51
52 import static java.util.stream.LambdaTestHelpers.countTo;
53 import static java.util.stream.LambdaTestHelpers.dpEven;
54 import static java.util.stream.LambdaTestHelpers.ipEven;
55 import static java.util.stream.LambdaTestHelpers.irDoubler;
56 import static java.util.stream.LambdaTestHelpers.lpEven;
57 import static java.util.stream.LambdaTestHelpers.mDoubler;
58 import static java.util.stream.LambdaTestHelpers.pEven;
59 import static java.util.stream.LambdaTestHelpers.permuteStreamFunctions;
60
61 @Test
62 public class StreamSpliteratorTest extends OpTestCase {
63
64 private static class ProxyNoExactSizeSpliterator<T> implements Spliterator<T> {
65 final Spliterator<T> sp;
66 final boolean proxyEstimateSize;
67 int splits = 0;
68 int prefixSplits = 0;
69
70 long sizeOnTraversal = -1;
71
72 ProxyNoExactSizeSpliterator(Spliterator<T> sp, boolean proxyEstimateSize) {
73 this.sp = sp;
74 this.proxyEstimateSize = proxyEstimateSize;
75 }
76
77 @Override
78 public Spliterator<T> trySplit() {
79 splits++;
80 Spliterator<T> prefix = sp.trySplit();
81 if (prefix != null)
82 prefixSplits++;
83 return prefix;
84 }
85
86 @Override
87 public boolean tryAdvance(Consumer<? super T> consumer) {
88 if (sizeOnTraversal == -1)
89 sizeOnTraversal = sp.getExactSizeIfKnown();
90 return sp.tryAdvance(consumer);
91 }
92
93 @Override
94 public void forEachRemaining(Consumer<? super T> consumer) {
95 sizeOnTraversal = sp.getExactSizeIfKnown();
96 sp.forEachRemaining(consumer);
97 }
98
99 @Override
100 public long estimateSize() {
101 return proxyEstimateSize ? sp.estimateSize() : Long.MAX_VALUE;
102 }
103
104 @Override
105 public Comparator<? super T> getComparator() {
106 return sp.getComparator();
107 }
108
109 @Override
110 public int characteristics() {
111 if (proxyEstimateSize)
112 return sp.characteristics();
113 else
114 return sp.characteristics() & ~(Spliterator.SUBSIZED | Spliterator.SIZED);
115 }
116
117 private static class OfInt extends ProxyNoExactSizeSpliterator<Integer> implements Spliterator.OfInt {
118 final Spliterator.OfInt psp;
119
120 private OfInt(Spliterator.OfInt sp, boolean proxyEstimateSize) {
121 super(sp, proxyEstimateSize);
122 this.psp = sp;
123 }
124
125 @Override
126 public Spliterator.OfInt trySplit() {
127 splits++;
128 Spliterator.OfInt prefix = psp.trySplit();
129 if (prefix != null)
130 prefixSplits++;
131 return prefix;
132 }
133
134 @Override
135 public boolean tryAdvance(Consumer<? super Integer> consumer) {
136 return Spliterator.OfInt.super.tryAdvance(consumer);
137 }
138
139 @Override
140 public void forEachRemaining(Consumer<? super Integer> consumer) {
141 Spliterator.OfInt.super.forEachRemaining(consumer);
142 }
143
144 @Override
145 public boolean tryAdvance(IntConsumer consumer) {
146 if (sizeOnTraversal == -1)
147 sizeOnTraversal = sp.getExactSizeIfKnown();
148 return psp.tryAdvance(consumer);
149 }
150
151 @Override
152 public void forEachRemaining(IntConsumer consumer) {
153 sizeOnTraversal = sp.getExactSizeIfKnown();
154 psp.forEachRemaining(consumer);
155 }
156 }
157
158 private static class OfLong extends ProxyNoExactSizeSpliterator<Long> implements Spliterator.OfLong {
159 final Spliterator.OfLong psp;
160
161 private OfLong(Spliterator.OfLong sp, boolean proxyEstimateSize) {
162 super(sp, proxyEstimateSize);
163 this.psp = sp;
164 }
165
166 @Override
167 public Spliterator.OfLong trySplit() {
168 splits++;
169 Spliterator.OfLong prefix = psp.trySplit();
170 if (prefix != null)
171 prefixSplits++;
172 return prefix;
173 }
174
175 @Override
176 public boolean tryAdvance(Consumer<? super Long> consumer) {
177 return Spliterator.OfLong.super.tryAdvance(consumer);
178 }
179
180 @Override
181 public void forEachRemaining(Consumer<? super Long> consumer) {
182 Spliterator.OfLong.super.forEachRemaining(consumer);
183 }
184
185 @Override
186 public boolean tryAdvance(LongConsumer consumer) {
187 if (sizeOnTraversal == -1)
188 sizeOnTraversal = sp.getExactSizeIfKnown();
189 return psp.tryAdvance(consumer);
190 }
191
192 @Override
193 public void forEachRemaining(LongConsumer consumer) {
194 sizeOnTraversal = sp.getExactSizeIfKnown();
195 psp.forEachRemaining(consumer);
196 }
197 }
198
199 private static class OfDouble extends ProxyNoExactSizeSpliterator<Double>
200 implements Spliterator.OfDouble {
201 final Spliterator.OfDouble psp;
202
203 private OfDouble(Spliterator.OfDouble sp, boolean proxyEstimateSize) {
204 super(sp, proxyEstimateSize);
205 this.psp = sp;
206 }
207
208 @Override
209 public Spliterator.OfDouble trySplit() {
210 splits++;
211 Spliterator.OfDouble prefix = psp.trySplit();
212 if (prefix != null)
213 prefixSplits++;
214 return prefix;
215 }
216
217 @Override
218 public boolean tryAdvance(Consumer<? super Double> consumer) {
219 return Spliterator.OfDouble.super.tryAdvance(consumer);
220 }
221
222 @Override
223 public void forEachRemaining(Consumer<? super Double> consumer) {
224 Spliterator.OfDouble.super.forEachRemaining(consumer);
225 }
226
227 @Override
228 public boolean tryAdvance(DoubleConsumer consumer) {
229 if (sizeOnTraversal == -1)
230 sizeOnTraversal = sp.getExactSizeIfKnown();
231 return psp.tryAdvance(consumer);
232 }
233
234 @Override
235 public void forEachRemaining(DoubleConsumer consumer) {
236 sizeOnTraversal = sp.getExactSizeIfKnown();
237 psp.forEachRemaining(consumer);
238 }
239 }
240 }
241
242 public void testSplitting() {
243 // Size is assumed to be larger than the target size for no splitting
244 // @@@ Need way to obtain the target size
245 List<Integer> l = countTo(1000);
246
247 List<Consumer<Stream<Integer>>> terminalOps = Arrays.asList(
248 s -> s.toArray(),
249 s -> s.forEach(e -> { }),
250 s -> s.reduce(Integer::sum)
251 );
252
253 List<UnaryOperator<Stream<Integer>>> intermediateOps = Arrays.asList(
254 s -> s.parallel(),
255 // The following ensures the wrapping spliterator is tested
256 s -> s.map(LambdaTestHelpers.identity()).parallel()
257 );
258
259 for (int i = 0; i < terminalOps.size(); i++) {
260 setContext("termOpIndex", i);
261 Consumer<Stream<Integer>> terminalOp = terminalOps.get(i);
262 for (int j = 0; j < intermediateOps.size(); j++) {
263 setContext("intOpIndex", j);
264 UnaryOperator<Stream<Integer>> intermediateOp = intermediateOps.get(j);
265 for (boolean proxyEstimateSize : new boolean[] {false, true}) {
266 setContext("proxyEstimateSize", proxyEstimateSize);
267 Spliterator<Integer> sp = intermediateOp.apply(l.stream()).spliterator();
268 ProxyNoExactSizeSpliterator<Integer> psp = new ProxyNoExactSizeSpliterator<>(sp, proxyEstimateSize);
269 Stream<Integer> s = StreamSupport.stream(psp, true);
270 terminalOp.accept(s);
271 Assert.assertTrue(psp.splits > 0,
272 String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
273 proxyEstimateSize));
274 Assert.assertTrue(psp.prefixSplits > 0,
275 String.format("Number of non-null prefix splits should be greater that zero when proxyEstimateSize is %s",
276 proxyEstimateSize));
277 Assert.assertTrue(psp.sizeOnTraversal < l.size(),
278 String.format("Size on traversal of last split should be less than the size of the list, %d, when proxyEstimateSize is %s",
279 l.size(), proxyEstimateSize));
280 }
281 }
282 }
283 }
284
285 @Test(dataProvider = "StreamTestData<Integer>",
286 dataProviderClass = StreamTestDataProvider.class,
287 groups = { "serialization-hostile" })
288 public void testStreamSpliterators(String name, TestData.OfRef<Integer> data) {
289 for (Function<Stream<Integer>, Stream<Integer>> f : streamFunctions()) {
290 withData(data).
291 stream((Stream<Integer> in) -> {
292 Stream<Integer> out = f.apply(in);
293 return StreamSupport.stream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
294 }).
295 exercise();
296
297 withData(data).
298 stream((Stream<Integer> in) -> {
299 Stream<Integer> out = f.apply(in);
300 return StreamSupport.stream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
301 }).
302 exercise();
303 }
304 }
305
306 @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
307 public void testSpliterators(String name, TestData.OfRef<Integer> data) {
308 for (Function<Stream<Integer>, Stream<Integer>> f : streamFunctions()) {
309 SpliteratorTestHelper.testSpliterator(() -> f.apply(data.stream()).spliterator());
310 }
311 }
312
313 @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
314 public void testParSpliterators(String name, TestData.OfRef<Integer> data) {
315 for (Function<Stream<Integer>, Stream<Integer>> f : streamFunctions()) {
316 SpliteratorTestHelper.testSpliterator(() -> f.apply(data.parallelStream()).spliterator());
317 }
318 }
319
320 private List<Function<Stream<Integer>, Stream<Integer>>> streamFunctions;
321
322 List<Function<Stream<Integer>, Stream<Integer>>> streamFunctions() {
323 if (streamFunctions == null) {
324 List<Function<Stream<Integer>, Stream<Integer>>> opFunctions = Arrays.asList(
325 s -> s.filter(pEven),
326 s -> s.map(mDoubler),
327 // @@@ Add distinct once asserting results with or without order
328 // is correctly supported
329 // s -> s.distinct(),
330 s -> s.sorted());
331
332 streamFunctions = permuteStreamFunctions(opFunctions);
333 }
334
335 return streamFunctions;
336 }
337
338 //
339
340 public void testIntSplitting() {
341 List<Consumer<IntStream>> terminalOps = Arrays.asList(
342 s -> s.toArray(),
343 s -> s.forEach(e -> {}),
344 s -> s.reduce(Integer::sum)
345 );
346
347 List<UnaryOperator<IntStream>> intermediateOps = Arrays.asList(
348 s -> s.parallel(),
349 // The following ensures the wrapping spliterator is tested
350 s -> s.map(i -> i).parallel()
351 );
352
353 for (int i = 0; i < terminalOps.size(); i++) {
354 setContext("termOpIndex", i);
355 Consumer<IntStream> terminalOp = terminalOps.get(i);
356 for (int j = 0; j < intermediateOps.size(); j++) {
357 setContext("intOpIndex", j);
358 UnaryOperator<IntStream> intermediateOp = intermediateOps.get(j);
359 for (boolean proxyEstimateSize : new boolean[] {false, true}) {
360 setContext("proxyEstimateSize", proxyEstimateSize);
361 // Size is assumed to be larger than the target size for no splitting
362 // @@@ Need way to obtain the target size
363 Spliterator.OfInt sp = intermediateOp.apply(IntStream.range(0, 1000)).spliterator();
364 ProxyNoExactSizeSpliterator.OfInt psp = new ProxyNoExactSizeSpliterator.OfInt(sp, proxyEstimateSize);
365 IntStream s = StreamSupport.intStream(psp, true);
366 terminalOp.accept(s);
367 Assert.assertTrue(psp.splits > 0,
368 String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
369 proxyEstimateSize));
370 Assert.assertTrue(psp.prefixSplits > 0,
371 String.format("Number of non-null prefix splits should be greater that zero when proxyEstimateSize is %s",
372 proxyEstimateSize));
373 Assert.assertTrue(psp.sizeOnTraversal < 1000,
374 String.format("Size on traversal of last split should be less than the size of the list, %d, when proxyEstimateSize is %s",
375 1000, proxyEstimateSize));
376 }
377 }
378 }
379 }
380
381 @Test(dataProvider = "IntStreamTestData",
382 dataProviderClass = IntStreamTestDataProvider.class,
383 groups = { "serialization-hostile" })
384 public void testIntStreamSpliterators(String name, TestData.OfInt data) {
385 for (Function<IntStream, IntStream> f : intStreamFunctions()) {
386 withData(data).
387 stream(in -> {
388 IntStream out = f.apply(in);
389 return StreamSupport.intStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
390 }).
391 exercise();
392
393 withData(data).
394 stream((in) -> {
395 IntStream out = f.apply(in);
396 return StreamSupport.intStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
397 }).
398 exercise();
399 }
400 }
401
402 @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
403 public void testIntSpliterators(String name, TestData.OfInt data) {
404 for (Function<IntStream, IntStream> f : intStreamFunctions()) {
405 SpliteratorTestHelper.testIntSpliterator(() -> f.apply(data.stream()).spliterator());
406 }
407 }
408
409 @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
410 public void testIntParSpliterators(String name, TestData.OfInt data) {
411 for (Function<IntStream, IntStream> f : intStreamFunctions()) {
412 SpliteratorTestHelper.testIntSpliterator(() -> f.apply(data.parallelStream()).spliterator());
413 }
414 }
415
416 private List<Function<IntStream, IntStream>> intStreamFunctions;
417
418 List<Function<IntStream, IntStream>> intStreamFunctions() {
419 if (intStreamFunctions == null) {
420 List<Function<IntStream, IntStream>> opFunctions = Arrays.asList(
421 s -> s.filter(ipEven),
422 s -> s.map(irDoubler),
423 s -> s.sorted());
424
425 intStreamFunctions = permuteStreamFunctions(opFunctions);
426 }
427
428 return intStreamFunctions;
429 }
430
431 //
432
433 public void testLongSplitting() {
434 List<Consumer<LongStream>> terminalOps = Arrays.asList(
435 s -> s.toArray(),
436 s -> s.forEach(e -> {}),
437 s -> s.reduce(Long::sum)
438 );
439
440 List<UnaryOperator<LongStream>> intermediateOps = Arrays.asList(
441 s -> s.parallel(),
442 // The following ensures the wrapping spliterator is tested
443 s -> s.map(i -> i).parallel()
444 );
445
446 for (int i = 0; i < terminalOps.size(); i++) {
447 Consumer<LongStream> terminalOp = terminalOps.get(i);
448 setContext("termOpIndex", i);
449 for (int j = 0; j < intermediateOps.size(); j++) {
450 setContext("intOpIndex", j);
451 UnaryOperator<LongStream> intermediateOp = intermediateOps.get(j);
452 for (boolean proxyEstimateSize : new boolean[] {false, true}) {
453 setContext("proxyEstimateSize", proxyEstimateSize);
454 // Size is assumed to be larger than the target size for no splitting
455 // @@@ Need way to obtain the target size
456 Spliterator.OfLong sp = intermediateOp.apply(LongStream.range(0, 1000)).spliterator();
457 ProxyNoExactSizeSpliterator.OfLong psp = new ProxyNoExactSizeSpliterator.OfLong(sp, proxyEstimateSize);
458 LongStream s = StreamSupport.longStream(psp, true);
459 terminalOp.accept(s);
460 Assert.assertTrue(psp.splits > 0,
461 String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
462 proxyEstimateSize));
463 Assert.assertTrue(psp.prefixSplits > 0,
464 String.format("Number of non-null prefix splits should be greater that zero when proxyEstimateSize is %s",
465 proxyEstimateSize));
466 Assert.assertTrue(psp.sizeOnTraversal < 1000,
467 String.format("Size on traversal of last split should be less than the size of the list, %d, when proxyEstimateSize is %s",
468 1000, proxyEstimateSize));
469 }
470 }
471 }
472 }
473
474 @Test(dataProvider = "LongStreamTestData",
475 dataProviderClass = LongStreamTestDataProvider.class,
476 groups = { "serialization-hostile" })
477 public void testLongStreamSpliterators(String name, TestData.OfLong data) {
478 for (Function<LongStream, LongStream> f : longStreamFunctions()) {
479 withData(data).
480 stream(in -> {
481 LongStream out = f.apply(in);
482 return StreamSupport.longStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
483 }).
484 exercise();
485
486 withData(data).
487 stream((in) -> {
488 LongStream out = f.apply(in);
489 return StreamSupport.longStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
490 }).
491 exercise();
492 }
493 }
494
495 @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
496 public void testLongSpliterators(String name, TestData.OfLong data) {
497 for (Function<LongStream, LongStream> f : longStreamFunctions()) {
498 SpliteratorTestHelper.testLongSpliterator(() -> f.apply(data.stream()).spliterator());
499 }
500 }
501
502 @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
503 public void testLongParSpliterators(String name, TestData.OfLong data) {
504 for (Function<LongStream, LongStream> f : longStreamFunctions()) {
505 SpliteratorTestHelper.testLongSpliterator(() -> f.apply(data.parallelStream()).spliterator());
506 }
507 }
508
509 private List<Function<LongStream, LongStream>> longStreamFunctions;
510
511 List<Function<LongStream, LongStream>> longStreamFunctions() {
512 if (longStreamFunctions == null) {
513 List<Function<LongStream, LongStream>> opFunctions = Arrays.asList(
514 s -> s.filter(lpEven),
515 s -> s.map(x -> x * 2L),
516 s -> s.sorted());
517
518 longStreamFunctions = permuteStreamFunctions(opFunctions);
519 }
520
521 return longStreamFunctions;
522 }
523
524 //
525
526 public void testDoubleSplitting() {
527 List<Consumer<DoubleStream>> terminalOps = Arrays.asList(
528 s -> s.toArray(),
529 s -> s.forEach(e -> {}),
530 s -> s.reduce(Double::sum)
531 );
532
533 List<UnaryOperator<DoubleStream>> intermediateOps = Arrays.asList(
534 s -> s.parallel(),
535 // The following ensures the wrapping spliterator is tested
536 s -> s.map(i -> i).parallel()
537 );
538
539 for (int i = 0; i < terminalOps.size(); i++) {
540 Consumer<DoubleStream> terminalOp = terminalOps.get(i);
541 setContext("termOpIndex", i);
542 for (int j = 0; j < intermediateOps.size(); j++) {
543 UnaryOperator<DoubleStream> intermediateOp = intermediateOps.get(j);
544 setContext("intOpIndex", j);
545 for (boolean proxyEstimateSize : new boolean[] {false, true}) {
546 setContext("proxyEstimateSize", proxyEstimateSize);
547 // Size is assumed to be larger than the target size for no splitting
548 // @@@ Need way to obtain the target size
549 Spliterator.OfDouble sp = intermediateOp.apply(IntStream.range(0, 1000).asDoubleStream()).spliterator();
550 ProxyNoExactSizeSpliterator.OfDouble psp = new ProxyNoExactSizeSpliterator.OfDouble(sp, proxyEstimateSize);
551 DoubleStream s = StreamSupport.doubleStream(psp, true);
552 terminalOp.accept(s);
553 Assert.assertTrue(psp.splits > 0,
554 String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
555 proxyEstimateSize));
556 Assert.assertTrue(psp.prefixSplits > 0,
557 String.format("Number of non-null prefix splits should be greater that zero when proxyEstimateSize is %s",
558 proxyEstimateSize));
559 Assert.assertTrue(psp.sizeOnTraversal < 1000,
560 String.format("Size on traversal of last split should be less than the size of the list, %d, when proxyEstimateSize is %s",
561 1000, proxyEstimateSize));
562 }
563 }
564 }
565 }
566
567 @Test(dataProvider = "DoubleStreamTestData",
568 dataProviderClass = DoubleStreamTestDataProvider.class,
569 groups = { "serialization-hostile" })
570 public void testDoubleStreamSpliterators(String name, TestData.OfDouble data) {
571 for (Function<DoubleStream, DoubleStream> f : doubleStreamFunctions()) {
572 withData(data).
573 stream(in -> {
574 DoubleStream out = f.apply(in);
575 return StreamSupport.doubleStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
576 }).
577 exercise();
578
579 withData(data).
580 stream((in) -> {
581 DoubleStream out = f.apply(in);
582 return StreamSupport.doubleStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
583 }).
584 exercise();
585 }
586 }
587
588 @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
589 public void testDoubleSpliterators(String name, TestData.OfDouble data) {
590 for (Function<DoubleStream, DoubleStream> f : doubleStreamFunctions()) {
591 SpliteratorTestHelper.testDoubleSpliterator(() -> f.apply(data.stream()).spliterator());
592 }
593 }
594
595 @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
596 public void testDoubleParSpliterators(String name, TestData.OfDouble data) {
597 for (Function<DoubleStream, DoubleStream> f : doubleStreamFunctions()) {
598 SpliteratorTestHelper.testDoubleSpliterator(() -> f.apply(data.parallelStream()).spliterator());
599 }
600 }
601
602 private List<Function<DoubleStream, DoubleStream>> doubleStreamFunctions;
603
604 List<Function<DoubleStream, DoubleStream>> doubleStreamFunctions() {
605 if (doubleStreamFunctions == null) {
606 List<Function<DoubleStream, DoubleStream>> opFunctions = Arrays.asList(
607 s -> s.filter(dpEven),
608 s -> s.map(x -> x * 2.0),
609 s -> s.sorted());
610
611 doubleStreamFunctions = permuteStreamFunctions(opFunctions);
612 }
613
614 return doubleStreamFunctions;
615 }
616 }