diff --git a/jdk/src/java.base/share/classes/java/nio/file/FileChannelLinesSpliterator.java b/jdk/src/java.base/share/classes/java/nio/file/FileChannelLinesSpliterator.java
new file mode 100644
index 00000000000..dab526e8d2b
--- /dev/null
+++ b/jdk/src/java.base/share/classes/java/nio/file/FileChannelLinesSpliterator.java
@@ -0,0 +1,267 @@
+/*
+ * Copyright (c) 2015, 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 java.nio.file;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.Channels;
+import java.nio.channels.FileChannel;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+
+/**
+ * A file-based lines spliterator, leveraging a shared mapped byte buffer and
+ * associated file channel, covering lines of a file for character encodings
+ * where line feed characters can be easily identified from character encoded
+ * bytes.
+ *
+ *
+ * When the root spliterator is first split a mapped byte buffer will be created
+ * over the file for it's size that was observed when the stream was created.
+ * Thus a mapped byte buffer is only required for parallel stream execution.
+ * Sub-spliterators will share that mapped byte buffer. Splitting will use the
+ * mapped byte buffer to find the closest line feed characters(s) to the left or
+ * right of the mid-point of covered range of bytes of the file. If a line feed
+ * is found then the spliterator is split with returned spliterator containing
+ * the identified line feed characters(s) at the end of it's covered range of
+ * bytes.
+ *
+ *
+ * Traversing will create a buffered reader, derived from the file channel, for
+ * the range of bytes of the file. The lines are then read from that buffered
+ * reader. Once traversing commences no further splitting can be performed and
+ * the reference to the mapped byte buffer will be set to null.
+ */
+final class FileChannelLinesSpliterator implements Spliterator {
+
+ static final Set SUPPORTED_CHARSET_NAMES;
+ static {
+ SUPPORTED_CHARSET_NAMES = new HashSet<>();
+ SUPPORTED_CHARSET_NAMES.add(StandardCharsets.UTF_8.name());
+ SUPPORTED_CHARSET_NAMES.add(StandardCharsets.ISO_8859_1.name());
+ SUPPORTED_CHARSET_NAMES.add(StandardCharsets.US_ASCII.name());
+ }
+
+ private final FileChannel fc;
+ private final Charset cs;
+ private int index;
+ private final int fence;
+
+ // Null before first split, non-null when splitting, null when traversing
+ private ByteBuffer buffer;
+ // Non-null when traversing
+ private BufferedReader reader;
+
+ FileChannelLinesSpliterator(FileChannel fc, Charset cs, int index, int fence) {
+ this.fc = fc;
+ this.cs = cs;
+ this.index = index;
+ this.fence = fence;
+ }
+
+ private FileChannelLinesSpliterator(FileChannel fc, Charset cs, int index, int fence, ByteBuffer buffer) {
+ this.fc = fc;
+ this.buffer = buffer;
+ this.cs = cs;
+ this.index = index;
+ this.fence = fence;
+ }
+
+ @Override
+ public boolean tryAdvance(Consumer action) {
+ String line = readLine();
+ if (line != null) {
+ action.accept(line);
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ @Override
+ public void forEachRemaining(Consumer action) {
+ String line;
+ while ((line = readLine()) != null) {
+ action.accept(line);
+ }
+ }
+
+ private BufferedReader getBufferedReader() {
+ /**
+ * A readable byte channel that reads bytes from an underlying
+ * file channel over a specified range.
+ */
+ ReadableByteChannel rrbc = new ReadableByteChannel() {
+ @Override
+ public int read(ByteBuffer dst) throws IOException {
+ int bytesToRead = fence - index;
+ if (bytesToRead == 0)
+ return -1;
+
+ int bytesRead;
+ if (bytesToRead < dst.remaining()) {
+ // The number of bytes to read is less than remaining
+ // bytes in the buffer
+ // Snapshot the limit, reduce it, read, then restore
+ int oldLimit = dst.limit();
+ dst.limit(dst.position() + bytesToRead);
+ bytesRead = fc.read(dst, index);
+ dst.limit(oldLimit);
+ } else {
+ bytesRead = fc.read(dst, index);
+ }
+ if (bytesRead == -1) {
+ index = fence;
+ return bytesRead;
+ }
+
+ index += bytesRead;
+ return bytesRead;
+ }
+
+ @Override
+ public boolean isOpen() {
+ return fc.isOpen();
+ }
+
+ @Override
+ public void close() throws IOException {
+ fc.close();
+ }
+ };
+ return new BufferedReader(Channels.newReader(rrbc, cs.newDecoder(), -1));
+ }
+
+ private String readLine() {
+ if (reader == null) {
+ reader = getBufferedReader();
+ buffer = null;
+ }
+
+ try {
+ return reader.readLine();
+ } catch (IOException e) {
+ throw new UncheckedIOException(e);
+ }
+ }
+
+ private ByteBuffer getMappedByteBuffer() {
+ // TODO can the mapped byte buffer be explicitly unmapped?
+ // It's possible, via a shared-secret mechanism, when either
+ // 1) the spliterator starts traversing, although traversal can
+ // happen concurrently for mulitple spliterators, so care is
+ // needed in this case; or
+ // 2) when the stream is closed using some shared holder to pass
+ // the mapped byte buffer when it is created.
+ try {
+ return fc.map(FileChannel.MapMode.READ_ONLY, 0, fence);
+ } catch (IOException e) {
+ throw new UncheckedIOException(e);
+ }
+ }
+
+ @Override
+ public Spliterator trySplit() {
+ // Cannot split after partial traverse
+ if (reader != null)
+ return null;
+
+ ByteBuffer b;
+ if ((b = buffer) == null) {
+ b = buffer = getMappedByteBuffer();
+ }
+
+ final int hi = fence, lo = index;
+
+ // Check if line separator hits the mid point
+ int mid = (lo + hi) >>> 1;
+ int c = b.get(mid);
+ if (c == '\n') {
+ mid++;
+ } else if (c == '\r') {
+ // Check if a line separator of "\r\n"
+ if (++mid < hi && b.get(mid) == '\n') {
+ mid++;
+ }
+ } else {
+ // TODO give up after a certain distance from the mid point?
+ // Scan to the left and right of the mid point
+ int midL = mid - 1;
+ int midR = mid + 1;
+ mid = 0;
+ while (midL > lo && midR < hi) {
+ // Sample to the left
+ c = b.get(midL--);
+ if (c == '\n' || c == '\r') {
+ // If c is "\r" then no need to check for "\r\n"
+ // since the subsequent value was previously checked
+ mid = midL + 2;
+ break;
+ }
+
+ // Sample to the right
+ c = b.get(midR++);
+ if (c == '\n' || c == '\r') {
+ mid = midR;
+ // Check if line-separator is "\r\n"
+ if (c == '\r' && mid < hi && b.get(mid) == '\n') {
+ mid++;
+ }
+ break;
+ }
+ }
+ }
+
+ // The left spliterator will have the line-separator at the end
+ return (mid > lo && mid < hi)
+ ? new FileChannelLinesSpliterator(fc, cs, lo, index = mid, b)
+ : null;
+ }
+
+ @Override
+ public long estimateSize() {
+ // Use the number of bytes as an estimate.
+ // We could divide by a constant that is the average number of
+ // characters per-line, but that constant will be factored out.
+ return fence - index;
+ }
+
+ @Override
+ public long getExactSizeIfKnown() {
+ return -1;
+ }
+
+ @Override
+ public int characteristics() {
+ return Spliterator.ORDERED | Spliterator.NONNULL;
+ }
+}
diff --git a/jdk/src/java.base/share/classes/java/nio/file/Files.java b/jdk/src/java.base/share/classes/java/nio/file/Files.java
index 7afd40bf12a..079361eb088 100644
--- a/jdk/src/java.base/share/classes/java/nio/file/Files.java
+++ b/jdk/src/java.base/share/classes/java/nio/file/Files.java
@@ -38,6 +38,7 @@ import java.io.Reader;
import java.io.UncheckedIOException;
import java.io.Writer;
import java.nio.channels.Channels;
+import java.nio.channels.FileChannel;
import java.nio.channels.SeekableByteChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
@@ -3735,6 +3736,7 @@ public final class Files {
}
}
+
/**
* Read all lines from a file as a {@code Stream}. Unlike {@link
* #readAllLines(Path, Charset) readAllLines}, this method does not read
@@ -3748,6 +3750,10 @@ public final class Files {
* The returned stream contains a reference to an open file. The file
* is closed by closing the stream.
*
+ *
The file contents should not be modified during the execution of the
+ * terminal stream operation. Otherwise, the result of the terminal stream
+ * operation is undefined.
+ *
*
After this method returns, then any subsequent I/O exception that
* occurs while reading from the file or when a malformed or unmappable byte
* sequence is read, is wrapped in an {@link UncheckedIOException} that will
@@ -3761,6 +3767,30 @@ public final class Files {
* control structure to ensure that the stream's open file is closed promptly
* after the stream's operations have completed.
*
+ * @implNote
+ * This implementation supports good parallel stream performance for the
+ * standard charsets {@link StandardCharsets#UTF_8 UTF-8},
+ * {@link StandardCharsets#US_ASCII US-ASCII} and
+ * {@link StandardCharsets#ISO_8859_1 ISO-8859-1}. Such
+ * line-optimal charsets have the property that the encoded bytes
+ * of a line feed ('\n') or a carriage return ('\r') are efficiently
+ * identifiable from other encoded characters when randomly accessing the
+ * bytes of the file.
+ *
+ *
For non-line-optimal charsets the stream source's
+ * spliterator has poor splitting properties, similar to that of a
+ * spliterator associated with an iterator or that associated with a stream
+ * returned from {@link BufferedReader#lines()}. Poor splitting properties
+ * can result in poor parallel stream performance.
+ *
+ *
For line-optimal charsets the stream source's spliterator
+ * has good splitting properties, assuming the file contains a regular
+ * sequence of lines. Good splitting properties can result in good parallel
+ * stream performance. The spliterator for a line-optimal charset
+ * takes advantage of the charset properties (a line feed or a carriage
+ * return being efficient identifiable) such that when splitting it can
+ * approximately divide the number of covered lines in half.
+ *
* @param path
* the path to the file
* @param cs
@@ -3781,7 +3811,50 @@ public final class Files {
* @since 1.8
*/
public static Stream lines(Path path, Charset cs) throws IOException {
- BufferedReader br = Files.newBufferedReader(path, cs);
+ // Use the good splitting spliterator if:
+ // 1) the path is associated with the default file system;
+ // 2) the character set is supported; and
+ // 3) the file size is such that all bytes can be indexed by int values
+ // (this limitation is imposed by ByteBuffer)
+ if (path.getFileSystem() == FileSystems.getDefault() &&
+ FileChannelLinesSpliterator.SUPPORTED_CHARSET_NAMES.contains(cs.name())) {
+ FileChannel fc = FileChannel.open(path, StandardOpenOption.READ);
+
+ Stream fcls = createFileChannelLinesStream(fc, cs);
+ if (fcls != null) {
+ return fcls;
+ }
+ fc.close();
+ }
+
+ return createBufferedReaderLinesStream(Files.newBufferedReader(path, cs));
+ }
+
+ private static Stream createFileChannelLinesStream(FileChannel fc, Charset cs) throws IOException {
+ try {
+ // Obtaining the size from the FileChannel is much faster
+ // than obtaining using path.toFile().length()
+ long length = fc.size();
+ if (length <= Integer.MAX_VALUE) {
+ Spliterator s = new FileChannelLinesSpliterator(fc, cs, 0, (int) length);
+ return StreamSupport.stream(s, false)
+ .onClose(Files.asUncheckedRunnable(fc));
+ }
+ } catch (Error|RuntimeException|IOException e) {
+ try {
+ fc.close();
+ } catch (IOException ex) {
+ try {
+ e.addSuppressed(ex);
+ } catch (Throwable ignore) {
+ }
+ }
+ throw e;
+ }
+ return null;
+ }
+
+ private static Stream createBufferedReaderLinesStream(BufferedReader br) {
try {
return br.lines().onClose(asUncheckedRunnable(br));
} catch (Error|RuntimeException e) {
@@ -3790,7 +3863,8 @@ public final class Files {
} catch (IOException ex) {
try {
e.addSuppressed(ex);
- } catch (Throwable ignore) {}
+ } catch (Throwable ignore) {
+ }
}
throw e;
}
@@ -3804,6 +3878,10 @@ public final class Files {
* The returned stream contains a reference to an open file. The file
* is closed by closing the stream.
*
+ *
The file contents should not be modified during the execution of the
+ * terminal stream operation. Otherwise, the result of the terminal stream
+ * operation is undefined.
+ *
*
This method works as if invoking it were equivalent to evaluating the
* expression:
*
{@code
diff --git a/jdk/test/java/nio/file/Files/StreamLinesTest.java b/jdk/test/java/nio/file/Files/StreamLinesTest.java
new file mode 100644
index 00000000000..f0f218138ba
--- /dev/null
+++ b/jdk/test/java/nio/file/Files/StreamLinesTest.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2015, 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.
+ */
+
+/* @test
+ * @bug 8072773
+ * @library /lib/testlibrary/ ../../../util/stream/bootlib
+ * @build java.util.stream.OpTestCase
+ * @build jdk.testlibrary.RandomFactory
+ * @run testng/othervm StreamLinesTest
+ * @summary Tests streams returned from Files.lines, primarily focused on
+ * testing the file-channel-based stream stream with supported
+ * character sets
+ * @key randomness
+ */
+
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Random;
+import java.util.function.IntFunction;
+import java.util.function.Supplier;
+import java.util.stream.OpTestCase;
+import java.util.stream.Stream;
+import java.util.stream.TestData;
+import jdk.testlibrary.RandomFactory;
+
+public class StreamLinesTest extends OpTestCase {
+
+ enum LineSeparator {
+ NONE(""),
+ N("\n"),
+ R("\r"),
+ RN("\r\n");
+
+ public final String value;
+
+ LineSeparator(String value) {
+ this.value = value;
+ }
+
+ public String toString() {
+ return name();
+ }
+ }
+
+ static Path generateTempFileWithLines(IntFunction lineGenerator,
+ IntFunction lineSeparatorGenerator,
+ int lines, Charset cs, boolean endLineSep) throws IOException {
+ Path p = Files.createTempFile("lines", null);
+ BufferedWriter bw = Files.newBufferedWriter(p, cs);
+
+ for (int i = 0; i < lines - 1; i++) {
+ bw.write(lineGenerator.apply(i));
+ bw.write(lineSeparatorGenerator.apply(i).value);
+ }
+ if (lines > 0) {
+ bw.write(lineGenerator.apply(lines - 1));
+ if (endLineSep)
+ bw.write(lineSeparatorGenerator.apply(lines - 1).value);
+ }
+
+ bw.flush();
+ bw.close();
+ p.toFile().deleteOnExit();
+
+ return p;
+ }
+
+ static void writeLineSeparator(Path p,
+ IntFunction lineSeparatorGenerator,
+ int lines, Charset cs) throws IOException {
+ BufferedWriter bw = Files.newBufferedWriter(p, cs, StandardOpenOption.APPEND);
+ bw.write(lineSeparatorGenerator.apply(lines - 1).value);
+ bw.flush();
+ bw.close();
+ }
+
+ static List readAllLines(Path path, Charset cs) throws IOException {
+ try (BufferedReader reader = Files.newBufferedReader(path, cs)) {
+ List result = new ArrayList<>();
+ for (; ; ) {
+ String line = reader.readLine();
+ if (line == null)
+ break;
+ result.add(line);
+ }
+ return result;
+ }
+ }
+
+ static Object[] of(String description, IntFunction lineGenerator,
+ IntFunction separatorGenerator, int n, Charset cs) {
+ return new Object[]{description, lineGenerator, separatorGenerator, n, cs};
+ }
+
+ private static final Random random = RandomFactory.getRandom();
+
+ @DataProvider
+ public static Object[][] lines() {
+ List l = new ArrayList<>();
+
+ // Include the three supported optimal-line charsets and one
+ // which does not
+ List charsets = Arrays.asList(StandardCharsets.UTF_8,
+ StandardCharsets.US_ASCII,
+ StandardCharsets.ISO_8859_1,
+ StandardCharsets.UTF_16);
+ String[] lines = {"", "A", "AB", "ABC", "ABCD"};
+ int[] linesSizes = {1, 2, 3, 4, 16, 256, 1024};
+
+ for (Charset charset : charsets) {
+ for (String line : lines) {
+ for (int linesSize : linesSizes) {
+ for (LineSeparator ls : EnumSet.complementOf(EnumSet.of(LineSeparator.NONE))) {
+ String description = String.format("%d lines of \"%s\" with separator %s", linesSize, line, ls);
+ l.add(of(description,
+ i -> line,
+ i -> ls,
+ linesSize, charset));
+ }
+ }
+ }
+ }
+
+ for (Charset charset : charsets) {
+ l.add(of("A maximum of 1024 random lines and separators",
+ i -> lines[1 + random.nextInt(lines.length - 1)],
+ i -> LineSeparator.values()[random.nextInt(LineSeparator.values().length)],
+ 1024, charset));
+ }
+
+ for (Charset charset : charsets) {
+ l.add(of("One large line with no separators",
+ i -> "ABCD",
+ i -> LineSeparator.NONE,
+ 1024, charset));
+ }
+
+ return l.toArray(new Object[][]{});
+ }
+
+ @Test(dataProvider = "lines")
+ public void test(String description,
+ IntFunction lineGenerator, IntFunction separatorGenerator,
+ int lines, Charset cs) throws IOException {
+ Path p = generateTempFileWithLines(lineGenerator, separatorGenerator, lines, cs, false);
+
+ Supplier> ss = () -> {
+ try {
+ return Files.lines(p, cs);
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ };
+
+ // Test without a separator at the end
+ List expected = readAllLines(p, cs);
+ withData(TestData.Factory.ofSupplier("Lines with no separator at end", ss))
+ .stream(s -> s)
+ .expectedResult(expected)
+ .exercise();
+
+ // Test with a separator at the end
+ writeLineSeparator(p, separatorGenerator, lines, cs);
+ expected = readAllLines(p, cs);
+ withData(TestData.Factory.ofSupplier("Lines with separator at end", ss))
+ .stream(s -> s)
+ .expectedResult(expected)
+ .exercise();
+ }
+
+}
diff --git a/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java b/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java
index 1811a4ba5cd..f1ff3382468 100644
--- a/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java
+++ b/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java
@@ -43,22 +43,21 @@ import java.util.function.Function;
@SuppressWarnings({"rawtypes", "unchecked"})
public enum DoubleStreamTestScenario implements OpTestCase.BaseStreamTestScenario {
- STREAM_FOR_EACH_WITH_CLOSE(false) {
+ STREAM_FOR_EACH(false) {
>
- void _run(TestData data, DoubleConsumer b, Function m) {
- DoubleStream s = m.apply(data.stream());
+ void run(TestData data, S_IN source, DoubleConsumer b, Function m) {
+ DoubleStream s = m.apply(source);
if (s.isParallel()) {
s = s.sequential();
}
s.forEach(b);
- s.close();
}
},
STREAM_TO_ARRAY(false) {
>
- void _run(TestData data, DoubleConsumer b, Function m) {
- for (double t : m.apply(data.stream()).toArray()) {
+ void run(TestData data, S_IN source, DoubleConsumer b, Function m) {
+ for (double t : m.apply(source).toArray()) {
b.accept(t);
}
}
@@ -66,8 +65,8 @@ public enum DoubleStreamTestScenario implements OpTestCase.BaseStreamTestScenari
STREAM_ITERATOR(false) {
>
- void _run(TestData data, DoubleConsumer b, Function m) {
- for (PrimitiveIterator.OfDouble seqIter = m.apply(data.stream()).iterator(); seqIter.hasNext(); )
+ void run(TestData data, S_IN source, DoubleConsumer b, Function m) {
+ for (PrimitiveIterator.OfDouble seqIter = m.apply(source).iterator(); seqIter.hasNext(); )
b.accept(seqIter.nextDouble());
}
},
@@ -75,8 +74,8 @@ public enum DoubleStreamTestScenario implements OpTestCase.BaseStreamTestScenari
// Wrap as stream, and spliterate then iterate in pull mode
STREAM_SPLITERATOR(false) {
>
- void _run(TestData data, DoubleConsumer b, Function m) {
- for (Spliterator.OfDouble spl = m.apply(data.stream()).spliterator(); spl.tryAdvance(b); ) {
+ void run(TestData data, S_IN source, DoubleConsumer b, Function m) {
+ for (Spliterator.OfDouble spl = m.apply(source).spliterator(); spl.tryAdvance(b); ) {
}
}
},
@@ -84,40 +83,40 @@ public enum DoubleStreamTestScenario implements OpTestCase.BaseStreamTestScenari
// Wrap as stream, spliterate, then split a few times mixing advances with forEach
STREAM_SPLITERATOR_WITH_MIXED_TRAVERSE_AND_SPLIT(false) {
>
- void _run(TestData data, DoubleConsumer b, Function m) {
- SpliteratorTestHelper.mixedTraverseAndSplit(b, m.apply(data.stream()).spliterator());
+ void run(TestData data, S_IN source, DoubleConsumer b, Function m) {
+ SpliteratorTestHelper.mixedTraverseAndSplit(b, m.apply(source).spliterator());
}
},
// Wrap as stream, and spliterate then iterate in pull mode
STREAM_SPLITERATOR_FOREACH(false) {
>
- void _run(TestData data, DoubleConsumer b, Function m) {
- m.apply(data.stream()).spliterator().forEachRemaining(b);
+ void run(TestData data, S_IN source, DoubleConsumer b, Function m) {
+ m.apply(source).spliterator().forEachRemaining(b);
}
},
PAR_STREAM_SEQUENTIAL_FOR_EACH(true) {
>
- void _run(TestData data, DoubleConsumer b, Function m) {
- m.apply(data.parallelStream()).sequential().forEach(b);
+ void run(TestData data, S_IN source, DoubleConsumer b, Function m) {
+ m.apply(source).sequential().forEach(b);
}
},
// Wrap as parallel stream + forEachOrdered
PAR_STREAM_FOR_EACH_ORDERED(true) {
>
- void _run(TestData data, DoubleConsumer b, Function m) {
+ void run(TestData data, S_IN source, DoubleConsumer b, Function m) {
// @@@ Want to explicitly select ordered equalator
- m.apply(data.parallelStream()).forEachOrdered(b);
+ m.apply(source).forEachOrdered(b);
}
},
// Wrap as stream, and spliterate then iterate sequentially
PAR_STREAM_SPLITERATOR(true) {
>
- void _run(TestData data, DoubleConsumer b, Function m) {
- for (Spliterator.OfDouble spl = m.apply(data.parallelStream()).spliterator(); spl.tryAdvance(b); ) {
+ void run(TestData data, S_IN source, DoubleConsumer b, Function m) {
+ for (Spliterator.OfDouble spl = m.apply(source).spliterator(); spl.tryAdvance(b); ) {
}
}
},
@@ -125,15 +124,15 @@ public enum DoubleStreamTestScenario implements OpTestCase.BaseStreamTestScenari
// Wrap as stream, and spliterate then iterate sequentially
PAR_STREAM_SPLITERATOR_FOREACH(true) {
>
- void _run(TestData data, DoubleConsumer b, Function m) {
- m.apply(data.parallelStream()).spliterator().forEachRemaining(b);
+ void run(TestData data, S_IN source, DoubleConsumer b, Function m) {
+ m.apply(source).spliterator().forEachRemaining(b);
}
},
PAR_STREAM_TO_ARRAY(true) {
>
- void _run(TestData data, DoubleConsumer b, Function m) {
- for (double t : m.apply(data.parallelStream()).toArray())
+ void run(TestData data, S_IN source, DoubleConsumer b, Function m) {
+ for (double t : m.apply(source).toArray())
b.accept(t);
}
},
@@ -141,8 +140,8 @@ public enum DoubleStreamTestScenario implements OpTestCase.BaseStreamTestScenari
// Wrap as parallel stream, get the spliterator, wrap as a stream + toArray
PAR_STREAM_SPLITERATOR_STREAM_TO_ARRAY(true) {
>
- void _run(TestData data, DoubleConsumer b, Function m) {
- DoubleStream s = m.apply(data.parallelStream());
+ void run(TestData data, S_IN source, DoubleConsumer b, Function m) {
+ DoubleStream s = m.apply(source);
Spliterator.OfDouble sp = s.spliterator();
DoubleStream ss = StreamSupport.doubleStream(() -> sp,
StreamOpFlag.toCharacteristics(OpTestCase.getStreamFlags(s))
@@ -154,8 +153,8 @@ public enum DoubleStreamTestScenario implements OpTestCase.BaseStreamTestScenari
PAR_STREAM_TO_ARRAY_CLEAR_SIZED(true) {
>
- void _run(TestData data, DoubleConsumer b, Function m) {
- S_IN pipe1 = (S_IN) OpTestCase.chain(data.parallelStream(),
+ void run(TestData data, S_IN source, DoubleConsumer b, Function m) {
+ S_IN pipe1 = (S_IN) OpTestCase.chain(source,
new FlagDeclaringOp(StreamOpFlag.NOT_SIZED, data.getShape()));
DoubleStream pipe2 = m.apply(pipe1);
@@ -167,8 +166,8 @@ public enum DoubleStreamTestScenario implements OpTestCase.BaseStreamTestScenari
// Wrap as parallel stream + forEach synchronizing
PAR_STREAM_FOR_EACH(true, false) {
>
- void _run(TestData data, DoubleConsumer b, Function m) {
- m.apply(data.parallelStream()).forEach(e -> {
+ void run(TestData data, S_IN source, DoubleConsumer b, Function m) {
+ m.apply(source).forEach(e -> {
synchronized (data) {
b.accept(e);
}
@@ -179,8 +178,8 @@ public enum DoubleStreamTestScenario implements OpTestCase.BaseStreamTestScenari
// Wrap as parallel stream + forEach synchronizing and clear SIZED flag
PAR_STREAM_FOR_EACH_CLEAR_SIZED(true, false) {
>
- void _run(TestData data, DoubleConsumer b, Function m) {
- S_IN pipe1 = (S_IN) OpTestCase.chain(data.parallelStream(),
+ void run(TestData data, S_IN source, DoubleConsumer b, Function m) {
+ S_IN pipe1 = (S_IN) OpTestCase.chain(source,
new FlagDeclaringOp(StreamOpFlag.NOT_SIZED, data.getShape()));
m.apply(pipe1).forEach(e -> {
synchronized (data) {
@@ -222,10 +221,12 @@ public enum DoubleStreamTestScenario implements OpTestCase.BaseStreamTestScenari
public , S_OUT extends BaseStream>
void run(TestData data, Consumer b, Function m) {
- _run(data, (DoubleConsumer) b, (Function) m);
+ try (S_IN source = getStream(data)) {
+ run(data, source, (DoubleConsumer) b, (Function) m);
+ }
}
abstract >
- void _run(TestData data, DoubleConsumer b, Function m);
+ void run(TestData data, S_IN source, DoubleConsumer b, Function m);
}
diff --git a/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java b/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java
index 9a3cc441380..526638d0cb8 100644
--- a/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java
+++ b/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java
@@ -43,22 +43,21 @@ import java.util.function.IntConsumer;
@SuppressWarnings({"rawtypes", "unchecked"})
public enum IntStreamTestScenario implements OpTestCase.BaseStreamTestScenario {
- STREAM_FOR_EACH_WITH_CLOSE(false) {
+ STREAM_FOR_EACH(false) {
>
- void _run(TestData data, IntConsumer b, Function m) {
- IntStream s = m.apply(data.stream());
+ void run(TestData data, S_IN source, IntConsumer b, Function m) {
+ IntStream s = m.apply(source);
if (s.isParallel()) {
s = s.sequential();
}
s.forEach(b);
- s.close();
}
},
STREAM_TO_ARRAY(false) {
>
- void _run(TestData data, IntConsumer b, Function m) {
- for (int t : m.apply(data.stream()).toArray()) {
+ void run(TestData data, S_IN source, IntConsumer b, Function m) {
+ for (int t : m.apply(source).toArray()) {
b.accept(t);
}
}
@@ -66,8 +65,8 @@ public enum IntStreamTestScenario implements OpTestCase.BaseStreamTestScenario {
STREAM_ITERATOR(false) {
>
- void _run(TestData data, IntConsumer b, Function m) {
- for (PrimitiveIterator.OfInt seqIter = m.apply(data.stream()).iterator(); seqIter.hasNext(); )
+ void run(TestData data, S_IN source, IntConsumer b, Function m) {
+ for (PrimitiveIterator.OfInt seqIter = m.apply(source).iterator(); seqIter.hasNext(); )
b.accept(seqIter.nextInt());
}
},
@@ -75,8 +74,8 @@ public enum IntStreamTestScenario implements OpTestCase.BaseStreamTestScenario {
// Wrap as stream, and spliterate then iterate in pull mode
STREAM_SPLITERATOR(false) {
>
- void _run(TestData data, IntConsumer b, Function m) {
- for (Spliterator.OfInt spl = m.apply(data.stream()).spliterator(); spl.tryAdvance(b); ) {
+ void run(TestData data, S_IN source, IntConsumer b, Function m) {
+ for (Spliterator.OfInt spl = m.apply(source).spliterator(); spl.tryAdvance(b); ) {
}
}
},
@@ -84,40 +83,40 @@ public enum IntStreamTestScenario implements OpTestCase.BaseStreamTestScenario {
// Wrap as stream, spliterate, then split a few times mixing advances with forEach
STREAM_SPLITERATOR_WITH_MIXED_TRAVERSE_AND_SPLIT(false) {
>
- void _run(TestData data, IntConsumer b, Function m) {
- SpliteratorTestHelper.mixedTraverseAndSplit(b, m.apply(data.stream()).spliterator());
+ void run(TestData data, S_IN source, IntConsumer b, Function m) {
+ SpliteratorTestHelper.mixedTraverseAndSplit(b, m.apply(source).spliterator());
}
},
// Wrap as stream, and spliterate then iterate in pull mode
STREAM_SPLITERATOR_FOREACH(false) {
>
- void _run(TestData data, IntConsumer b, Function m) {
- m.apply(data.stream()).spliterator().forEachRemaining(b);
+ void run(TestData data, S_IN source, IntConsumer b, Function m) {
+ m.apply(source).spliterator().forEachRemaining(b);
}
},
PAR_STREAM_SEQUENTIAL_FOR_EACH(true) {
>
- void _run(TestData data, IntConsumer b, Function m) {
- m.apply(data.parallelStream()).sequential().forEach(b);
+ void run(TestData data, S_IN source, IntConsumer b, Function m) {
+ m.apply(source).sequential().forEach(b);
}
},
// Wrap as parallel stream + forEachOrdered
PAR_STREAM_FOR_EACH_ORDERED(true) {
>
- void _run(TestData data, IntConsumer b, Function m) {
+ void run(TestData data, S_IN source, IntConsumer b, Function m) {
// @@@ Want to explicitly select ordered equalator
- m.apply(data.parallelStream()).forEachOrdered(b);
+ m.apply(source).forEachOrdered(b);
}
},
// Wrap as stream, and spliterate then iterate sequentially
PAR_STREAM_SPLITERATOR(true) {
>
- void _run(TestData data, IntConsumer b, Function m) {
- for (Spliterator.OfInt spl = m.apply(data.parallelStream()).spliterator(); spl.tryAdvance(b); ) {
+ void run(TestData data, S_IN source, IntConsumer b, Function m) {
+ for (Spliterator.OfInt spl = m.apply(source).spliterator(); spl.tryAdvance(b); ) {
}
}
},
@@ -125,15 +124,15 @@ public enum IntStreamTestScenario implements OpTestCase.BaseStreamTestScenario {
// Wrap as stream, and spliterate then iterate sequentially
PAR_STREAM_SPLITERATOR_FOREACH(true) {
>
- void _run(TestData data, IntConsumer b, Function m) {
- m.apply(data.parallelStream()).spliterator().forEachRemaining(b);
+ void run(TestData data, S_IN source, IntConsumer b, Function m) {
+ m.apply(source).spliterator().forEachRemaining(b);
}
},
PAR_STREAM_TO_ARRAY(true) {
>
- void _run(TestData data, IntConsumer b, Function m) {
- for (int t : m.apply(data.parallelStream()).toArray())
+ void run(TestData data, S_IN source, IntConsumer b, Function m) {
+ for (int t : m.apply(source).toArray())
b.accept(t);
}
},
@@ -141,8 +140,8 @@ public enum IntStreamTestScenario implements OpTestCase.BaseStreamTestScenario {
// Wrap as parallel stream, get the spliterator, wrap as a stream + toArray
PAR_STREAM_SPLITERATOR_STREAM_TO_ARRAY(true) {
>
- void _run(TestData data, IntConsumer b, Function m) {
- IntStream s = m.apply(data.parallelStream());
+ void run(TestData data, S_IN source, IntConsumer b, Function m) {
+ IntStream s = m.apply(source);
Spliterator.OfInt sp = s.spliterator();
IntStream ss = StreamSupport.intStream(() -> sp,
StreamOpFlag.toCharacteristics(OpTestCase.getStreamFlags(s))
@@ -155,8 +154,8 @@ public enum IntStreamTestScenario implements OpTestCase.BaseStreamTestScenario {
PAR_STREAM_TO_ARRAY_CLEAR_SIZED(true) {
>
- void _run(TestData data, IntConsumer b, Function m) {
- S_IN pipe1 = (S_IN) OpTestCase.chain(data.parallelStream(),
+ void run(TestData data, S_IN source, IntConsumer b, Function m) {
+ S_IN pipe1 = (S_IN) OpTestCase.chain(source,
new FlagDeclaringOp(StreamOpFlag.NOT_SIZED, data.getShape()));
IntStream pipe2 = m.apply(pipe1);
@@ -168,8 +167,8 @@ public enum IntStreamTestScenario implements OpTestCase.BaseStreamTestScenario {
// Wrap as parallel stream + forEach synchronizing
PAR_STREAM_FOR_EACH(true, false) {
>
- void _run(TestData data, IntConsumer b, Function m) {
- m.apply(data.parallelStream()).forEach(e -> {
+ void run(TestData data, S_IN source, IntConsumer b, Function m) {
+ m.apply(source).forEach(e -> {
synchronized (data) {
b.accept(e);
}
@@ -180,8 +179,8 @@ public enum IntStreamTestScenario implements OpTestCase.BaseStreamTestScenario {
// Wrap as parallel stream + forEach synchronizing and clear SIZED flag
PAR_STREAM_FOR_EACH_CLEAR_SIZED(true, false) {
>
- void _run(TestData data, IntConsumer b, Function m) {
- S_IN pipe1 = (S_IN) OpTestCase.chain(data.parallelStream(),
+ void run(TestData data, S_IN source, IntConsumer b, Function m) {
+ S_IN pipe1 = (S_IN) OpTestCase.chain(source,
new FlagDeclaringOp(StreamOpFlag.NOT_SIZED, data.getShape()));
m.apply(pipe1).forEach(e -> {
synchronized (data) {
@@ -223,10 +222,12 @@ public enum IntStreamTestScenario implements OpTestCase.BaseStreamTestScenario {
public , S_OUT extends BaseStream>
void run(TestData data, Consumer b, Function m) {
- _run(data, (IntConsumer) b, (Function) m);
+ try (S_IN source = getStream(data)) {
+ run(data, source, (IntConsumer) b, (Function) m);
+ }
}
abstract >
- void _run(TestData data, IntConsumer b, Function m);
+ void run(TestData data, S_IN source, IntConsumer b, Function m);
}
diff --git a/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java b/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java
index 6d3e1044b0b..acc2492d6f6 100644
--- a/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java
+++ b/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java
@@ -43,22 +43,21 @@ import java.util.function.LongConsumer;
@SuppressWarnings({"rawtypes", "unchecked"})
public enum LongStreamTestScenario implements OpTestCase.BaseStreamTestScenario {
- STREAM_FOR_EACH_WITH_CLOSE(false) {
+ STREAM_FOR_EACH(false) {
>
- void _run(TestData data, LongConsumer b, Function m) {
- LongStream s = m.apply(data.stream());
+ void run(TestData data, S_IN source, LongConsumer b, Function m) {
+ LongStream s = m.apply(source);
if (s.isParallel()) {
s = s.sequential();
}
s.forEach(b);
- s.close();
}
},
STREAM_TO_ARRAY(false) {
>
- void _run(TestData data, LongConsumer b, Function m) {
- for (long t : m.apply(data.stream()).toArray()) {
+ void run(TestData data, S_IN source, LongConsumer b, Function m) {
+ for (long t : m.apply(source).toArray()) {
b.accept(t);
}
}
@@ -66,8 +65,8 @@ public enum LongStreamTestScenario implements OpTestCase.BaseStreamTestScenario
STREAM_ITERATOR(false) {
>
- void _run(TestData data, LongConsumer b, Function m) {
- for (PrimitiveIterator.OfLong seqIter = m.apply(data.stream()).iterator(); seqIter.hasNext(); )
+ void run(TestData data, S_IN source, LongConsumer b, Function m) {
+ for (PrimitiveIterator.OfLong seqIter = m.apply(source).iterator(); seqIter.hasNext(); )
b.accept(seqIter.nextLong());
}
},
@@ -75,8 +74,8 @@ public enum LongStreamTestScenario implements OpTestCase.BaseStreamTestScenario
// Wrap as stream, and spliterate then iterate in pull mode
STREAM_SPLITERATOR(false) {
>
- void _run(TestData data, LongConsumer b, Function m) {
- for (Spliterator.OfLong spl = m.apply(data.stream()).spliterator(); spl.tryAdvance(b); ) {
+ void run(TestData data, S_IN source, LongConsumer b, Function m) {
+ for (Spliterator.OfLong spl = m.apply(source).spliterator(); spl.tryAdvance(b); ) {
}
}
},
@@ -84,40 +83,40 @@ public enum LongStreamTestScenario implements OpTestCase.BaseStreamTestScenario
// Wrap as stream, spliterate, then split a few times mixing advances with forEach
STREAM_SPLITERATOR_WITH_MIXED_TRAVERSE_AND_SPLIT(false) {
>
- void _run(TestData data, LongConsumer b, Function m) {
- SpliteratorTestHelper.mixedTraverseAndSplit(b, m.apply(data.stream()).spliterator());
+ void run(TestData data, S_IN source, LongConsumer b, Function m) {
+ SpliteratorTestHelper.mixedTraverseAndSplit(b, m.apply(source).spliterator());
}
},
// Wrap as stream, and spliterate then iterate in pull mode
STREAM_SPLITERATOR_FOREACH(false) {
>
- void _run(TestData data, LongConsumer b, Function m) {
- m.apply(data.stream()).spliterator().forEachRemaining(b);
+ void run(TestData data, S_IN source, LongConsumer b, Function m) {
+ m.apply(source).spliterator().forEachRemaining(b);
}
},
PAR_STREAM_SEQUENTIAL_FOR_EACH(true) {
>
- void _run(TestData data, LongConsumer b, Function m) {
- m.apply(data.parallelStream()).sequential().forEach(b);
+ void run(TestData data, S_IN source, LongConsumer b, Function m) {
+ m.apply(source).sequential().forEach(b);
}
},
// Wrap as parallel stream + forEachOrdered
PAR_STREAM_FOR_EACH_ORDERED(true) {
>
- void _run(TestData data, LongConsumer b, Function m) {
+ void run(TestData data, S_IN source, LongConsumer b, Function m) {
// @@@ Want to explicitly select ordered equalator
- m.apply(data.parallelStream()).forEachOrdered(b);
+ m.apply(source).forEachOrdered(b);
}
},
// Wrap as stream, and spliterate then iterate sequentially
PAR_STREAM_SPLITERATOR(true) {
>
- void _run(TestData data, LongConsumer b, Function m) {
- for (Spliterator.OfLong spl = m.apply(data.parallelStream()).spliterator(); spl.tryAdvance(b); ) {
+ void run(TestData data, S_IN source, LongConsumer b, Function m) {
+ for (Spliterator.OfLong spl = m.apply(source).spliterator(); spl.tryAdvance(b); ) {
}
}
},
@@ -125,15 +124,15 @@ public enum LongStreamTestScenario implements OpTestCase.BaseStreamTestScenario
// Wrap as stream, and spliterate then iterate sequentially
PAR_STREAM_SPLITERATOR_FOREACH(true) {
>
- void _run(TestData data, LongConsumer b, Function m) {
- m.apply(data.parallelStream()).spliterator().forEachRemaining(b);
+ void run(TestData data, S_IN source, LongConsumer b, Function m) {
+ m.apply(source).spliterator().forEachRemaining(b);
}
},
PAR_STREAM_TO_ARRAY(true) {
>
- void _run(TestData data, LongConsumer b, Function m) {
- for (long t : m.apply(data.parallelStream()).toArray())
+ void run(TestData data, S_IN source, LongConsumer b, Function