RFR 8017329 8b92-lambda regression: TreeSet("a", "b").stream().substream(1).parallel().iterator() is empty

[Paul Sandoz]

Hi,

Please review a fix for a regression with using Stream.substream for an ORDERED but not SUBSIZED spliterator that does not split.

This is based off:

  http://cr.openjdk.java.net/~psandoz/tl/JDK-8012987-slice/webrev/

which is blocked waiting for the Comparator API webrev to go into tl, which should be soon (waiting on CCC approval).

Paul.

# HG changeset patch
# User psandoz
# Date 1372324256 -7200
# Node ID 3459ac0d695ffdf2f5120e63a9a4bb79a0af40dc
# Parent  d4cd5e16ac8f279e05974cdb2f6281c5f24e484c
8017329: 8b92-lambda regression: TreeSet("a", "b").stream().substream(1).parallel().iterator() is empty
Reviewed-by:

diff -r d4cd5e16ac8f -r 3459ac0d695f src/share/classes/java/util/stream/SliceOps.java
--- a/src/share/classes/java/util/stream/SliceOps.java	Thu Jun 27 11:06:17 2013 +0200
+++ b/src/share/classes/java/util/stream/SliceOps.java	Thu Jun 27 11:10:56 2013 +0200
@@ -598,9 +598,9 @@
                 final Node.Builder<P_OUT> nb = op.makeNodeBuilder(sizeIfKnown, generator);
                 Sink<P_OUT> opSink = op.opWrapSink(helper.getStreamAndOpFlags(), nb);
                 helper.copyIntoWithCancel(helper.wrapSink(opSink), spliterator);
-                // It is necessary to truncate here since the result at the root
-                // can only be set once
-                return doTruncate(nb.build());
+                // There is no need to truncate since the op performs the
+                // skipping and limiting of elements
+                return nb.build();
             }
             else {
                 Node<P_OUT> node = helper.wrapAndCopyInto(helper.makeNodeBuilder(-1, generator),
diff -r d4cd5e16ac8f -r 3459ac0d695f test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java
--- a/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java	Thu Jun 27 11:06:17 2013 +0200
+++ b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java	Thu Jun 27 11:10:56 2013 +0200
@@ -26,13 +26,16 @@
 
 import java.util.*;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Consumer;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 import java.util.stream.DoubleStream;
 import java.util.stream.IntStream;
 import java.util.stream.LambdaTestHelpers;
 import java.util.stream.LongStream;
 import java.util.stream.OpTestCase;
 import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
 import java.util.stream.StreamTestDataProvider;
 import java.util.stream.TestData;
 
@@ -192,6 +195,53 @@
         }
     }
 
+    public void testSkipLimitOpsWithNonSplittingSpliterator() {
+        class NonSplittingNotSubsizedOrderedSpliterator<T> implements Spliterator<T> {
+            Spliterator<T> s;
+
+            NonSplittingNotSubsizedOrderedSpliterator(Spliterator<T> s) {
+                assert s.hasCharacteristics(Spliterator.ORDERED);
+                this.s = s;
+            }
+
+            @Override
+            public boolean tryAdvance(Consumer<? super T> action) {
+                return s.tryAdvance(action);
+            }
+
+            @Override
+            public void forEachRemaining(Consumer<? super T> action) {
+                s.forEachRemaining(action);
+            }
+
+            @Override
+            public Spliterator<T> trySplit() {
+                return null;
+            }
+
+            @Override
+            public long estimateSize() {
+                return s.estimateSize();
+            }
+
+            @Override
+            public int characteristics() {
+                return s.characteristics() & ~(Spliterator.SUBSIZED);
+            }
+
+            @Override
+            public Comparator<? super T> getComparator() {
+                return s.getComparator();
+            }
+        }
+        List<Integer> list = IntStream.range(0, 100).boxed().collect(Collectors.toList());
+        TestData.OfRef<Integer> data = TestData.Factory.ofSupplier(
+                "Non splitting, not SUBSIZED, ORDERED, stream",
+                () -> StreamSupport.stream(new NonSplittingNotSubsizedOrderedSpliterator<>(list.spliterator())));
+
+        testSkipLimitOps("testSkipLimitOpsWithNonSplittingSpliterator", data);
+    }
+
     @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
     public void testLimitOps(String name, TestData.OfRef<Integer> data) {
         List<Integer> limits = sizes(data.size());