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());
