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
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
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
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 }
|
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 s -> s.flatMap(x -> Stream.of(x, x)),
328 // @@@ Add distinct once asserting results with or without order
329 // is correctly supported
330 // s -> s.distinct(),
331 s -> s.sorted());
332
333 streamFunctions = permuteStreamFunctions(opFunctions);
334 }
335
336 return streamFunctions;
337 }
338
339 //
340
341 public void testIntSplitting() {
342 List<Consumer<IntStream>> terminalOps = Arrays.asList(
343 s -> s.toArray(),
344 s -> s.forEach(e -> {}),
345 s -> s.reduce(Integer::sum)
346 );
347
404 public void testIntSpliterators(String name, TestData.OfInt data) {
405 for (Function<IntStream, IntStream> f : intStreamFunctions()) {
406 SpliteratorTestHelper.testIntSpliterator(() -> f.apply(data.stream()).spliterator());
407 }
408 }
409
410 @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
411 public void testIntParSpliterators(String name, TestData.OfInt data) {
412 for (Function<IntStream, IntStream> f : intStreamFunctions()) {
413 SpliteratorTestHelper.testIntSpliterator(() -> f.apply(data.parallelStream()).spliterator());
414 }
415 }
416
417 private List<Function<IntStream, IntStream>> intStreamFunctions;
418
419 List<Function<IntStream, IntStream>> intStreamFunctions() {
420 if (intStreamFunctions == null) {
421 List<Function<IntStream, IntStream>> opFunctions = Arrays.asList(
422 s -> s.filter(ipEven),
423 s -> s.map(irDoubler),
424 s -> s.flatMap(x -> IntStream.of(x, x)),
425 s -> s.sorted());
426
427 intStreamFunctions = permuteStreamFunctions(opFunctions);
428 }
429
430 return intStreamFunctions;
431 }
432
433 //
434
435 public void testLongSplitting() {
436 List<Consumer<LongStream>> terminalOps = Arrays.asList(
437 s -> s.toArray(),
438 s -> s.forEach(e -> {}),
439 s -> s.reduce(Long::sum)
440 );
441
442 List<UnaryOperator<LongStream>> intermediateOps = Arrays.asList(
443 s -> s.parallel(),
444 // The following ensures the wrapping spliterator is tested
498 public void testLongSpliterators(String name, TestData.OfLong data) {
499 for (Function<LongStream, LongStream> f : longStreamFunctions()) {
500 SpliteratorTestHelper.testLongSpliterator(() -> f.apply(data.stream()).spliterator());
501 }
502 }
503
504 @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
505 public void testLongParSpliterators(String name, TestData.OfLong data) {
506 for (Function<LongStream, LongStream> f : longStreamFunctions()) {
507 SpliteratorTestHelper.testLongSpliterator(() -> f.apply(data.parallelStream()).spliterator());
508 }
509 }
510
511 private List<Function<LongStream, LongStream>> longStreamFunctions;
512
513 List<Function<LongStream, LongStream>> longStreamFunctions() {
514 if (longStreamFunctions == null) {
515 List<Function<LongStream, LongStream>> opFunctions = Arrays.asList(
516 s -> s.filter(lpEven),
517 s -> s.map(x -> x * 2L),
518 s -> s.flatMap(x -> LongStream.of(x, x)),
519 s -> s.sorted());
520
521 longStreamFunctions = permuteStreamFunctions(opFunctions);
522 }
523
524 return longStreamFunctions;
525 }
526
527 //
528
529 public void testDoubleSplitting() {
530 List<Consumer<DoubleStream>> terminalOps = Arrays.asList(
531 s -> s.toArray(),
532 s -> s.forEach(e -> {}),
533 s -> s.reduce(Double::sum)
534 );
535
536 List<UnaryOperator<DoubleStream>> intermediateOps = Arrays.asList(
537 s -> s.parallel(),
538 // The following ensures the wrapping spliterator is tested
592 public void testDoubleSpliterators(String name, TestData.OfDouble data) {
593 for (Function<DoubleStream, DoubleStream> f : doubleStreamFunctions()) {
594 SpliteratorTestHelper.testDoubleSpliterator(() -> f.apply(data.stream()).spliterator());
595 }
596 }
597
598 @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
599 public void testDoubleParSpliterators(String name, TestData.OfDouble data) {
600 for (Function<DoubleStream, DoubleStream> f : doubleStreamFunctions()) {
601 SpliteratorTestHelper.testDoubleSpliterator(() -> f.apply(data.parallelStream()).spliterator());
602 }
603 }
604
605 private List<Function<DoubleStream, DoubleStream>> doubleStreamFunctions;
606
607 List<Function<DoubleStream, DoubleStream>> doubleStreamFunctions() {
608 if (doubleStreamFunctions == null) {
609 List<Function<DoubleStream, DoubleStream>> opFunctions = Arrays.asList(
610 s -> s.filter(dpEven),
611 s -> s.map(x -> x * 2.0),
612 s -> s.flatMap(x -> DoubleStream.of(x, x)),
613 s -> s.sorted());
614
615 doubleStreamFunctions = permuteStreamFunctions(opFunctions);
616 }
617
618 return doubleStreamFunctions;
619 }
620 }
|