ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamSpliteratorTest.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package org.openjdk.tests.java.util.stream;

 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Spliterator;
 import java.util.function.Consumer;
 import java.util.function.DoubleConsumer;
 import java.util.function.Function;
 import java.util.function.IntConsumer;
 import java.util.function.LongConsumer;
 import java.util.function.UnaryOperator;
 import java.util.stream.DoubleStream;
 import java.util.stream.DoubleStreamTestDataProvider;
 import java.util.stream.IntStream;
 import java.util.stream.IntStreamTestDataProvider;
 import java.util.stream.LambdaTestHelpers;
 import java.util.stream.LongStream;
 import java.util.stream.LongStreamTestDataProvider;
 import java.util.stream.OpTestCase;
 import java.util.stream.SpliteratorTestHelper;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 import java.util.stream.StreamTestDataProvider;
 import java.util.stream.TestData;

 import org.testng.Assert;
 import org.testng.annotations.Test;

 import static java.util.stream.LambdaTestHelpers.countTo;
 import static java.util.stream.LambdaTestHelpers.dpEven;
 import static java.util.stream.LambdaTestHelpers.ipEven;
 import static java.util.stream.LambdaTestHelpers.irDoubler;
 import static java.util.stream.LambdaTestHelpers.lpEven;
 import static java.util.stream.LambdaTestHelpers.mDoubler;
 import static java.util.stream.LambdaTestHelpers.pEven;
 import static java.util.stream.LambdaTestHelpers.permuteStreamFunctions;

 @Test
 public class StreamSpliteratorTest extends OpTestCase {

     private static class ProxyNoExactSizeSpliterator<T> implements Spliterator<T> {
         final Spliterator<T> sp;
         final boolean proxyEstimateSize;
         int splits = 0;
         int prefixSplits = 0;

         long sizeOnTraversal = -1;

         ProxyNoExactSizeSpliterator(Spliterator<T> sp, boolean proxyEstimateSize) {
             this.sp = sp;
             this.proxyEstimateSize = proxyEstimateSize;
         }

         @Override
         public Spliterator<T> trySplit() {
             splits++;
             Spliterator<T> prefix = sp.trySplit();
             if (prefix != null)
                 prefixSplits++;
             return prefix;
         }

         @Override
         public boolean tryAdvance(Consumer<? super T> consumer) {
             if (sizeOnTraversal == -1)
                 sizeOnTraversal = sp.getExactSizeIfKnown();
             return sp.tryAdvance(consumer);
         }

         @Override
         public void forEachRemaining(Consumer<? super T> consumer) {
             sizeOnTraversal = sp.getExactSizeIfKnown();
             sp.forEachRemaining(consumer);
         }

         @Override
         public long estimateSize() {
             return proxyEstimateSize ? sp.estimateSize() : Long.MAX_VALUE;
         }

         @Override
         public Comparator<? super T> getComparator() {
             return sp.getComparator();
         }

         @Override
         public int characteristics() {
             if (proxyEstimateSize)
                 return sp.characteristics();
             else
                 return sp.characteristics() & ~(Spliterator.SUBSIZED | Spliterator.SIZED);
         }

         private static class OfInt extends ProxyNoExactSizeSpliterator<Integer> implements Spliterator.OfInt {
             final Spliterator.OfInt psp;

             private OfInt(Spliterator.OfInt sp, boolean proxyEstimateSize) {
                 super(sp, proxyEstimateSize);
                 this.psp = sp;
             }

             @Override
             public Spliterator.OfInt trySplit() {
                 splits++;
                 Spliterator.OfInt prefix = psp.trySplit();
                 if (prefix != null)
                     prefixSplits++;
                 return prefix;
             }

             @Override
             public boolean tryAdvance(Consumer<? super Integer> consumer) {
                 return Spliterator.OfInt.super.tryAdvance(consumer);
             }

             @Override
             public void forEachRemaining(Consumer<? super Integer> consumer) {
                 Spliterator.OfInt.super.forEachRemaining(consumer);
             }

             @Override
             public boolean tryAdvance(IntConsumer consumer) {
                 if (sizeOnTraversal == -1)
                     sizeOnTraversal = sp.getExactSizeIfKnown();
                 return psp.tryAdvance(consumer);
             }

             @Override
             public void forEachRemaining(IntConsumer consumer) {
                 sizeOnTraversal = sp.getExactSizeIfKnown();
                 psp.forEachRemaining(consumer);
             }
         }

         private static class OfLong extends ProxyNoExactSizeSpliterator<Long> implements Spliterator.OfLong {
             final Spliterator.OfLong psp;

             private OfLong(Spliterator.OfLong sp, boolean proxyEstimateSize) {
                 super(sp, proxyEstimateSize);
                 this.psp = sp;
             }

             @Override
             public Spliterator.OfLong trySplit() {
                 splits++;
                 Spliterator.OfLong prefix = psp.trySplit();
                 if (prefix != null)
                     prefixSplits++;
                 return prefix;
             }

             @Override
             public boolean tryAdvance(Consumer<? super Long> consumer) {
                 return Spliterator.OfLong.super.tryAdvance(consumer);
             }

             @Override
             public void forEachRemaining(Consumer<? super Long> consumer) {
                 Spliterator.OfLong.super.forEachRemaining(consumer);
             }

             @Override
             public boolean tryAdvance(LongConsumer consumer) {
                 if (sizeOnTraversal == -1)
                     sizeOnTraversal = sp.getExactSizeIfKnown();
                 return psp.tryAdvance(consumer);
             }

             @Override
             public void forEachRemaining(LongConsumer consumer) {
                 sizeOnTraversal = sp.getExactSizeIfKnown();
                 psp.forEachRemaining(consumer);
             }
         }

         private static class OfDouble extends ProxyNoExactSizeSpliterator<Double>
                 implements Spliterator.OfDouble {
             final Spliterator.OfDouble psp;

             private OfDouble(Spliterator.OfDouble sp, boolean proxyEstimateSize) {
                 super(sp, proxyEstimateSize);
                 this.psp = sp;
             }

             @Override
             public Spliterator.OfDouble trySplit() {
                 splits++;
                 Spliterator.OfDouble prefix = psp.trySplit();
                 if (prefix != null)
                     prefixSplits++;
                 return prefix;
             }

             @Override
             public boolean tryAdvance(Consumer<? super Double> consumer) {
                 return Spliterator.OfDouble.super.tryAdvance(consumer);
             }

             @Override
             public void forEachRemaining(Consumer<? super Double> consumer) {
                 Spliterator.OfDouble.super.forEachRemaining(consumer);
             }

             @Override
             public boolean tryAdvance(DoubleConsumer consumer) {
                 if (sizeOnTraversal == -1)
                     sizeOnTraversal = sp.getExactSizeIfKnown();
                 return psp.tryAdvance(consumer);
             }

             @Override
             public void forEachRemaining(DoubleConsumer consumer) {
                 sizeOnTraversal = sp.getExactSizeIfKnown();
                 psp.forEachRemaining(consumer);
             }
         }
     }

     public void testSplitting() {
         // Size is assumed to be larger than the target size for no splitting
         // @@@ Need way to obtain the target size
         List<Integer> l = countTo(1000);

         List<Consumer<Stream<Integer>>> terminalOps = Arrays.asList(
                 s -> s.toArray(),
                 s -> s.forEach(e -> { }),
                 s -> s.reduce(Integer::sum)
         );

         List<UnaryOperator<Stream<Integer>>> intermediateOps = Arrays.asList(
                 s -> s.parallel(),
                 // The following ensures the wrapping spliterator is tested
                 s -> s.map(LambdaTestHelpers.identity()).parallel()
         );

         for (int i = 0; i < terminalOps.size(); i++) {
             setContext("termOpIndex", i);
             Consumer<Stream<Integer>> terminalOp = terminalOps.get(i);
             for (int j = 0; j < intermediateOps.size(); j++) {
                 setContext("intOpIndex", j);
                 UnaryOperator<Stream<Integer>> intermediateOp = intermediateOps.get(j);
                 for (boolean proxyEstimateSize : new boolean[] {false, true}) {
                     setContext("proxyEstimateSize", proxyEstimateSize);
                     Spliterator<Integer> sp = intermediateOp.apply(l.stream()).spliterator();
                     ProxyNoExactSizeSpliterator<Integer> psp = new ProxyNoExactSizeSpliterator<>(sp, proxyEstimateSize);
                     Stream<Integer> s = StreamSupport.stream(psp, true);
                     terminalOp.accept(s);
                     Assert.assertTrue(psp.splits > 0,
                                       String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
                                                     proxyEstimateSize));
                     Assert.assertTrue(psp.prefixSplits > 0,
                                       String.format("Number of non-null prefix splits should be greater that zero when proxyEstimateSize is %s",
                                                     proxyEstimateSize));
                     Assert.assertTrue(psp.sizeOnTraversal < l.size(),
                                       String.format("Size on traversal of last split should be less than the size of the list, %d, when proxyEstimateSize is %s",
                                                     l.size(), proxyEstimateSize));
                 }
             }
         }
     }

     @Test(dataProvider = "StreamTestData<Integer>",
           dataProviderClass = StreamTestDataProvider.class,
           groups = { "serialization-hostile" })
     public void testStreamSpliterators(String name, TestData.OfRef<Integer> data) {
         for (Function<Stream<Integer>, Stream<Integer>> f : streamFunctions()) {
             withData(data).
                     stream((Stream<Integer> in) -> {
                         Stream<Integer> out = f.apply(in);
                         return StreamSupport.stream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
                     }).
                     exercise();

             withData(data).
                     stream((Stream<Integer> in) -> {
                         Stream<Integer> out = f.apply(in);
                         return StreamSupport.stream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
                     }).
                     exercise();
         }
     }

     @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
     public void testSpliterators(String name, TestData.OfRef<Integer> data) {
         for (Function<Stream<Integer>, Stream<Integer>> f : streamFunctions()) {
             SpliteratorTestHelper.testSpliterator(() -> f.apply(data.stream()).spliterator());
         }
     }

     @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
     public void testParSpliterators(String name, TestData.OfRef<Integer> data) {
         for (Function<Stream<Integer>, Stream<Integer>> f : streamFunctions()) {
             SpliteratorTestHelper.testSpliterator(() -> f.apply(data.parallelStream()).spliterator());
         }
     }

     private List<Function<Stream<Integer>, Stream<Integer>>> streamFunctions;

     List<Function<Stream<Integer>, Stream<Integer>>> streamFunctions() {
         if (streamFunctions == null) {
             List<Function<Stream<Integer>, Stream<Integer>>> opFunctions = Arrays.asList(
                     s -> s.filter(pEven),
                     s -> s.map(mDoubler),
                     // @@@ Add distinct once asserting results with or without order
                     //     is correctly supported
 //                    s -> s.distinct(),
                     s -> s.sorted());

             streamFunctions = permuteStreamFunctions(opFunctions);
         }

         return streamFunctions;
     }

     //

     public void testIntSplitting() {
         List<Consumer<IntStream>> terminalOps = Arrays.asList(
                 s -> s.toArray(),
                 s -> s.forEach(e -> {}),
                 s -> s.reduce(Integer::sum)
         );

         List<UnaryOperator<IntStream>> intermediateOps = Arrays.asList(
                 s -> s.parallel(),
                 // The following ensures the wrapping spliterator is tested
                 s -> s.map(i -> i).parallel()
         );

         for (int i = 0; i < terminalOps.size(); i++) {
             setContext("termOpIndex", i);
             Consumer<IntStream> terminalOp = terminalOps.get(i);
             for (int j = 0; j < intermediateOps.size(); j++) {
                 setContext("intOpIndex", j);
                 UnaryOperator<IntStream> intermediateOp = intermediateOps.get(j);
                 for (boolean proxyEstimateSize : new boolean[] {false, true}) {
                     setContext("proxyEstimateSize", proxyEstimateSize);
                     // Size is assumed to be larger than the target size for no splitting
                     // @@@ Need way to obtain the target size
                     Spliterator.OfInt sp = intermediateOp.apply(IntStream.range(0, 1000)).spliterator();
                     ProxyNoExactSizeSpliterator.OfInt psp = new ProxyNoExactSizeSpliterator.OfInt(sp, proxyEstimateSize);
                     IntStream s = StreamSupport.intStream(psp, true);
                     terminalOp.accept(s);
                     Assert.assertTrue(psp.splits > 0,
                                       String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
                                                     proxyEstimateSize));
                     Assert.assertTrue(psp.prefixSplits > 0,
                                       String.format("Number of non-null prefix splits should be greater that zero when proxyEstimateSize is %s",
                                                     proxyEstimateSize));
                     Assert.assertTrue(psp.sizeOnTraversal < 1000,
                                       String.format("Size on traversal of last split should be less than the size of the list, %d, when proxyEstimateSize is %s",
                                                     1000, proxyEstimateSize));
                 }
             }
         }
     }

     @Test(dataProvider = "IntStreamTestData",
           dataProviderClass = IntStreamTestDataProvider.class,
           groups = { "serialization-hostile" })
     public void testIntStreamSpliterators(String name, TestData.OfInt data) {
         for (Function<IntStream, IntStream> f : intStreamFunctions()) {
             withData(data).
                     stream(in -> {
                         IntStream out = f.apply(in);
                         return StreamSupport.intStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
                     }).
                     exercise();

             withData(data).
                     stream((in) -> {
                         IntStream out = f.apply(in);
                         return StreamSupport.intStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
                     }).
                     exercise();
         }
     }

     @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
     public void testIntSpliterators(String name, TestData.OfInt data) {
         for (Function<IntStream, IntStream> f : intStreamFunctions()) {
             SpliteratorTestHelper.testIntSpliterator(() -> f.apply(data.stream()).spliterator());
         }
     }

     @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
     public void testIntParSpliterators(String name, TestData.OfInt data) {
         for (Function<IntStream, IntStream> f : intStreamFunctions()) {
             SpliteratorTestHelper.testIntSpliterator(() -> f.apply(data.parallelStream()).spliterator());
         }
     }

     private List<Function<IntStream, IntStream>> intStreamFunctions;

     List<Function<IntStream, IntStream>> intStreamFunctions() {
         if (intStreamFunctions == null) {
             List<Function<IntStream, IntStream>> opFunctions = Arrays.asList(
                     s -> s.filter(ipEven),
                     s -> s.map(irDoubler),
                     s -> s.sorted());

             intStreamFunctions = permuteStreamFunctions(opFunctions);
         }

         return intStreamFunctions;
     }

     //

     public void testLongSplitting() {
         List<Consumer<LongStream>> terminalOps = Arrays.asList(
                 s -> s.toArray(),
                 s -> s.forEach(e -> {}),
                 s -> s.reduce(Long::sum)
         );

         List<UnaryOperator<LongStream>> intermediateOps = Arrays.asList(
                 s -> s.parallel(),
                 // The following ensures the wrapping spliterator is tested
                 s -> s.map(i -> i).parallel()
         );

         for (int i = 0; i < terminalOps.size(); i++) {
             Consumer<LongStream> terminalOp = terminalOps.get(i);
             setContext("termOpIndex", i);
             for (int j = 0; j < intermediateOps.size(); j++) {
                 setContext("intOpIndex", j);
                 UnaryOperator<LongStream> intermediateOp = intermediateOps.get(j);
                 for (boolean proxyEstimateSize : new boolean[] {false, true}) {
                     setContext("proxyEstimateSize", proxyEstimateSize);
                     // Size is assumed to be larger than the target size for no splitting
                     // @@@ Need way to obtain the target size
                     Spliterator.OfLong sp = intermediateOp.apply(LongStream.range(0, 1000)).spliterator();
                     ProxyNoExactSizeSpliterator.OfLong psp = new ProxyNoExactSizeSpliterator.OfLong(sp, proxyEstimateSize);
                     LongStream s = StreamSupport.longStream(psp, true);
                     terminalOp.accept(s);
                     Assert.assertTrue(psp.splits > 0,
                                       String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
                                                     proxyEstimateSize));
                     Assert.assertTrue(psp.prefixSplits > 0,
                                       String.format("Number of non-null prefix splits should be greater that zero when proxyEstimateSize is %s",
                                                     proxyEstimateSize));
                     Assert.assertTrue(psp.sizeOnTraversal < 1000,
                                       String.format("Size on traversal of last split should be less than the size of the list, %d, when proxyEstimateSize is %s",
                                                     1000, proxyEstimateSize));
                 }
             }
         }
     }

     @Test(dataProvider = "LongStreamTestData",
           dataProviderClass = LongStreamTestDataProvider.class,
           groups = { "serialization-hostile" })
     public void testLongStreamSpliterators(String name, TestData.OfLong data) {
         for (Function<LongStream, LongStream> f : longStreamFunctions()) {
             withData(data).
                     stream(in -> {
                         LongStream out = f.apply(in);
                         return StreamSupport.longStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
                     }).
                     exercise();

             withData(data).
                     stream((in) -> {
                         LongStream out = f.apply(in);
                         return StreamSupport.longStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
                     }).
                     exercise();
         }
     }

     @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
     public void testLongSpliterators(String name, TestData.OfLong data) {
         for (Function<LongStream, LongStream> f : longStreamFunctions()) {
             SpliteratorTestHelper.testLongSpliterator(() -> f.apply(data.stream()).spliterator());
         }
     }

     @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
     public void testLongParSpliterators(String name, TestData.OfLong data) {
         for (Function<LongStream, LongStream> f : longStreamFunctions()) {
             SpliteratorTestHelper.testLongSpliterator(() -> f.apply(data.parallelStream()).spliterator());
         }
     }

     private List<Function<LongStream, LongStream>> longStreamFunctions;

     List<Function<LongStream, LongStream>> longStreamFunctions() {
         if (longStreamFunctions == null) {
             List<Function<LongStream, LongStream>> opFunctions = Arrays.asList(
                     s -> s.filter(lpEven),
                     s -> s.map(x -> x * 2L),
                     s -> s.sorted());

             longStreamFunctions = permuteStreamFunctions(opFunctions);
         }

         return longStreamFunctions;
     }

     //

     public void testDoubleSplitting() {
         List<Consumer<DoubleStream>> terminalOps = Arrays.asList(
                 s -> s.toArray(),
                 s -> s.forEach(e -> {}),
                 s -> s.reduce(Double::sum)
         );

         List<UnaryOperator<DoubleStream>> intermediateOps = Arrays.asList(
                 s -> s.parallel(),
                 // The following ensures the wrapping spliterator is tested
                 s -> s.map(i -> i).parallel()
         );

         for (int i = 0; i < terminalOps.size(); i++) {
             Consumer<DoubleStream> terminalOp = terminalOps.get(i);
             setContext("termOpIndex", i);
             for (int j = 0; j < intermediateOps.size(); j++) {
                 UnaryOperator<DoubleStream> intermediateOp = intermediateOps.get(j);
                 setContext("intOpIndex", j);
                 for (boolean proxyEstimateSize : new boolean[] {false, true}) {
                     setContext("proxyEstimateSize", proxyEstimateSize);
                     // Size is assumed to be larger than the target size for no splitting
                     // @@@ Need way to obtain the target size
                     Spliterator.OfDouble sp = intermediateOp.apply(IntStream.range(0, 1000).asDoubleStream()).spliterator();
                     ProxyNoExactSizeSpliterator.OfDouble psp = new ProxyNoExactSizeSpliterator.OfDouble(sp, proxyEstimateSize);
                     DoubleStream s = StreamSupport.doubleStream(psp, true);
                     terminalOp.accept(s);
                     Assert.assertTrue(psp.splits > 0,
                                       String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
                                                     proxyEstimateSize));
                     Assert.assertTrue(psp.prefixSplits > 0,
                                       String.format("Number of non-null prefix splits should be greater that zero when proxyEstimateSize is %s",
                                                     proxyEstimateSize));
                     Assert.assertTrue(psp.sizeOnTraversal < 1000,
                                       String.format("Size on traversal of last split should be less than the size of the list, %d, when proxyEstimateSize is %s",
                                                     1000, proxyEstimateSize));
                 }
             }
         }
     }

     @Test(dataProvider = "DoubleStreamTestData",
           dataProviderClass = DoubleStreamTestDataProvider.class,
           groups = { "serialization-hostile" })
     public void testDoubleStreamSpliterators(String name, TestData.OfDouble data) {
         for (Function<DoubleStream, DoubleStream> f : doubleStreamFunctions()) {
             withData(data).
                     stream(in -> {
                         DoubleStream out = f.apply(in);
                         return StreamSupport.doubleStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
                     }).
                     exercise();

             withData(data).
                     stream((in) -> {
                         DoubleStream out = f.apply(in);
                         return StreamSupport.doubleStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
                     }).
                     exercise();
         }
     }

     @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
     public void testDoubleSpliterators(String name, TestData.OfDouble data) {
         for (Function<DoubleStream, DoubleStream> f : doubleStreamFunctions()) {
             SpliteratorTestHelper.testDoubleSpliterator(() -> f.apply(data.stream()).spliterator());
         }
     }

     @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
     public void testDoubleParSpliterators(String name, TestData.OfDouble data) {
         for (Function<DoubleStream, DoubleStream> f : doubleStreamFunctions()) {
             SpliteratorTestHelper.testDoubleSpliterator(() -> f.apply(data.parallelStream()).spliterator());
         }
     }

     private List<Function<DoubleStream, DoubleStream>> doubleStreamFunctions;

     List<Function<DoubleStream, DoubleStream>> doubleStreamFunctions() {
         if (doubleStreamFunctions == null) {
             List<Function<DoubleStream, DoubleStream>> opFunctions = Arrays.asList(
                     s -> s.filter(dpEven),
                     s -> s.map(x -> x * 2.0),
                     s -> s.sorted());

             doubleStreamFunctions = permuteStreamFunctions(opFunctions);
         }

         return doubleStreamFunctions;
     }
 }
	/*
	* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package org.openjdk.tests.java.util.stream;

	import java.util.Arrays;
	import java.util.Comparator;
	import java.util.List;
	import java.util.Spliterator;
	import java.util.function.Consumer;
	import java.util.function.DoubleConsumer;
	import java.util.function.Function;
	import java.util.function.IntConsumer;
	import java.util.function.LongConsumer;
	import java.util.function.UnaryOperator;
	import java.util.stream.DoubleStream;
	import java.util.stream.DoubleStreamTestDataProvider;
	import java.util.stream.IntStream;
	import java.util.stream.IntStreamTestDataProvider;
	import java.util.stream.LambdaTestHelpers;
	import java.util.stream.LongStream;
	import java.util.stream.LongStreamTestDataProvider;
	import java.util.stream.OpTestCase;
	import java.util.stream.SpliteratorTestHelper;
	import java.util.stream.Stream;
	import java.util.stream.StreamSupport;
	import java.util.stream.StreamTestDataProvider;
	import java.util.stream.TestData;

	import org.testng.Assert;
	import org.testng.annotations.Test;

	import static java.util.stream.LambdaTestHelpers.countTo;
	import static java.util.stream.LambdaTestHelpers.dpEven;
	import static java.util.stream.LambdaTestHelpers.ipEven;
	import static java.util.stream.LambdaTestHelpers.irDoubler;
	import static java.util.stream.LambdaTestHelpers.lpEven;
	import static java.util.stream.LambdaTestHelpers.mDoubler;
	import static java.util.stream.LambdaTestHelpers.pEven;
	import static java.util.stream.LambdaTestHelpers.permuteStreamFunctions;

	@Test
	public class StreamSpliteratorTest extends OpTestCase {

	private static class ProxyNoExactSizeSpliterator<T> implements Spliterator<T> {
	final Spliterator<T> sp;
	final boolean proxyEstimateSize;
	int splits = 0;
	int prefixSplits = 0;

	long sizeOnTraversal = -1;

	ProxyNoExactSizeSpliterator(Spliterator<T> sp, boolean proxyEstimateSize) {
	this.sp = sp;
	this.proxyEstimateSize = proxyEstimateSize;
	}

	@Override
	public Spliterator<T> trySplit() {
	splits++;
	Spliterator<T> prefix = sp.trySplit();
	if (prefix != null)
	prefixSplits++;
	return prefix;
	}

	@Override
	public boolean tryAdvance(Consumer<? super T> consumer) {
	if (sizeOnTraversal == -1)
	sizeOnTraversal = sp.getExactSizeIfKnown();
	return sp.tryAdvance(consumer);
	}

	@Override
	public void forEachRemaining(Consumer<? super T> consumer) {
	sizeOnTraversal = sp.getExactSizeIfKnown();
	sp.forEachRemaining(consumer);
	}

	@Override
	public long estimateSize() {
	return proxyEstimateSize ? sp.estimateSize() : Long.MAX_VALUE;
	}

	@Override
	public Comparator<? super T> getComparator() {
	return sp.getComparator();
	}

	@Override
	public int characteristics() {
	if (proxyEstimateSize)
	return sp.characteristics();
	else
	return sp.characteristics() & ~(Spliterator.SUBSIZED \| Spliterator.SIZED);
	}

	private static class OfInt extends ProxyNoExactSizeSpliterator<Integer> implements Spliterator.OfInt {
	final Spliterator.OfInt psp;

	private OfInt(Spliterator.OfInt sp, boolean proxyEstimateSize) {
	super(sp, proxyEstimateSize);
	this.psp = sp;
	}

	@Override
	public Spliterator.OfInt trySplit() {
	splits++;
	Spliterator.OfInt prefix = psp.trySplit();
	if (prefix != null)
	prefixSplits++;
	return prefix;
	}

	@Override
	public boolean tryAdvance(Consumer<? super Integer> consumer) {
	return Spliterator.OfInt.super.tryAdvance(consumer);
	}

	@Override
	public void forEachRemaining(Consumer<? super Integer> consumer) {
	Spliterator.OfInt.super.forEachRemaining(consumer);
	}

	@Override
	public boolean tryAdvance(IntConsumer consumer) {
	if (sizeOnTraversal == -1)
	sizeOnTraversal = sp.getExactSizeIfKnown();
	return psp.tryAdvance(consumer);
	}

	@Override
	public void forEachRemaining(IntConsumer consumer) {
	sizeOnTraversal = sp.getExactSizeIfKnown();
	psp.forEachRemaining(consumer);
	}
	}

	private static class OfLong extends ProxyNoExactSizeSpliterator<Long> implements Spliterator.OfLong {
	final Spliterator.OfLong psp;

	private OfLong(Spliterator.OfLong sp, boolean proxyEstimateSize) {
	super(sp, proxyEstimateSize);
	this.psp = sp;
	}

	@Override
	public Spliterator.OfLong trySplit() {
	splits++;
	Spliterator.OfLong prefix = psp.trySplit();
	if (prefix != null)
	prefixSplits++;
	return prefix;
	}

	@Override
	public boolean tryAdvance(Consumer<? super Long> consumer) {
	return Spliterator.OfLong.super.tryAdvance(consumer);
	}

	@Override
	public void forEachRemaining(Consumer<? super Long> consumer) {
	Spliterator.OfLong.super.forEachRemaining(consumer);
	}

	@Override
	public boolean tryAdvance(LongConsumer consumer) {
	if (sizeOnTraversal == -1)
	sizeOnTraversal = sp.getExactSizeIfKnown();
	return psp.tryAdvance(consumer);
	}

	@Override
	public void forEachRemaining(LongConsumer consumer) {
	sizeOnTraversal = sp.getExactSizeIfKnown();
	psp.forEachRemaining(consumer);
	}
	}

	private static class OfDouble extends ProxyNoExactSizeSpliterator<Double>
	implements Spliterator.OfDouble {
	final Spliterator.OfDouble psp;

	private OfDouble(Spliterator.OfDouble sp, boolean proxyEstimateSize) {
	super(sp, proxyEstimateSize);
	this.psp = sp;
	}

	@Override
	public Spliterator.OfDouble trySplit() {
	splits++;
	Spliterator.OfDouble prefix = psp.trySplit();
	if (prefix != null)
	prefixSplits++;
	return prefix;
	}

	@Override
	public boolean tryAdvance(Consumer<? super Double> consumer) {
	return Spliterator.OfDouble.super.tryAdvance(consumer);
	}

	@Override
	public void forEachRemaining(Consumer<? super Double> consumer) {
	Spliterator.OfDouble.super.forEachRemaining(consumer);
	}

	@Override
	public boolean tryAdvance(DoubleConsumer consumer) {
	if (sizeOnTraversal == -1)
	sizeOnTraversal = sp.getExactSizeIfKnown();
	return psp.tryAdvance(consumer);
	}

	@Override
	public void forEachRemaining(DoubleConsumer consumer) {
	sizeOnTraversal = sp.getExactSizeIfKnown();
	psp.forEachRemaining(consumer);
	}
	}
	}

	public void testSplitting() {
	// Size is assumed to be larger than the target size for no splitting
	// @@@ Need way to obtain the target size
	List<Integer> l = countTo(1000);

	List<Consumer<Stream<Integer>>> terminalOps = Arrays.asList(
	s -> s.toArray(),
	s -> s.forEach(e -> { }),
	s -> s.reduce(Integer::sum)
	);

	List<UnaryOperator<Stream<Integer>>> intermediateOps = Arrays.asList(
	s -> s.parallel(),
	// The following ensures the wrapping spliterator is tested
	s -> s.map(LambdaTestHelpers.identity()).parallel()
	);

	for (int i = 0; i < terminalOps.size(); i++) {
	setContext("termOpIndex", i);
	Consumer<Stream<Integer>> terminalOp = terminalOps.get(i);
	for (int j = 0; j < intermediateOps.size(); j++) {
	setContext("intOpIndex", j);
	UnaryOperator<Stream<Integer>> intermediateOp = intermediateOps.get(j);
	for (boolean proxyEstimateSize : new boolean[] {false, true}) {
	setContext("proxyEstimateSize", proxyEstimateSize);
	Spliterator<Integer> sp = intermediateOp.apply(l.stream()).spliterator();
	ProxyNoExactSizeSpliterator<Integer> psp = new ProxyNoExactSizeSpliterator<>(sp, proxyEstimateSize);
	Stream<Integer> s = StreamSupport.stream(psp, true);
	terminalOp.accept(s);
	Assert.assertTrue(psp.splits > 0,
	String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
	proxyEstimateSize));
	Assert.assertTrue(psp.prefixSplits > 0,
	String.format("Number of non-null prefix splits should be greater that zero when proxyEstimateSize is %s",
	proxyEstimateSize));
	Assert.assertTrue(psp.sizeOnTraversal < l.size(),
	String.format("Size on traversal of last split should be less than the size of the list, %d, when proxyEstimateSize is %s",
	l.size(), proxyEstimateSize));
	}
	}
	}
	}

	@Test(dataProvider = "StreamTestData<Integer>",
	dataProviderClass = StreamTestDataProvider.class,
	groups = { "serialization-hostile" })
	public void testStreamSpliterators(String name, TestData.OfRef<Integer> data) {
	for (Function<Stream<Integer>, Stream<Integer>> f : streamFunctions()) {
	withData(data).
	stream((Stream<Integer> in) -> {
	Stream<Integer> out = f.apply(in);
	return StreamSupport.stream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
	}).
	exercise();

	withData(data).
	stream((Stream<Integer> in) -> {
	Stream<Integer> out = f.apply(in);
	return StreamSupport.stream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
	}).
	exercise();
	}
	}

	@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
	public void testSpliterators(String name, TestData.OfRef<Integer> data) {
	for (Function<Stream<Integer>, Stream<Integer>> f : streamFunctions()) {
	SpliteratorTestHelper.testSpliterator(() -> f.apply(data.stream()).spliterator());
	}
	}

	@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
	public void testParSpliterators(String name, TestData.OfRef<Integer> data) {
	for (Function<Stream<Integer>, Stream<Integer>> f : streamFunctions()) {
	SpliteratorTestHelper.testSpliterator(() -> f.apply(data.parallelStream()).spliterator());
	}
	}

	private List<Function<Stream<Integer>, Stream<Integer>>> streamFunctions;

	List<Function<Stream<Integer>, Stream<Integer>>> streamFunctions() {
	if (streamFunctions == null) {
	List<Function<Stream<Integer>, Stream<Integer>>> opFunctions = Arrays.asList(
	s -> s.filter(pEven),
	s -> s.map(mDoubler),
	// @@@ Add distinct once asserting results with or without order
	// is correctly supported
	// s -> s.distinct(),
	s -> s.sorted());

	streamFunctions = permuteStreamFunctions(opFunctions);
	}

	return streamFunctions;
	}

	//

	public void testIntSplitting() {
	List<Consumer<IntStream>> terminalOps = Arrays.asList(
	s -> s.toArray(),
	s -> s.forEach(e -> {}),
	s -> s.reduce(Integer::sum)
	);

	List<UnaryOperator<IntStream>> intermediateOps = Arrays.asList(
	s -> s.parallel(),
	// The following ensures the wrapping spliterator is tested
	s -> s.map(i -> i).parallel()
	);

	for (int i = 0; i < terminalOps.size(); i++) {
	setContext("termOpIndex", i);
	Consumer<IntStream> terminalOp = terminalOps.get(i);
	for (int j = 0; j < intermediateOps.size(); j++) {
	setContext("intOpIndex", j);
	UnaryOperator<IntStream> intermediateOp = intermediateOps.get(j);
	for (boolean proxyEstimateSize : new boolean[] {false, true}) {
	setContext("proxyEstimateSize", proxyEstimateSize);
	// Size is assumed to be larger than the target size for no splitting
	// @@@ Need way to obtain the target size
	Spliterator.OfInt sp = intermediateOp.apply(IntStream.range(0, 1000)).spliterator();
	ProxyNoExactSizeSpliterator.OfInt psp = new ProxyNoExactSizeSpliterator.OfInt(sp, proxyEstimateSize);
	IntStream s = StreamSupport.intStream(psp, true);
	terminalOp.accept(s);
	Assert.assertTrue(psp.splits > 0,
	String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
	proxyEstimateSize));
	Assert.assertTrue(psp.prefixSplits > 0,
	String.format("Number of non-null prefix splits should be greater that zero when proxyEstimateSize is %s",
	proxyEstimateSize));
	Assert.assertTrue(psp.sizeOnTraversal < 1000,
	String.format("Size on traversal of last split should be less than the size of the list, %d, when proxyEstimateSize is %s",
	1000, proxyEstimateSize));
	}
	}
	}
	}

	@Test(dataProvider = "IntStreamTestData",
	dataProviderClass = IntStreamTestDataProvider.class,
	groups = { "serialization-hostile" })
	public void testIntStreamSpliterators(String name, TestData.OfInt data) {
	for (Function<IntStream, IntStream> f : intStreamFunctions()) {
	withData(data).
	stream(in -> {
	IntStream out = f.apply(in);
	return StreamSupport.intStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
	}).
	exercise();

	withData(data).
	stream((in) -> {
	IntStream out = f.apply(in);
	return StreamSupport.intStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
	}).
	exercise();
	}
	}

	@Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
	public void testIntSpliterators(String name, TestData.OfInt data) {
	for (Function<IntStream, IntStream> f : intStreamFunctions()) {
	SpliteratorTestHelper.testIntSpliterator(() -> f.apply(data.stream()).spliterator());
	}
	}

	@Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
	public void testIntParSpliterators(String name, TestData.OfInt data) {
	for (Function<IntStream, IntStream> f : intStreamFunctions()) {
	SpliteratorTestHelper.testIntSpliterator(() -> f.apply(data.parallelStream()).spliterator());
	}
	}

	private List<Function<IntStream, IntStream>> intStreamFunctions;

	List<Function<IntStream, IntStream>> intStreamFunctions() {
	if (intStreamFunctions == null) {
	List<Function<IntStream, IntStream>> opFunctions = Arrays.asList(
	s -> s.filter(ipEven),
	s -> s.map(irDoubler),
	s -> s.sorted());

	intStreamFunctions = permuteStreamFunctions(opFunctions);
	}

	return intStreamFunctions;
	}

	//

	public void testLongSplitting() {
	List<Consumer<LongStream>> terminalOps = Arrays.asList(
	s -> s.toArray(),
	s -> s.forEach(e -> {}),
	s -> s.reduce(Long::sum)
	);

	List<UnaryOperator<LongStream>> intermediateOps = Arrays.asList(
	s -> s.parallel(),
	// The following ensures the wrapping spliterator is tested
	s -> s.map(i -> i).parallel()
	);

	for (int i = 0; i < terminalOps.size(); i++) {
	Consumer<LongStream> terminalOp = terminalOps.get(i);
	setContext("termOpIndex", i);
	for (int j = 0; j < intermediateOps.size(); j++) {
	setContext("intOpIndex", j);
	UnaryOperator<LongStream> intermediateOp = intermediateOps.get(j);
	for (boolean proxyEstimateSize : new boolean[] {false, true}) {
	setContext("proxyEstimateSize", proxyEstimateSize);
	// Size is assumed to be larger than the target size for no splitting
	// @@@ Need way to obtain the target size
	Spliterator.OfLong sp = intermediateOp.apply(LongStream.range(0, 1000)).spliterator();
	ProxyNoExactSizeSpliterator.OfLong psp = new ProxyNoExactSizeSpliterator.OfLong(sp, proxyEstimateSize);
	LongStream s = StreamSupport.longStream(psp, true);
	terminalOp.accept(s);
	Assert.assertTrue(psp.splits > 0,
	String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
	proxyEstimateSize));
	Assert.assertTrue(psp.prefixSplits > 0,
	String.format("Number of non-null prefix splits should be greater that zero when proxyEstimateSize is %s",
	proxyEstimateSize));
	Assert.assertTrue(psp.sizeOnTraversal < 1000,
	String.format("Size on traversal of last split should be less than the size of the list, %d, when proxyEstimateSize is %s",
	1000, proxyEstimateSize));
	}
	}
	}
	}

	@Test(dataProvider = "LongStreamTestData",
	dataProviderClass = LongStreamTestDataProvider.class,
	groups = { "serialization-hostile" })
	public void testLongStreamSpliterators(String name, TestData.OfLong data) {
	for (Function<LongStream, LongStream> f : longStreamFunctions()) {
	withData(data).
	stream(in -> {
	LongStream out = f.apply(in);
	return StreamSupport.longStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
	}).
	exercise();

	withData(data).
	stream((in) -> {
	LongStream out = f.apply(in);
	return StreamSupport.longStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
	}).
	exercise();
	}
	}

	@Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
	public void testLongSpliterators(String name, TestData.OfLong data) {
	for (Function<LongStream, LongStream> f : longStreamFunctions()) {
	SpliteratorTestHelper.testLongSpliterator(() -> f.apply(data.stream()).spliterator());
	}
	}

	@Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
	public void testLongParSpliterators(String name, TestData.OfLong data) {
	for (Function<LongStream, LongStream> f : longStreamFunctions()) {
	SpliteratorTestHelper.testLongSpliterator(() -> f.apply(data.parallelStream()).spliterator());
	}
	}

	private List<Function<LongStream, LongStream>> longStreamFunctions;

	List<Function<LongStream, LongStream>> longStreamFunctions() {
	if (longStreamFunctions == null) {
	List<Function<LongStream, LongStream>> opFunctions = Arrays.asList(
	s -> s.filter(lpEven),
	s -> s.map(x -> x * 2L),
	s -> s.sorted());

	longStreamFunctions = permuteStreamFunctions(opFunctions);
	}

	return longStreamFunctions;
	}

	//

	public void testDoubleSplitting() {
	List<Consumer<DoubleStream>> terminalOps = Arrays.asList(
	s -> s.toArray(),
	s -> s.forEach(e -> {}),
	s -> s.reduce(Double::sum)
	);

	List<UnaryOperator<DoubleStream>> intermediateOps = Arrays.asList(
	s -> s.parallel(),
	// The following ensures the wrapping spliterator is tested
	s -> s.map(i -> i).parallel()
	);

	for (int i = 0; i < terminalOps.size(); i++) {
	Consumer<DoubleStream> terminalOp = terminalOps.get(i);
	setContext("termOpIndex", i);
	for (int j = 0; j < intermediateOps.size(); j++) {
	UnaryOperator<DoubleStream> intermediateOp = intermediateOps.get(j);
	setContext("intOpIndex", j);
	for (boolean proxyEstimateSize : new boolean[] {false, true}) {
	setContext("proxyEstimateSize", proxyEstimateSize);
	// Size is assumed to be larger than the target size for no splitting
	// @@@ Need way to obtain the target size
	Spliterator.OfDouble sp = intermediateOp.apply(IntStream.range(0, 1000).asDoubleStream()).spliterator();
	ProxyNoExactSizeSpliterator.OfDouble psp = new ProxyNoExactSizeSpliterator.OfDouble(sp, proxyEstimateSize);
	DoubleStream s = StreamSupport.doubleStream(psp, true);
	terminalOp.accept(s);
	Assert.assertTrue(psp.splits > 0,
	String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
	proxyEstimateSize));
	Assert.assertTrue(psp.prefixSplits > 0,
	String.format("Number of non-null prefix splits should be greater that zero when proxyEstimateSize is %s",
	proxyEstimateSize));
	Assert.assertTrue(psp.sizeOnTraversal < 1000,
	String.format("Size on traversal of last split should be less than the size of the list, %d, when proxyEstimateSize is %s",
	1000, proxyEstimateSize));
	}
	}
	}
	}

	@Test(dataProvider = "DoubleStreamTestData",
	dataProviderClass = DoubleStreamTestDataProvider.class,
	groups = { "serialization-hostile" })
	public void testDoubleStreamSpliterators(String name, TestData.OfDouble data) {
	for (Function<DoubleStream, DoubleStream> f : doubleStreamFunctions()) {
	withData(data).
	stream(in -> {
	DoubleStream out = f.apply(in);
	return StreamSupport.doubleStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
	}).
	exercise();

	withData(data).
	stream((in) -> {
	DoubleStream out = f.apply(in);
	return StreamSupport.doubleStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
	}).
	exercise();
	}
	}

	@Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
	public void testDoubleSpliterators(String name, TestData.OfDouble data) {
	for (Function<DoubleStream, DoubleStream> f : doubleStreamFunctions()) {
	SpliteratorTestHelper.testDoubleSpliterator(() -> f.apply(data.stream()).spliterator());
	}
	}

	@Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
	public void testDoubleParSpliterators(String name, TestData.OfDouble data) {
	for (Function<DoubleStream, DoubleStream> f : doubleStreamFunctions()) {
	SpliteratorTestHelper.testDoubleSpliterator(() -> f.apply(data.parallelStream()).spliterator());
	}
	}

	private List<Function<DoubleStream, DoubleStream>> doubleStreamFunctions;

	List<Function<DoubleStream, DoubleStream>> doubleStreamFunctions() {
	if (doubleStreamFunctions == null) {
	List<Function<DoubleStream, DoubleStream>> opFunctions = Arrays.asList(
	s -> s.filter(dpEven),
	s -> s.map(x -> x * 2.0),
	s -> s.sorted());

	doubleStreamFunctions = permuteStreamFunctions(opFunctions);
	}

	return doubleStreamFunctions;
	}
	}