ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ToArrayOpTest.java - platform/libcore - Git at Google

 /*
  * 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 org.openjdk.tests.java.util.stream;

 import org.testng.annotations.Test;

 import java.util.*;
 import java.util.function.Function;
 import java.util.stream.*;

 import static java.util.stream.LambdaTestHelpers.*;
 import static org.testng.Assert.assertEquals;


 /**
  * ToArrayOpTest
  *
  */
 @Test
 public class ToArrayOpTest extends OpTestCase {

     public void testToArray() {
         assertCountSum(Arrays.asList(countTo(0).stream().toArray()), 0, 0);
         assertCountSum(Arrays.asList(countTo(10).stream().toArray()), 10, 55);
     }

     @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
     public void testOps(String name, TestData.OfRef<Integer> data) {
         exerciseTerminalOps(data, s -> s.toArray());
     }

     @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
     public void testOpsWithMap(String name, TestData.OfRef<Integer> data) {
         // Retain the size of the source
         // This should kick in the parallel evaluation optimization for tasks stuffing elements into a shared array

         Object[] objects = exerciseTerminalOps(data, s -> s.map(i -> (Integer) (i + i)), s -> s.toArray());
         assertTrue(objects.length == data.size());
     }

     @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
     public void testOpsWithSorted(String name, TestData.OfRef<Integer> data) {
         // Retain the size of the source
         // This should kick in the parallel evaluation optimization for tasks stuffing elements into a shared array

         Object[] objects = exerciseTerminalOps(data, s -> s.sorted(), s -> s.toArray());
         assertTrue(objects.length == data.size());
     }

     @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
     public void testOpsWithFlatMap(String name, TestData.OfRef<Integer> data) {
         // Double the size of the source
         // Fixed size optimizations will not be used

         Object[] objects = exerciseTerminalOps(data,
                                                s -> s.flatMap(e -> Arrays.stream(new Object[] { e, e })),
                                                s -> s.toArray());
         assertTrue(objects.length == data.size() * 2);
     }

     @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
     public void testOpsWithFilter(String name, TestData.OfRef<Integer> data) {
         // Reduce the size of the source
         // Fixed size optimizations will not be used

         exerciseTerminalOps(data, s -> s.filter(LambdaTestHelpers.pEven), s -> s.toArray());
     }

     public void testAsArrayWithType() {
         exerciseTerminalOps(
                 TestData.Factory.ofCollection("", Arrays.asList(1.1, 2.2, 3.4, 4.4)),
                 s -> // First pipeline slice using Object[] with Double elements
                     s.sorted()
                     // Second pipeline slice using Integer[] with Integer elements
                     .map((Double d) -> Integer.valueOf(d.intValue())).sorted(),
                 s -> s.toArray(Integer[]::new));
     }

     private List<Function<Stream<Integer>, Stream<Integer>>> uniqueAndSortedPermutations =
             LambdaTestHelpers.permuteStreamFunctions(Arrays.asList(
                     s -> s.distinct(),
                     s -> s.distinct(),
                     s -> s.sorted(),
                     s -> s.sorted()
             ));

     @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
     public void testDistinctAndSortedPermutations(String name, TestData.OfRef<Integer> data) {
         for (Function<Stream<Integer>, Stream<Integer>> f : uniqueAndSortedPermutations) {
             exerciseTerminalOps(data, f, s -> s.toArray());

             Integer[] is = exerciseTerminalOps(data, f, s -> s.toArray(Integer[]::new));
             assertEquals(is.getClass(), Integer[].class);

             Number[] ns = exerciseTerminalOps(data, f, s -> s.toArray(Number[]::new));
             assertEquals(ns.getClass(), Number[].class);

             if (data.size() > 0) {
                 Exception caught = null;
                 try {
                     exerciseTerminalOps(data, f, s -> s.toArray(String[]::new));
                 } catch (Exception e) {
                     caught = e;
                 }
                 assertTrue(caught != null);
                 assertEquals(caught.getClass(), ArrayStoreException.class);
             }
         }
     }

     private List<Function<Stream<Integer>, Stream<Integer>>> statefulOpPermutations =
             LambdaTestHelpers.permuteStreamFunctions(Arrays.asList(
                     s -> s.limit(10),
                     s -> s.distinct(),
                     s -> s.sorted()
             ));

     private <T extends Object> ResultAsserter<T[]> statefulOpResultAsserter(TestData.OfRef<Integer> data) {
         return (act, exp, ord, par) -> {
             if (par) {
                 if (!data.isOrdered()) {
                     // Relax the checking if the data source is unordered
                     // It is not exactly possible to determine if the limit
                     // operation is present and if it is before or after
                     // the sorted operation
                     // If the limit operation is present and before the sorted
                     // operation then the sub-set output after limit is a
                     // non-deterministic sub-set of the source
                     List<Integer> expected = new ArrayList<>();
                     data.forEach(expected::add);

                     List<T> actual = Arrays.asList(act);

                     assertEquals(actual.size(), exp.length);
                     assertTrue(expected.containsAll(actual));
                     return;
                 }
                 else if (!ord) {
                     LambdaTestHelpers.assertContentsUnordered(Arrays.asList(act),
                                                               Arrays.asList(exp));
                     return;
                 }
             }
             assertEquals(act, exp);
         };
     }

     @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class,
           groups = { "serialization-hostile" })
     public void testStatefulOpPermutations(String name, TestData.OfRef<Integer> data) {
         for (Function<Stream<Integer>, Stream<Integer>> f : statefulOpPermutations) {
             withData(data).terminal(f, s -> s.toArray())
                     .resultAsserter(statefulOpResultAsserter(data))
                     .exercise();

             Integer[] is = withData(data).terminal(f, s -> s.toArray(Integer[]::new))
                     .resultAsserter(statefulOpResultAsserter(data))
                     .exercise();
             assertEquals(is.getClass(), Integer[].class);

             Number[] ns = withData(data).terminal(f, s -> s.toArray(Number[]::new))
                     .resultAsserter(statefulOpResultAsserter(data))
                     .exercise();
             assertEquals(ns.getClass(), Number[].class);

             if (data.size() > 0) {
                 Exception caught = null;
                 try {
                     exerciseTerminalOps(data, f, s -> s.toArray(String[]::new));
                 } catch (Exception e) {
                     caught = e;
                 }
                 assertTrue(caught != null);
                 assertEquals(caught.getClass(), ArrayStoreException.class);
             }
         }
     }

     //

     @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
     public void testIntOps(String name, TestData.OfInt data) {
         exerciseTerminalOps(data, s -> s.toArray());
     }

     @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
     public void testIntOpsWithMap(String name, TestData.OfInt data) {
         // Retain the size of the source
         // This should kick in the parallel evaluation optimization for tasks stuffing elements into a shared array

         int[] ints = exerciseTerminalOps(data, s -> s.map(i -> i + i), s -> s.toArray());
         assertTrue(ints.length == data.size());
     }

     @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
     public void testIntOpsWithSorted(String name, TestData.OfInt data) {
         // Retain the size of the source
         // This should kick in the parallel evaluation optimization for tasks stuffing elements into a shared array

         int[] ints = exerciseTerminalOps(data, s -> s.sorted(), (IntStream s) -> s.toArray());
         assertTrue(ints.length == data.size());
     }

     @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
     public void testIntOpsWithFlatMap(String name, TestData.OfInt data) {
         // Int the size of the source
         // Fixed size optimizations will not be used

         int[] objects = exerciseTerminalOps(data,
                                                s -> s.flatMap(e -> Arrays.stream(new int[] { e, e })),
                                                s -> s.toArray());
         assertTrue(objects.length == data.size() * 2);
     }

     @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
     public void testIntOpsWithFilter(String name, TestData.OfInt data) {
         // Reduce the size of the source
         // Fixed size optimizations will not be used

         exerciseTerminalOps(data, s -> s.filter(LambdaTestHelpers.ipEven), s -> s.toArray());
     }

     private List<Function<IntStream, IntStream>> intUniqueAndSortedPermutations =
             LambdaTestHelpers.permuteStreamFunctions(Arrays.asList(
                     s -> s.distinct(),
                     s -> s.distinct(),
                     s -> s.sorted(),
                     s -> s.sorted()
             ));

     @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
     public void testIntDistinctAndSortedPermutations(String name, TestData.OfInt data) {
         for (Function<IntStream, IntStream> f : intUniqueAndSortedPermutations) {
             exerciseTerminalOps(data, f, s -> s.toArray());
         }
     }

     private List<Function<IntStream, IntStream>> intStatefulOpPermutations =
             LambdaTestHelpers.permuteStreamFunctions(Arrays.asList(
                     s -> s.limit(10),
                     s -> s.distinct(),
                     s -> s.sorted()
             ));

     @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
     public void testIntStatefulOpPermutations(String name, TestData.OfInt data) {
         for (Function<IntStream, IntStream> f : intStatefulOpPermutations) {
             exerciseTerminalOps(data, f, s -> s.toArray());
         }
     }

     //

     @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
     public void testLongOps(String name, TestData.OfLong data) {
         exerciseTerminalOps(data, s -> s.toArray());
     }

     @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
     public void testLongOpsWithMap(String name, TestData.OfLong data) {
         // Retain the size of the source
         // This should kick in the parallel evaluation optimization for tasks stuffing elements into a shared array

         long[] longs = exerciseTerminalOps(data, s -> s.map(i -> i + i), s -> s.toArray());
         assertTrue(longs.length == data.size());
     }

     @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
     public void testLongOpsWithSorted(String name, TestData.OfLong data) {
         // Retain the size of the source
         // This should kick in the parallel evaluation optimization for tasks stuffing elements into a shared array

         long[] longs = exerciseTerminalOps(data, s -> s.sorted(), (LongStream s) -> s.toArray());
         assertTrue(longs.length == data.size());
     }

     @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
     public void testLongOpsWithFlatMap(String name, TestData.OfLong data) {
         // Long the size of the source
         // Fixed size optimizations will not be used

         long[] objects = exerciseTerminalOps(data,
                                                s -> s.flatMap(e -> Arrays.stream(new long[] { e, e })),
                                                s -> s.toArray());
         assertTrue(objects.length == data.size() * 2);
     }

     @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
     public void testLongOpsWithFilter(String name, TestData.OfLong data) {
         // Reduce the size of the source
         // Fixed size optimizations will not be used

         exerciseTerminalOps(data, s -> s.filter(LambdaTestHelpers.lpEven), s -> s.toArray());
     }

     private List<Function<LongStream, LongStream>> longUniqueAndSortedPermutations =
             LambdaTestHelpers.permuteStreamFunctions(Arrays.asList(
                     s -> s.distinct(),
                     s -> s.distinct(),
                     s -> s.sorted(),
                     s -> s.sorted()
             ));

     @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
     public void testLongDistinctAndSortedPermutations(String name, TestData.OfLong data) {
         for (Function<LongStream, LongStream> f : longUniqueAndSortedPermutations) {
             exerciseTerminalOps(data, f, s -> s.toArray());
         }
     }

     private List<Function<LongStream, LongStream>> longStatefulOpPermutations =
             LambdaTestHelpers.permuteStreamFunctions(Arrays.asList(
                     s -> s.limit(10),
                     s -> s.distinct(),
                     s -> s.sorted()
             ));

     @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
     public void testLongStatefulOpPermutations(String name, TestData.OfLong data) {
         for (Function<LongStream, LongStream> f : longStatefulOpPermutations) {
             exerciseTerminalOps(data, f, s -> s.toArray());
         }
     }

     //

     @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
     public void testDoubleOps(String name, TestData.OfDouble data) {
         exerciseTerminalOps(data, s -> s.toArray());
     }

     @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
     public void testDoubleOpsWithMap(String name, TestData.OfDouble data) {
         // Retain the size of the source
         // This should kick in the parallel evaluation optimization for tasks stuffing elements into a shared array

         double[] doubles = exerciseTerminalOps(data, s -> s.map(i -> i + i), s -> s.toArray());
         assertTrue(doubles.length == data.size());
     }

     @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
     public void testDoubleOpsWithSorted(String name, TestData.OfDouble data) {
         // Retain the size of the source
         // This should kick in the parallel evaluation optimization for tasks stuffing elements into a shared array

         double[] doubles = exerciseTerminalOps(data, s -> s.sorted(), (DoubleStream s) -> s.toArray());
         assertTrue(doubles.length == data.size());
     }

     @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
     public void testDoubleOpsWithFlatMap(String name, TestData.OfDouble data) {
         // Double the size of the source
         // Fixed size optimizations will not be used

         double[] objects = exerciseTerminalOps(data,
                                                s -> s.flatMap(e -> Arrays.stream(new double[] { e, e })),
                                                s -> s.toArray());
         assertTrue(objects.length == data.size() * 2);
     }

     @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
     public void testDoubleOpsWithFilter(String name, TestData.OfDouble data) {
         // Reduce the size of the source
         // Fixed size optimizations will not be used

         exerciseTerminalOps(data, s -> s.filter(LambdaTestHelpers.dpEven), s -> s.toArray());
     }

     private List<Function<DoubleStream, DoubleStream>> doubleUniqueAndSortedPermutations =
             LambdaTestHelpers.permuteStreamFunctions(Arrays.asList(
                     s -> s.distinct(),
                     s -> s.distinct(),
                     s -> s.sorted(),
                     s -> s.sorted()
             ));

     @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
     public void testDoubleDistinctAndSortedPermutations(String name, TestData.OfDouble data) {
         for (Function<DoubleStream, DoubleStream> f : doubleUniqueAndSortedPermutations) {
             exerciseTerminalOps(data, f, s -> s.toArray());
         }
     }

     private List<Function<DoubleStream, DoubleStream>> doubleStatefulOpPermutations =
             LambdaTestHelpers.permuteStreamFunctions(Arrays.asList(
                     s -> s.limit(10),
                     s -> s.distinct(),
                     s -> s.sorted()
             ));

     @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
     public void testDoubleStatefulOpPermutations(String name, TestData.OfDouble data) {
         for (Function<DoubleStream, DoubleStream> f : doubleStatefulOpPermutations) {
             exerciseTerminalOps(data, f, s -> s.toArray());
         }
     }
 }
	/*
	* 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 org.openjdk.tests.java.util.stream;

	import org.testng.annotations.Test;

	import java.util.*;
	import java.util.function.Function;
	import java.util.stream.*;

	import static java.util.stream.LambdaTestHelpers.*;
	import static org.testng.Assert.assertEquals;


	/**
	* ToArrayOpTest
	*
	*/
	@Test
	public class ToArrayOpTest extends OpTestCase {

	public void testToArray() {
	assertCountSum(Arrays.asList(countTo(0).stream().toArray()), 0, 0);
	assertCountSum(Arrays.asList(countTo(10).stream().toArray()), 10, 55);
	}

	@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
	public void testOps(String name, TestData.OfRef<Integer> data) {
	exerciseTerminalOps(data, s -> s.toArray());
	}

	@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
	public void testOpsWithMap(String name, TestData.OfRef<Integer> data) {
	// Retain the size of the source
	// This should kick in the parallel evaluation optimization for tasks stuffing elements into a shared array

	Object[] objects = exerciseTerminalOps(data, s -> s.map(i -> (Integer) (i + i)), s -> s.toArray());
	assertTrue(objects.length == data.size());
	}

	@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
	public void testOpsWithSorted(String name, TestData.OfRef<Integer> data) {
	// Retain the size of the source
	// This should kick in the parallel evaluation optimization for tasks stuffing elements into a shared array

	Object[] objects = exerciseTerminalOps(data, s -> s.sorted(), s -> s.toArray());
	assertTrue(objects.length == data.size());
	}

	@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
	public void testOpsWithFlatMap(String name, TestData.OfRef<Integer> data) {
	// Double the size of the source
	// Fixed size optimizations will not be used

	Object[] objects = exerciseTerminalOps(data,
	s -> s.flatMap(e -> Arrays.stream(new Object[] { e, e })),
	s -> s.toArray());
	assertTrue(objects.length == data.size() * 2);
	}

	@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
	public void testOpsWithFilter(String name, TestData.OfRef<Integer> data) {
	// Reduce the size of the source
	// Fixed size optimizations will not be used

	exerciseTerminalOps(data, s -> s.filter(LambdaTestHelpers.pEven), s -> s.toArray());
	}

	public void testAsArrayWithType() {
	exerciseTerminalOps(
	TestData.Factory.ofCollection("", Arrays.asList(1.1, 2.2, 3.4, 4.4)),
	s -> // First pipeline slice using Object[] with Double elements
	s.sorted()
	// Second pipeline slice using Integer[] with Integer elements
	.map((Double d) -> Integer.valueOf(d.intValue())).sorted(),
	s -> s.toArray(Integer[]::new));
	}

	private List<Function<Stream<Integer>, Stream<Integer>>> uniqueAndSortedPermutations =
	LambdaTestHelpers.permuteStreamFunctions(Arrays.asList(
	s -> s.distinct(),
	s -> s.distinct(),
	s -> s.sorted(),
	s -> s.sorted()
	));

	@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
	public void testDistinctAndSortedPermutations(String name, TestData.OfRef<Integer> data) {
	for (Function<Stream<Integer>, Stream<Integer>> f : uniqueAndSortedPermutations) {
	exerciseTerminalOps(data, f, s -> s.toArray());

	Integer[] is = exerciseTerminalOps(data, f, s -> s.toArray(Integer[]::new));
	assertEquals(is.getClass(), Integer[].class);

	Number[] ns = exerciseTerminalOps(data, f, s -> s.toArray(Number[]::new));
	assertEquals(ns.getClass(), Number[].class);

	if (data.size() > 0) {
	Exception caught = null;
	try {
	exerciseTerminalOps(data, f, s -> s.toArray(String[]::new));
	} catch (Exception e) {
	caught = e;
	}
	assertTrue(caught != null);
	assertEquals(caught.getClass(), ArrayStoreException.class);
	}
	}
	}

	private List<Function<Stream<Integer>, Stream<Integer>>> statefulOpPermutations =
	LambdaTestHelpers.permuteStreamFunctions(Arrays.asList(
	s -> s.limit(10),
	s -> s.distinct(),
	s -> s.sorted()
	));

	private <T extends Object> ResultAsserter<T[]> statefulOpResultAsserter(TestData.OfRef<Integer> data) {
	return (act, exp, ord, par) -> {
	if (par) {
	if (!data.isOrdered()) {
	// Relax the checking if the data source is unordered
	// It is not exactly possible to determine if the limit
	// operation is present and if it is before or after
	// the sorted operation
	// If the limit operation is present and before the sorted
	// operation then the sub-set output after limit is a
	// non-deterministic sub-set of the source
	List<Integer> expected = new ArrayList<>();
	data.forEach(expected::add);

	List<T> actual = Arrays.asList(act);

	assertEquals(actual.size(), exp.length);
	assertTrue(expected.containsAll(actual));
	return;
	}
	else if (!ord) {
	LambdaTestHelpers.assertContentsUnordered(Arrays.asList(act),
	Arrays.asList(exp));
	return;
	}
	}
	assertEquals(act, exp);
	};
	}

	@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class,
	groups = { "serialization-hostile" })
	public void testStatefulOpPermutations(String name, TestData.OfRef<Integer> data) {
	for (Function<Stream<Integer>, Stream<Integer>> f : statefulOpPermutations) {
	withData(data).terminal(f, s -> s.toArray())
	.resultAsserter(statefulOpResultAsserter(data))
	.exercise();

	Integer[] is = withData(data).terminal(f, s -> s.toArray(Integer[]::new))
	.resultAsserter(statefulOpResultAsserter(data))
	.exercise();
	assertEquals(is.getClass(), Integer[].class);

	Number[] ns = withData(data).terminal(f, s -> s.toArray(Number[]::new))
	.resultAsserter(statefulOpResultAsserter(data))
	.exercise();
	assertEquals(ns.getClass(), Number[].class);

	if (data.size() > 0) {
	Exception caught = null;
	try {
	exerciseTerminalOps(data, f, s -> s.toArray(String[]::new));
	} catch (Exception e) {
	caught = e;
	}
	assertTrue(caught != null);
	assertEquals(caught.getClass(), ArrayStoreException.class);
	}
	}
	}

	//

	@Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
	public void testIntOps(String name, TestData.OfInt data) {
	exerciseTerminalOps(data, s -> s.toArray());
	}

	@Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
	public void testIntOpsWithMap(String name, TestData.OfInt data) {
	// Retain the size of the source
	// This should kick in the parallel evaluation optimization for tasks stuffing elements into a shared array

	int[] ints = exerciseTerminalOps(data, s -> s.map(i -> i + i), s -> s.toArray());
	assertTrue(ints.length == data.size());
	}

	@Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
	public void testIntOpsWithSorted(String name, TestData.OfInt data) {
	// Retain the size of the source
	// This should kick in the parallel evaluation optimization for tasks stuffing elements into a shared array

	int[] ints = exerciseTerminalOps(data, s -> s.sorted(), (IntStream s) -> s.toArray());
	assertTrue(ints.length == data.size());
	}

	@Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
	public void testIntOpsWithFlatMap(String name, TestData.OfInt data) {
	// Int the size of the source
	// Fixed size optimizations will not be used

	int[] objects = exerciseTerminalOps(data,
	s -> s.flatMap(e -> Arrays.stream(new int[] { e, e })),
	s -> s.toArray());
	assertTrue(objects.length == data.size() * 2);
	}

	@Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
	public void testIntOpsWithFilter(String name, TestData.OfInt data) {
	// Reduce the size of the source
	// Fixed size optimizations will not be used

	exerciseTerminalOps(data, s -> s.filter(LambdaTestHelpers.ipEven), s -> s.toArray());
	}

	private List<Function<IntStream, IntStream>> intUniqueAndSortedPermutations =
	LambdaTestHelpers.permuteStreamFunctions(Arrays.asList(
	s -> s.distinct(),
	s -> s.distinct(),
	s -> s.sorted(),
	s -> s.sorted()
	));

	@Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
	public void testIntDistinctAndSortedPermutations(String name, TestData.OfInt data) {
	for (Function<IntStream, IntStream> f : intUniqueAndSortedPermutations) {
	exerciseTerminalOps(data, f, s -> s.toArray());
	}
	}

	private List<Function<IntStream, IntStream>> intStatefulOpPermutations =
	LambdaTestHelpers.permuteStreamFunctions(Arrays.asList(
	s -> s.limit(10),
	s -> s.distinct(),
	s -> s.sorted()
	));

	@Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
	public void testIntStatefulOpPermutations(String name, TestData.OfInt data) {
	for (Function<IntStream, IntStream> f : intStatefulOpPermutations) {
	exerciseTerminalOps(data, f, s -> s.toArray());
	}
	}

	//

	@Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
	public void testLongOps(String name, TestData.OfLong data) {
	exerciseTerminalOps(data, s -> s.toArray());
	}

	@Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
	public void testLongOpsWithMap(String name, TestData.OfLong data) {
	// Retain the size of the source
	// This should kick in the parallel evaluation optimization for tasks stuffing elements into a shared array

	long[] longs = exerciseTerminalOps(data, s -> s.map(i -> i + i), s -> s.toArray());
	assertTrue(longs.length == data.size());
	}

	@Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
	public void testLongOpsWithSorted(String name, TestData.OfLong data) {
	// Retain the size of the source
	// This should kick in the parallel evaluation optimization for tasks stuffing elements into a shared array

	long[] longs = exerciseTerminalOps(data, s -> s.sorted(), (LongStream s) -> s.toArray());
	assertTrue(longs.length == data.size());
	}

	@Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
	public void testLongOpsWithFlatMap(String name, TestData.OfLong data) {
	// Long the size of the source
	// Fixed size optimizations will not be used

	long[] objects = exerciseTerminalOps(data,
	s -> s.flatMap(e -> Arrays.stream(new long[] { e, e })),
	s -> s.toArray());
	assertTrue(objects.length == data.size() * 2);
	}

	@Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
	public void testLongOpsWithFilter(String name, TestData.OfLong data) {
	// Reduce the size of the source
	// Fixed size optimizations will not be used

	exerciseTerminalOps(data, s -> s.filter(LambdaTestHelpers.lpEven), s -> s.toArray());
	}

	private List<Function<LongStream, LongStream>> longUniqueAndSortedPermutations =
	LambdaTestHelpers.permuteStreamFunctions(Arrays.asList(
	s -> s.distinct(),
	s -> s.distinct(),
	s -> s.sorted(),
	s -> s.sorted()
	));

	@Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
	public void testLongDistinctAndSortedPermutations(String name, TestData.OfLong data) {
	for (Function<LongStream, LongStream> f : longUniqueAndSortedPermutations) {
	exerciseTerminalOps(data, f, s -> s.toArray());
	}
	}

	private List<Function<LongStream, LongStream>> longStatefulOpPermutations =
	LambdaTestHelpers.permuteStreamFunctions(Arrays.asList(
	s -> s.limit(10),
	s -> s.distinct(),
	s -> s.sorted()
	));

	@Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
	public void testLongStatefulOpPermutations(String name, TestData.OfLong data) {
	for (Function<LongStream, LongStream> f : longStatefulOpPermutations) {
	exerciseTerminalOps(data, f, s -> s.toArray());
	}
	}

	//

	@Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
	public void testDoubleOps(String name, TestData.OfDouble data) {
	exerciseTerminalOps(data, s -> s.toArray());
	}

	@Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
	public void testDoubleOpsWithMap(String name, TestData.OfDouble data) {
	// Retain the size of the source
	// This should kick in the parallel evaluation optimization for tasks stuffing elements into a shared array

	double[] doubles = exerciseTerminalOps(data, s -> s.map(i -> i + i), s -> s.toArray());
	assertTrue(doubles.length == data.size());
	}

	@Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
	public void testDoubleOpsWithSorted(String name, TestData.OfDouble data) {
	// Retain the size of the source
	// This should kick in the parallel evaluation optimization for tasks stuffing elements into a shared array

	double[] doubles = exerciseTerminalOps(data, s -> s.sorted(), (DoubleStream s) -> s.toArray());
	assertTrue(doubles.length == data.size());
	}

	@Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
	public void testDoubleOpsWithFlatMap(String name, TestData.OfDouble data) {
	// Double the size of the source
	// Fixed size optimizations will not be used

	double[] objects = exerciseTerminalOps(data,
	s -> s.flatMap(e -> Arrays.stream(new double[] { e, e })),
	s -> s.toArray());
	assertTrue(objects.length == data.size() * 2);
	}

	@Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
	public void testDoubleOpsWithFilter(String name, TestData.OfDouble data) {
	// Reduce the size of the source
	// Fixed size optimizations will not be used

	exerciseTerminalOps(data, s -> s.filter(LambdaTestHelpers.dpEven), s -> s.toArray());
	}

	private List<Function<DoubleStream, DoubleStream>> doubleUniqueAndSortedPermutations =
	LambdaTestHelpers.permuteStreamFunctions(Arrays.asList(
	s -> s.distinct(),
	s -> s.distinct(),
	s -> s.sorted(),
	s -> s.sorted()
	));

	@Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
	public void testDoubleDistinctAndSortedPermutations(String name, TestData.OfDouble data) {
	for (Function<DoubleStream, DoubleStream> f : doubleUniqueAndSortedPermutations) {
	exerciseTerminalOps(data, f, s -> s.toArray());
	}
	}

	private List<Function<DoubleStream, DoubleStream>> doubleStatefulOpPermutations =
	LambdaTestHelpers.permuteStreamFunctions(Arrays.asList(
	s -> s.limit(10),
	s -> s.distinct(),
	s -> s.sorted()
	));

	@Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
	public void testDoubleStatefulOpPermutations(String name, TestData.OfDouble data) {
	for (Function<DoubleStream, DoubleStream> f : doubleStatefulOpPermutations) {
	exerciseTerminalOps(data, f, s -> s.toArray());
	}
	}
	}