--- old/test/java/util/stream/boottest/java/util/stream/StreamReuseTest.java	2015-11-13 15:38:30.907223474 -0800
+++ /dev/null	2015-05-15 15:37:46.536788447 -0700
@@ -1,441 +0,0 @@
-/*
- * 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 java.util.stream;
-
-import org.testng.annotations.Test;
-
-import java.util.function.Function;
-
-import static org.testng.Assert.fail;
-
-/**
- * StreamReuseTest
- *
- * @author Brian Goetz
- */
-@Test
-public class StreamReuseTest {
-
-    private <T, U, E, S extends BaseStream<E, S>, D extends TestData<E, S>> void assertSecondFails(
-            D data,
-            Function<S, T> first,
-            Function<S, U> second,
-            Class<? extends Throwable> exception,
-            String text) {
-        S stream = data.stream();
-        T fr = first.apply(stream);
-        try {
-            U sr = second.apply(stream);
-            fail(text + " (seq)");
-        }
-        catch (Throwable e) {
-            if (exception.isAssignableFrom(e.getClass())) {
-                // Expected
-            }
-            else if (e instanceof Error)
-                throw (Error) e;
-            else if (e instanceof RuntimeException)
-                throw (RuntimeException) e;
-            else
-                throw new AssertionError("Unexpected exception " + e.getClass(), e);
-        }
-
-        stream = data.parallelStream();
-        fr = first.apply(stream);
-        try {
-            U sr = second.apply(stream);
-            fail(text + " (par)");
-        }
-        catch (Throwable e) {
-            if (exception.isAssignableFrom(e.getClass())) {
-                // Expected
-            }
-            else if (e instanceof Error)
-                throw (Error) e;
-            else if (e instanceof RuntimeException)
-                throw (RuntimeException) e;
-            else
-                throw new AssertionError("Unexpected exception " + e.getClass(), e);
-        }
-    }
-
-    // Stream
-
-    @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
-    public void testTwoStreams(String name, TestData<Integer, Stream<Integer>> data) {
-        assertSecondFails(data,
-                          (Stream<Integer> s) -> s.map(i -> i), (Stream<Integer> s) -> s.map(i -> i),
-                          IllegalStateException.class,
-                          "Stream map / map succeeded erroneously");
-        assertSecondFails(data,
-                          Stream::distinct, (Stream<Integer> s) -> s.map(i -> i),
-                          IllegalStateException.class,
-                          "Stream distinct / map succeeded erroneously");
-        assertSecondFails(data,
-                          (Stream<Integer> s) -> s.map(i -> i), Stream::distinct,
-                          IllegalStateException.class,
-                          "Stream map / distinct succeeded erroneously");
-        assertSecondFails(data,
-                          Stream::distinct, Stream::distinct,
-                          IllegalStateException.class,
-                          "Stream distinct / distinct succeeded erroneously");
-    }
-
-    @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
-    public void testTwoTerminals(String name, TestData<Integer, Stream<Integer>> data) {
-        assertSecondFails(data,
-                          Stream::findFirst, Stream::findFirst,
-                          IllegalStateException.class,
-                          "Stream findFirst / findFirst succeeded erroneously");
-    }
-
-    @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
-    public void testTerminalStream(String name, TestData<Integer, Stream<Integer>> data) {
-        assertSecondFails(data,
-                          Stream::findFirst, (Stream<Integer> s) -> s.map(i -> i),
-                          IllegalStateException.class,
-                          "Stream findFirst / map succeeded erroneously");
-        assertSecondFails(data,
-                          (Stream<Integer> s) -> s.map(i -> i), Stream::findFirst,
-                          IllegalStateException.class,
-                          "Stream map / findFirst succeeded erroneously");
-        assertSecondFails(data,
-                          Stream::findFirst, Stream::distinct,
-                          IllegalStateException.class,
-                          "Stream findFirst / distinct succeeded erroneously");
-        assertSecondFails(data,
-                          Stream::distinct, Stream::findFirst,
-                          IllegalStateException.class,
-                          "Stream distinct / findFirst succeeded erroneously");
-    }
-
-    @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
-    public void testTwoIterators(String name, TestData<Integer, Stream<Integer>> data) {
-        assertSecondFails(data,
-                          Stream::iterator, Stream::iterator,
-                          IllegalStateException.class,
-                          "Stream iterator / iterator succeeded erroneously");
-    }
-
-    @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
-    public void testTerminalIterator(String name, TestData<Integer, Stream<Integer>> data) {
-        assertSecondFails(data,
-                          Stream::iterator, Stream::findFirst,
-                          IllegalStateException.class,
-                          "Stream iterator / findFirst succeeded erroneously");
-        assertSecondFails(data,
-                          Stream::findFirst, Stream::iterator,
-                          IllegalStateException.class,
-                          "Stream findFirst / iterator succeeded erroneously");
-    }
-
-    @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
-    public void testStreamIterator(String name, TestData<Integer, Stream<Integer>> data) {
-        assertSecondFails(data,
-                          Stream::iterator, (Stream<Integer> s) -> s.map(i -> i),
-                          IllegalStateException.class,
-                          "Stream iterator / map succeeded erroneously");
-        assertSecondFails(data,
-                          (Stream<Integer> s) -> s.map(i -> i), Stream::iterator,
-                          IllegalStateException.class,
-                          "Stream map / iterator succeeded erroneously");
-        assertSecondFails(data,
-                          Stream::iterator, Stream::distinct,
-                          IllegalStateException.class,
-                          "Stream iterator / distinct succeeded erroneously");
-        assertSecondFails(data,
-                          Stream::distinct, Stream::iterator,
-                          IllegalStateException.class,
-                          "Stream distinct / iterator succeeded erroneously");
-    }
-
-    // IntStream
-
-    @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
-    public void testTwoStreams(String name, TestData.OfInt data) {
-        assertSecondFails(data,
-                          (IntStream s) -> s.mapToObj(i -> i), (IntStream s) -> s.mapToObj(i -> i),
-                          IllegalStateException.class,
-                          "IntStream map / map succeeded erroneously");
-        assertSecondFails(data,
-                          IntStream::distinct, (IntStream s) -> s.mapToObj(i -> i),
-                          IllegalStateException.class,
-                          "IntStream distinct / map succeeded erroneously");
-        assertSecondFails(data,
-                          (IntStream s) -> s.mapToObj(i -> i), IntStream::distinct,
-                          IllegalStateException.class,
-                          "IntStream map / distinct succeeded erroneously");
-        assertSecondFails(data,
-                          IntStream::distinct, IntStream::distinct,
-                          IllegalStateException.class,
-                          "IntStream distinct / distinct succeeded erroneously");
-    }
-
-    @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
-    public void testTwoTerminals(String name, TestData.OfInt data) {
-        assertSecondFails(data,
-                          IntStream::sum, IntStream::sum,
-                          IllegalStateException.class,
-                          "IntStream sum / sum succeeded erroneously");
-    }
-
-    @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
-    public void testTerminalStream(String name, TestData.OfInt data) {
-        assertSecondFails(data,
-                          IntStream::sum, (IntStream s) -> s.mapToObj(i -> i),
-                          IllegalStateException.class,
-                          "IntStream sum / map succeeded erroneously");
-        assertSecondFails(data,
-                          (IntStream s) -> s.mapToObj(i -> i), IntStream::sum,
-                          IllegalStateException.class,
-                          "IntStream map / sum succeeded erroneously");
-        assertSecondFails(data,
-                          IntStream::sum, IntStream::distinct,
-                          IllegalStateException.class,
-                          "IntStream sum / distinct succeeded erroneously");
-        assertSecondFails(data,
-                          IntStream::distinct, IntStream::sum,
-                          IllegalStateException.class,
-                          "IntStream distinct / sum succeeded erroneously");
-    }
-
-    @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
-    public void testTwoIterators(String name, TestData.OfInt data) {
-        assertSecondFails(data,
-                          IntStream::iterator, IntStream::iterator,
-                          IllegalStateException.class,
-                          "IntStream iterator / iterator succeeded erroneously");
-    }
-
-    @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
-    public void testTerminalIterator(String name, TestData.OfInt data) {
-        assertSecondFails(data,
-                          IntStream::iterator, IntStream::sum,
-                          IllegalStateException.class,
-                          "IntStream iterator / sum succeeded erroneously");
-        assertSecondFails(data,
-                          IntStream::sum, IntStream::iterator,
-                          IllegalStateException.class,
-                          "Stream sum / iterator succeeded erroneously");
-    }
-
-    @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
-    public void testStreamIterator(String name, TestData.OfInt data) {
-        assertSecondFails(data,
-                          IntStream::iterator, (IntStream s) -> s.mapToObj(i -> i),
-                          IllegalStateException.class,
-                          "IntStream iterator / map succeeded erroneously");
-        assertSecondFails(data,
-                          (IntStream s) -> s.mapToObj(i -> i), IntStream::iterator,
-                          IllegalStateException.class,
-                          "IntStream map / iterator succeeded erroneously");
-        assertSecondFails(data,
-                          IntStream::iterator, IntStream::distinct,
-                          IllegalStateException.class,
-                          "IntStream iterator / distinct succeeded erroneously");
-        assertSecondFails(data,
-                          IntStream::distinct, IntStream::iterator,
-                          IllegalStateException.class,
-                          "IntStream distinct / iterator succeeded erroneously");
-    }
-
-    // LongStream
-
-    @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
-    public void testTwoStreams(String name, TestData.OfLong data) {
-        assertSecondFails(data,
-                          (LongStream s) -> s.mapToObj(i -> i), (LongStream s) -> s.mapToObj(i -> i),
-                          IllegalStateException.class,
-                          "LongStream map / map succeeded erroneously");
-        assertSecondFails(data,
-                          LongStream::distinct, (LongStream s) -> s.mapToObj(i -> i),
-                          IllegalStateException.class,
-                          "LongStream distinct / map succeeded erroneously");
-        assertSecondFails(data,
-                          (LongStream s) -> s.mapToObj(i -> i), LongStream::distinct,
-                          IllegalStateException.class,
-                          "LongStream map / distinct succeeded erroneously");
-        assertSecondFails(data,
-                          LongStream::distinct, LongStream::distinct,
-                          IllegalStateException.class,
-                          "LongStream distinct / distinct succeeded erroneously");
-    }
-
-    @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
-    public void testTwoTerminals(String name, TestData.OfLong data) {
-        assertSecondFails(data,
-                          LongStream::sum, LongStream::sum,
-                          IllegalStateException.class,
-                          "LongStream sum / sum succeeded erroneously");
-    }
-
-    @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
-    public void testTerminalStream(String name, TestData.OfLong data) {
-        assertSecondFails(data,
-                          LongStream::sum, (LongStream s) -> s.mapToObj(i -> i),
-                          IllegalStateException.class,
-                          "LongStream sum / map succeeded erroneously");
-        assertSecondFails(data,
-                          (LongStream s) -> s.mapToObj(i -> i), LongStream::sum,
-                          IllegalStateException.class,
-                          "LongStream map / sum succeeded erroneously");
-        assertSecondFails(data,
-                          LongStream::sum, LongStream::distinct,
-                          IllegalStateException.class,
-                          "LongStream sum / distinct succeeded erroneously");
-        assertSecondFails(data,
-                          LongStream::distinct, LongStream::sum,
-                          IllegalStateException.class,
-                          "LongStream distinct / sum succeeded erroneously");
-    }
-
-    @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
-    public void testTwoIterators(String name, TestData.OfLong data) {
-        assertSecondFails(data,
-                          LongStream::iterator, LongStream::iterator,
-                          IllegalStateException.class,
-                          "LongStream iterator / iterator succeeded erroneously");
-    }
-
-    @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
-    public void testTerminalIterator(String name, TestData.OfLong data) {
-        assertSecondFails(data,
-                          LongStream::iterator, LongStream::sum,
-                          IllegalStateException.class,
-                          "LongStream iterator / sum succeeded erroneously");
-        assertSecondFails(data,
-                          LongStream::sum, LongStream::iterator,
-                          IllegalStateException.class,
-                          "Stream sum / iterator succeeded erroneously");
-    }
-
-    @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
-    public void testStreamIterator(String name, TestData.OfLong data) {
-        assertSecondFails(data,
-                          LongStream::iterator, (LongStream s) -> s.mapToObj(i -> i),
-                          IllegalStateException.class,
-                          "LongStream iterator / map succeeded erroneously");
-        assertSecondFails(data,
-                          (LongStream s) -> s.mapToObj(i -> i), LongStream::iterator,
-                          IllegalStateException.class,
-                          "LongStream map / iterator succeeded erroneously");
-        assertSecondFails(data,
-                          LongStream::iterator, LongStream::distinct,
-                          IllegalStateException.class,
-                          "LongStream iterator / distinct succeeded erroneously");
-        assertSecondFails(data,
-                          LongStream::distinct, LongStream::iterator,
-                          IllegalStateException.class,
-                          "LongStream distinct / iterator succeeded erroneously");
-    }
-
-    // DoubleStream
-
-    @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
-    public void testTwoStreams(String name, TestData.OfDouble data) {
-        assertSecondFails(data,
-                          (DoubleStream s) -> s.mapToObj(i -> i), (DoubleStream s) -> s.mapToObj(i -> i),
-                          IllegalStateException.class,
-                          "DoubleStream map / map succeeded erroneously");
-        assertSecondFails(data,
-                          DoubleStream::distinct, (DoubleStream s) -> s.mapToObj(i -> i),
-                          IllegalStateException.class,
-                          "DoubleStream distinct / map succeeded erroneously");
-        assertSecondFails(data,
-                          (DoubleStream s) -> s.mapToObj(i -> i), DoubleStream::distinct,
-                          IllegalStateException.class,
-                          "DoubleStream map / distinct succeeded erroneously");
-        assertSecondFails(data,
-                          DoubleStream::distinct, DoubleStream::distinct,
-                          IllegalStateException.class,
-                          "DoubleStream distinct / distinct succeeded erroneously");
-    }
-
-    @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
-    public void testTwoTerminals(String name, TestData.OfDouble data) {
-        assertSecondFails(data,
-                          DoubleStream::sum, DoubleStream::sum,
-                          IllegalStateException.class,
-                          "DoubleStream sum / sum succeeded erroneously");
-    }
-
-    @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
-    public void testTerminalStream(String name, TestData.OfDouble data) {
-        assertSecondFails(data,
-                          DoubleStream::sum, (DoubleStream s) -> s.mapToObj(i -> i),
-                          IllegalStateException.class,
-                          "DoubleStream sum / map succeeded erroneously");
-        assertSecondFails(data,
-                          (DoubleStream s) -> s.mapToObj(i -> i), DoubleStream::sum,
-                          IllegalStateException.class,
-                          "DoubleStream map / sum succeeded erroneously");
-        assertSecondFails(data,
-                          DoubleStream::sum, DoubleStream::distinct,
-                          IllegalStateException.class,
-                          "DoubleStream sum / distinct succeeded erroneously");
-        assertSecondFails(data,
-                          DoubleStream::distinct, DoubleStream::sum,
-                          IllegalStateException.class,
-                          "DoubleStream distinct / sum succeeded erroneously");
-    }
-
-    @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
-    public void testTwoIterators(String name, TestData.OfDouble data) {
-        assertSecondFails(data,
-                          DoubleStream::iterator, DoubleStream::iterator,
-                          IllegalStateException.class,
-                          "DoubleStream iterator / iterator succeeded erroneously");
-    }
-
-    @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
-    public void testTerminalIterator(String name, TestData.OfDouble data) {
-        assertSecondFails(data,
-                          DoubleStream::iterator, DoubleStream::sum,
-                          IllegalStateException.class,
-                          "DoubleStream iterator / sum succeeded erroneously");
-        assertSecondFails(data,
-                          DoubleStream::sum, DoubleStream::iterator,
-                          IllegalStateException.class,
-                          "Stream sum / iterator succeeded erroneously");
-    }
-
-    @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
-    public void testStreamIterator(String name, TestData.OfDouble data) {
-        assertSecondFails(data,
-                          DoubleStream::iterator, (DoubleStream s) -> s.mapToObj(i -> i),
-                          IllegalStateException.class,
-                          "DoubleStream iterator / map succeeded erroneously");
-        assertSecondFails(data,
-                          (DoubleStream s) -> s.mapToObj(i -> i), DoubleStream::iterator,
-                          IllegalStateException.class,
-                          "DoubleStream map / iterator succeeded erroneously");
-        assertSecondFails(data,
-                          DoubleStream::iterator, DoubleStream::distinct,
-                          IllegalStateException.class,
-                          "DoubleStream iterator / distinct succeeded erroneously");
-        assertSecondFails(data,
-                          DoubleStream::distinct, DoubleStream::iterator,
-                          IllegalStateException.class,
-                          "DoubleStream distinct / iterator succeeded erroneously");
-    }
-}
--- /dev/null	2015-05-15 15:37:46.536788447 -0700
+++ new/test/java/util/stream/boottest/java.base/java/util/stream/StreamReuseTest.java	2015-11-13 15:38:30.707214969 -0800
@@ -0,0 +1,441 @@
+/*
+ * 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 java.util.stream;
+
+import org.testng.annotations.Test;
+
+import java.util.function.Function;
+
+import static org.testng.Assert.fail;
+
+/**
+ * StreamReuseTest
+ *
+ * @author Brian Goetz
+ */
+@Test
+public class StreamReuseTest {
+
+    private <T, U, E, S extends BaseStream<E, S>, D extends TestData<E, S>> void assertSecondFails(
+            D data,
+            Function<S, T> first,
+            Function<S, U> second,
+            Class<? extends Throwable> exception,
+            String text) {
+        S stream = data.stream();
+        T fr = first.apply(stream);
+        try {
+            U sr = second.apply(stream);
+            fail(text + " (seq)");
+        }
+        catch (Throwable e) {
+            if (exception.isAssignableFrom(e.getClass())) {
+                // Expected
+            }
+            else if (e instanceof Error)
+                throw (Error) e;
+            else if (e instanceof RuntimeException)
+                throw (RuntimeException) e;
+            else
+                throw new AssertionError("Unexpected exception " + e.getClass(), e);
+        }
+
+        stream = data.parallelStream();
+        fr = first.apply(stream);
+        try {
+            U sr = second.apply(stream);
+            fail(text + " (par)");
+        }
+        catch (Throwable e) {
+            if (exception.isAssignableFrom(e.getClass())) {
+                // Expected
+            }
+            else if (e instanceof Error)
+                throw (Error) e;
+            else if (e instanceof RuntimeException)
+                throw (RuntimeException) e;
+            else
+                throw new AssertionError("Unexpected exception " + e.getClass(), e);
+        }
+    }
+
+    // Stream
+
+    @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+    public void testTwoStreams(String name, TestData<Integer, Stream<Integer>> data) {
+        assertSecondFails(data,
+                          (Stream<Integer> s) -> s.map(i -> i), (Stream<Integer> s) -> s.map(i -> i),
+                          IllegalStateException.class,
+                          "Stream map / map succeeded erroneously");
+        assertSecondFails(data,
+                          Stream::distinct, (Stream<Integer> s) -> s.map(i -> i),
+                          IllegalStateException.class,
+                          "Stream distinct / map succeeded erroneously");
+        assertSecondFails(data,
+                          (Stream<Integer> s) -> s.map(i -> i), Stream::distinct,
+                          IllegalStateException.class,
+                          "Stream map / distinct succeeded erroneously");
+        assertSecondFails(data,
+                          Stream::distinct, Stream::distinct,
+                          IllegalStateException.class,
+                          "Stream distinct / distinct succeeded erroneously");
+    }
+
+    @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+    public void testTwoTerminals(String name, TestData<Integer, Stream<Integer>> data) {
+        assertSecondFails(data,
+                          Stream::findFirst, Stream::findFirst,
+                          IllegalStateException.class,
+                          "Stream findFirst / findFirst succeeded erroneously");
+    }
+
+    @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+    public void testTerminalStream(String name, TestData<Integer, Stream<Integer>> data) {
+        assertSecondFails(data,
+                          Stream::findFirst, (Stream<Integer> s) -> s.map(i -> i),
+                          IllegalStateException.class,
+                          "Stream findFirst / map succeeded erroneously");
+        assertSecondFails(data,
+                          (Stream<Integer> s) -> s.map(i -> i), Stream::findFirst,
+                          IllegalStateException.class,
+                          "Stream map / findFirst succeeded erroneously");
+        assertSecondFails(data,
+                          Stream::findFirst, Stream::distinct,
+                          IllegalStateException.class,
+                          "Stream findFirst / distinct succeeded erroneously");
+        assertSecondFails(data,
+                          Stream::distinct, Stream::findFirst,
+                          IllegalStateException.class,
+                          "Stream distinct / findFirst succeeded erroneously");
+    }
+
+    @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+    public void testTwoIterators(String name, TestData<Integer, Stream<Integer>> data) {
+        assertSecondFails(data,
+                          Stream::iterator, Stream::iterator,
+                          IllegalStateException.class,
+                          "Stream iterator / iterator succeeded erroneously");
+    }
+
+    @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+    public void testTerminalIterator(String name, TestData<Integer, Stream<Integer>> data) {
+        assertSecondFails(data,
+                          Stream::iterator, Stream::findFirst,
+                          IllegalStateException.class,
+                          "Stream iterator / findFirst succeeded erroneously");
+        assertSecondFails(data,
+                          Stream::findFirst, Stream::iterator,
+                          IllegalStateException.class,
+                          "Stream findFirst / iterator succeeded erroneously");
+    }
+
+    @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+    public void testStreamIterator(String name, TestData<Integer, Stream<Integer>> data) {
+        assertSecondFails(data,
+                          Stream::iterator, (Stream<Integer> s) -> s.map(i -> i),
+                          IllegalStateException.class,
+                          "Stream iterator / map succeeded erroneously");
+        assertSecondFails(data,
+                          (Stream<Integer> s) -> s.map(i -> i), Stream::iterator,
+                          IllegalStateException.class,
+                          "Stream map / iterator succeeded erroneously");
+        assertSecondFails(data,
+                          Stream::iterator, Stream::distinct,
+                          IllegalStateException.class,
+                          "Stream iterator / distinct succeeded erroneously");
+        assertSecondFails(data,
+                          Stream::distinct, Stream::iterator,
+                          IllegalStateException.class,
+                          "Stream distinct / iterator succeeded erroneously");
+    }
+
+    // IntStream
+
+    @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+    public void testTwoStreams(String name, TestData.OfInt data) {
+        assertSecondFails(data,
+                          (IntStream s) -> s.mapToObj(i -> i), (IntStream s) -> s.mapToObj(i -> i),
+                          IllegalStateException.class,
+                          "IntStream map / map succeeded erroneously");
+        assertSecondFails(data,
+                          IntStream::distinct, (IntStream s) -> s.mapToObj(i -> i),
+                          IllegalStateException.class,
+                          "IntStream distinct / map succeeded erroneously");
+        assertSecondFails(data,
+                          (IntStream s) -> s.mapToObj(i -> i), IntStream::distinct,
+                          IllegalStateException.class,
+                          "IntStream map / distinct succeeded erroneously");
+        assertSecondFails(data,
+                          IntStream::distinct, IntStream::distinct,
+                          IllegalStateException.class,
+                          "IntStream distinct / distinct succeeded erroneously");
+    }
+
+    @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+    public void testTwoTerminals(String name, TestData.OfInt data) {
+        assertSecondFails(data,
+                          IntStream::sum, IntStream::sum,
+                          IllegalStateException.class,
+                          "IntStream sum / sum succeeded erroneously");
+    }
+
+    @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+    public void testTerminalStream(String name, TestData.OfInt data) {
+        assertSecondFails(data,
+                          IntStream::sum, (IntStream s) -> s.mapToObj(i -> i),
+                          IllegalStateException.class,
+                          "IntStream sum / map succeeded erroneously");
+        assertSecondFails(data,
+                          (IntStream s) -> s.mapToObj(i -> i), IntStream::sum,
+                          IllegalStateException.class,
+                          "IntStream map / sum succeeded erroneously");
+        assertSecondFails(data,
+                          IntStream::sum, IntStream::distinct,
+                          IllegalStateException.class,
+                          "IntStream sum / distinct succeeded erroneously");
+        assertSecondFails(data,
+                          IntStream::distinct, IntStream::sum,
+                          IllegalStateException.class,
+                          "IntStream distinct / sum succeeded erroneously");
+    }
+
+    @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+    public void testTwoIterators(String name, TestData.OfInt data) {
+        assertSecondFails(data,
+                          IntStream::iterator, IntStream::iterator,
+                          IllegalStateException.class,
+                          "IntStream iterator / iterator succeeded erroneously");
+    }
+
+    @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+    public void testTerminalIterator(String name, TestData.OfInt data) {
+        assertSecondFails(data,
+                          IntStream::iterator, IntStream::sum,
+                          IllegalStateException.class,
+                          "IntStream iterator / sum succeeded erroneously");
+        assertSecondFails(data,
+                          IntStream::sum, IntStream::iterator,
+                          IllegalStateException.class,
+                          "Stream sum / iterator succeeded erroneously");
+    }
+
+    @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+    public void testStreamIterator(String name, TestData.OfInt data) {
+        assertSecondFails(data,
+                          IntStream::iterator, (IntStream s) -> s.mapToObj(i -> i),
+                          IllegalStateException.class,
+                          "IntStream iterator / map succeeded erroneously");
+        assertSecondFails(data,
+                          (IntStream s) -> s.mapToObj(i -> i), IntStream::iterator,
+                          IllegalStateException.class,
+                          "IntStream map / iterator succeeded erroneously");
+        assertSecondFails(data,
+                          IntStream::iterator, IntStream::distinct,
+                          IllegalStateException.class,
+                          "IntStream iterator / distinct succeeded erroneously");
+        assertSecondFails(data,
+                          IntStream::distinct, IntStream::iterator,
+                          IllegalStateException.class,
+                          "IntStream distinct / iterator succeeded erroneously");
+    }
+
+    // LongStream
+
+    @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+    public void testTwoStreams(String name, TestData.OfLong data) {
+        assertSecondFails(data,
+                          (LongStream s) -> s.mapToObj(i -> i), (LongStream s) -> s.mapToObj(i -> i),
+                          IllegalStateException.class,
+                          "LongStream map / map succeeded erroneously");
+        assertSecondFails(data,
+                          LongStream::distinct, (LongStream s) -> s.mapToObj(i -> i),
+                          IllegalStateException.class,
+                          "LongStream distinct / map succeeded erroneously");
+        assertSecondFails(data,
+                          (LongStream s) -> s.mapToObj(i -> i), LongStream::distinct,
+                          IllegalStateException.class,
+                          "LongStream map / distinct succeeded erroneously");
+        assertSecondFails(data,
+                          LongStream::distinct, LongStream::distinct,
+                          IllegalStateException.class,
+                          "LongStream distinct / distinct succeeded erroneously");
+    }
+
+    @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+    public void testTwoTerminals(String name, TestData.OfLong data) {
+        assertSecondFails(data,
+                          LongStream::sum, LongStream::sum,
+                          IllegalStateException.class,
+                          "LongStream sum / sum succeeded erroneously");
+    }
+
+    @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+    public void testTerminalStream(String name, TestData.OfLong data) {
+        assertSecondFails(data,
+                          LongStream::sum, (LongStream s) -> s.mapToObj(i -> i),
+                          IllegalStateException.class,
+                          "LongStream sum / map succeeded erroneously");
+        assertSecondFails(data,
+                          (LongStream s) -> s.mapToObj(i -> i), LongStream::sum,
+                          IllegalStateException.class,
+                          "LongStream map / sum succeeded erroneously");
+        assertSecondFails(data,
+                          LongStream::sum, LongStream::distinct,
+                          IllegalStateException.class,
+                          "LongStream sum / distinct succeeded erroneously");
+        assertSecondFails(data,
+                          LongStream::distinct, LongStream::sum,
+                          IllegalStateException.class,
+                          "LongStream distinct / sum succeeded erroneously");
+    }
+
+    @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+    public void testTwoIterators(String name, TestData.OfLong data) {
+        assertSecondFails(data,
+                          LongStream::iterator, LongStream::iterator,
+                          IllegalStateException.class,
+                          "LongStream iterator / iterator succeeded erroneously");
+    }
+
+    @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+    public void testTerminalIterator(String name, TestData.OfLong data) {
+        assertSecondFails(data,
+                          LongStream::iterator, LongStream::sum,
+                          IllegalStateException.class,
+                          "LongStream iterator / sum succeeded erroneously");
+        assertSecondFails(data,
+                          LongStream::sum, LongStream::iterator,
+                          IllegalStateException.class,
+                          "Stream sum / iterator succeeded erroneously");
+    }
+
+    @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+    public void testStreamIterator(String name, TestData.OfLong data) {
+        assertSecondFails(data,
+                          LongStream::iterator, (LongStream s) -> s.mapToObj(i -> i),
+                          IllegalStateException.class,
+                          "LongStream iterator / map succeeded erroneously");
+        assertSecondFails(data,
+                          (LongStream s) -> s.mapToObj(i -> i), LongStream::iterator,
+                          IllegalStateException.class,
+                          "LongStream map / iterator succeeded erroneously");
+        assertSecondFails(data,
+                          LongStream::iterator, LongStream::distinct,
+                          IllegalStateException.class,
+                          "LongStream iterator / distinct succeeded erroneously");
+        assertSecondFails(data,
+                          LongStream::distinct, LongStream::iterator,
+                          IllegalStateException.class,
+                          "LongStream distinct / iterator succeeded erroneously");
+    }
+
+    // DoubleStream
+
+    @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+    public void testTwoStreams(String name, TestData.OfDouble data) {
+        assertSecondFails(data,
+                          (DoubleStream s) -> s.mapToObj(i -> i), (DoubleStream s) -> s.mapToObj(i -> i),
+                          IllegalStateException.class,
+                          "DoubleStream map / map succeeded erroneously");
+        assertSecondFails(data,
+                          DoubleStream::distinct, (DoubleStream s) -> s.mapToObj(i -> i),
+                          IllegalStateException.class,
+                          "DoubleStream distinct / map succeeded erroneously");
+        assertSecondFails(data,
+                          (DoubleStream s) -> s.mapToObj(i -> i), DoubleStream::distinct,
+                          IllegalStateException.class,
+                          "DoubleStream map / distinct succeeded erroneously");
+        assertSecondFails(data,
+                          DoubleStream::distinct, DoubleStream::distinct,
+                          IllegalStateException.class,
+                          "DoubleStream distinct / distinct succeeded erroneously");
+    }
+
+    @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+    public void testTwoTerminals(String name, TestData.OfDouble data) {
+        assertSecondFails(data,
+                          DoubleStream::sum, DoubleStream::sum,
+                          IllegalStateException.class,
+                          "DoubleStream sum / sum succeeded erroneously");
+    }
+
+    @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+    public void testTerminalStream(String name, TestData.OfDouble data) {
+        assertSecondFails(data,
+                          DoubleStream::sum, (DoubleStream s) -> s.mapToObj(i -> i),
+                          IllegalStateException.class,
+                          "DoubleStream sum / map succeeded erroneously");
+        assertSecondFails(data,
+                          (DoubleStream s) -> s.mapToObj(i -> i), DoubleStream::sum,
+                          IllegalStateException.class,
+                          "DoubleStream map / sum succeeded erroneously");
+        assertSecondFails(data,
+                          DoubleStream::sum, DoubleStream::distinct,
+                          IllegalStateException.class,
+                          "DoubleStream sum / distinct succeeded erroneously");
+        assertSecondFails(data,
+                          DoubleStream::distinct, DoubleStream::sum,
+                          IllegalStateException.class,
+                          "DoubleStream distinct / sum succeeded erroneously");
+    }
+
+    @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+    public void testTwoIterators(String name, TestData.OfDouble data) {
+        assertSecondFails(data,
+                          DoubleStream::iterator, DoubleStream::iterator,
+                          IllegalStateException.class,
+                          "DoubleStream iterator / iterator succeeded erroneously");
+    }
+
+    @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+    public void testTerminalIterator(String name, TestData.OfDouble data) {
+        assertSecondFails(data,
+                          DoubleStream::iterator, DoubleStream::sum,
+                          IllegalStateException.class,
+                          "DoubleStream iterator / sum succeeded erroneously");
+        assertSecondFails(data,
+                          DoubleStream::sum, DoubleStream::iterator,
+                          IllegalStateException.class,
+                          "Stream sum / iterator succeeded erroneously");
+    }
+
+    @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+    public void testStreamIterator(String name, TestData.OfDouble data) {
+        assertSecondFails(data,
+                          DoubleStream::iterator, (DoubleStream s) -> s.mapToObj(i -> i),
+                          IllegalStateException.class,
+                          "DoubleStream iterator / map succeeded erroneously");
+        assertSecondFails(data,
+                          (DoubleStream s) -> s.mapToObj(i -> i), DoubleStream::iterator,
+                          IllegalStateException.class,
+                          "DoubleStream map / iterator succeeded erroneously");
+        assertSecondFails(data,
+                          DoubleStream::iterator, DoubleStream::distinct,
+                          IllegalStateException.class,
+                          "DoubleStream iterator / distinct succeeded erroneously");
+        assertSecondFails(data,
+                          DoubleStream::distinct, DoubleStream::iterator,
+                          IllegalStateException.class,
+                          "DoubleStream distinct / iterator succeeded erroneously");
+    }
+}