Java example source code file (StreamReuseTest.java)

This example Java source code file (StreamReuseTest.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

doublestream, doublestream\:\:distinct, doublestream\:\:sum, intstream, intstream\:\:sum, longstream, longstream\:\:distinct, longstream\:\:iterator, longstream\:\:sum, stream, stream\:\:distinct, stream\:\:findfirst, stream\:\:iterator, test

The StreamReuseTest.java Java example source code

/*
 * 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> 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 data) {
        assertSecondFails(data,
                          (Stream<Integer> s) -> s.map(i -> i), (Stream 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 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 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 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 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 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");
    }
}