/*
* 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");
}
}