diff --git a/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestDataProvider.java b/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestDataProvider.java index 2ddad65f539..dded670d167 100644 --- a/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestDataProvider.java +++ b/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestDataProvider.java @@ -129,7 +129,6 @@ public class IntStreamTestDataProvider { () -> IntStream.range(0, ints.length).spliterator())); spliterators.add(splitDescr("IntStream.intRangeClosed(0,l):" + name, () -> IntStream.rangeClosed(0, ints.length).spliterator())); - // Need more! } spliteratorTestData = spliterators.toArray(new Object[0][]); diff --git a/jdk/test/java/util/stream/bootlib/java/util/stream/LambdaTestHelpers.java b/jdk/test/java/util/stream/bootlib/java/util/stream/LambdaTestHelpers.java index f1d8ffe81c6..225cbf147f6 100644 --- a/jdk/test/java/util/stream/bootlib/java/util/stream/LambdaTestHelpers.java +++ b/jdk/test/java/util/stream/bootlib/java/util/stream/LambdaTestHelpers.java @@ -269,7 +269,7 @@ public class LambdaTestHelpers { Set uniq = new HashSet<>(); while(iter.hasNext()) { T each = iter.next(); - assertTrue(!uniq.contains(each)); + assertTrue(!uniq.contains(each), "Not unique"); uniq.add(each); } } diff --git a/jdk/test/java/util/stream/bootlib/java/util/stream/LoggingTestCase.java b/jdk/test/java/util/stream/bootlib/java/util/stream/LoggingTestCase.java new file mode 100644 index 00000000000..a0f221929ad --- /dev/null +++ b/jdk/test/java/util/stream/bootlib/java/util/stream/LoggingTestCase.java @@ -0,0 +1,67 @@ +/* + * Copyright (c) 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 java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.testng.Assert; +import org.testng.ITestResult; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +/** + * LoggingTestCase + * + */ +@Test +public class LoggingTestCase extends Assert { + private Map context = new HashMap<>(); + + @BeforeMethod + public void before() { + context.clear(); + } + + @AfterMethod + public void after(ITestResult result) { + if (!result.isSuccess()) { + List list = new ArrayList<>(); + Collections.addAll(list, result.getParameters()); + list.add(context.toString()); + result.setParameters(list.toArray(new Object[list.size()])); + } + } + + protected void setContext(String key, Object value) { + context.put(key, value); + } + + protected void clearContext(String key) { + context.remove(key); + } +} diff --git a/jdk/test/java/util/stream/bootlib/java/util/stream/OpTestCase.java b/jdk/test/java/util/stream/bootlib/java/util/stream/OpTestCase.java index 763b8838b5d..84a574480b5 100644 --- a/jdk/test/java/util/stream/bootlib/java/util/stream/OpTestCase.java +++ b/jdk/test/java/util/stream/bootlib/java/util/stream/OpTestCase.java @@ -50,7 +50,7 @@ import org.testng.annotations.Test; * ways and asserts that they produce equivalent results. */ @Test -public abstract class OpTestCase extends Assert { +public abstract class OpTestCase extends LoggingTestCase { private final Map> testScenarios; @@ -67,6 +67,25 @@ public abstract class OpTestCase extends Assert { return ((AbstractPipeline) s).getStreamFlags(); } + /** + * An asserter for results produced when exercising of stream or terminal + * tests. + * + * @param the type of result to assert on + */ + public interface ResultAsserter { + /** + * Assert a result produced when exercising of stream or terminal + * test. + * + * @param actual the actual result + * @param excepted the expected result + * @param isOrdered true if the pipeline is ordered + * @param isParallel true if the pipeline is parallel + */ + void assertResult(R actual, R excepted, boolean isOrdered, boolean isParallel); + } + // Exercise stream operations public interface BaseStreamTestScenario { @@ -190,14 +209,19 @@ public abstract class OpTestCase extends Assert { Set testSet = new HashSet<>(); Collection refResult; - boolean isOrdered; Consumer> before = LambdaTestHelpers.bEmpty; Consumer> after = LambdaTestHelpers.bEmpty; - BiConsumer, Iterable> sequentialEqualityAsserter = LambdaTestHelpers::assertContentsEqual; - BiConsumer, Iterable> parallelEqualityAsserter = LambdaTestHelpers::assertContentsEqual; + ResultAsserter> resultAsserter = (act, exp, ord, par) -> { + if (par & !ord) { + LambdaTestHelpers.assertContentsUnordered(act, exp); + } + else { + LambdaTestHelpers.assertContentsEqual(act, exp); + } + }; private ExerciseDataStreamBuilder(TestData data, Function m) { this.data = data; @@ -211,10 +235,6 @@ public abstract class OpTestCase extends Assert { testSet.addAll(testScenarios.get(shape)); } - public BiConsumer, Iterable> getEqualityAsserter(BaseStreamTestScenario t) { - return t.isParallel() ? parallelEqualityAsserter : sequentialEqualityAsserter; - } - // public > ExerciseDataStreamBuilder expectedResult(I expectedResult) { @@ -299,29 +319,15 @@ public abstract class OpTestCase extends Assert { return this; } - public ExerciseDataStreamBuilder sequentialEqualityAsserter(BiConsumer, Iterable> equalator) { - this.sequentialEqualityAsserter = equalator; - return this; - } - - public ExerciseDataStreamBuilder parallelEqualityAsserter(BiConsumer, Iterable> equalator) { - this.parallelEqualityAsserter = equalator; + public ExerciseDataStreamBuilder resultAsserter(ResultAsserter> resultAsserter) { + this.resultAsserter = resultAsserter; return this; } // Build method - private long count(StreamShape shape, BaseStream s) { - switch (shape) { - case REFERENCE: return ((Stream) s).count(); - case INT_VALUE: return ((IntStream) s).count(); - case LONG_VALUE: return ((LongStream) s).count(); - case DOUBLE_VALUE: return ((DoubleStream) s).count(); - default: throw new IllegalStateException("Unknown shape: " + shape); - } - } - public Collection exercise() { + final boolean isOrdered; if (refResult == null) { // Induce the reference result before.accept(data); @@ -330,9 +336,10 @@ public abstract class OpTestCase extends Assert { Node refNodeResult = ((AbstractPipeline) sOut).evaluateToArrayNode(size -> (U[]) new Object[size]); refResult = LambdaTestHelpers.toBoxedList(refNodeResult.spliterator()); after.accept(data); - S_OUT anotherCopy = m.apply(data.stream()); - long count = count(((AbstractPipeline) anotherCopy).getOutputShape(), anotherCopy); - assertEquals(count, refNodeResult.count()); + } + else { + S_OUT sOut = m.apply(data.stream()); + isOrdered = StreamOpFlag.ORDERED.isKnown(((AbstractPipeline) sOut).getStreamFlags()); } List errors = new ArrayList<>(); @@ -343,16 +350,20 @@ public abstract class OpTestCase extends Assert { List result = new ArrayList<>(); test.run(data, LambdaTestHelpers.toBoxingConsumer(result::add), m); - Runnable asserter = () -> getEqualityAsserter(test).accept(result, refResult); - if (test.isParallel() && !isOrdered) - asserter = () -> LambdaTestHelpers.assertContentsUnordered(result, refResult); - LambdaTestHelpers.launderAssertion( - asserter, - () -> String.format("%n%s: %s != %s", test, refResult, result)); + Runnable asserter = () -> resultAsserter.assertResult(result, refResult, isOrdered, test.isParallel()); + + if (refResult.size() > 1000) { + LambdaTestHelpers.launderAssertion( + asserter, + () -> String.format("%n%s: [actual size=%d] != [expected size=%d]", test, result.size(), refResult.size())); + } + else { + LambdaTestHelpers.launderAssertion( + asserter, + () -> String.format("%n%s: [actual] %s != [expected] %s", test, result, refResult)); + } after.accept(data); -// } catch (AssertionError ae) { -// errors.add(ae); } catch (Throwable t) { errors.add(new Error(String.format("%s: %s", test, t), t)); } @@ -406,8 +417,7 @@ public abstract class OpTestCase extends Assert { Set testSet = EnumSet.allOf(TerminalTestScenario.class); - Function> sequentialEqualityAsserter = s -> LambdaTestHelpers::assertContentsEqual; - Function> parallelEqualityAsserter = s -> LambdaTestHelpers::assertContentsEqual; + ResultAsserter resultAsserter = (act, exp, ord, par) -> LambdaTestHelpers.assertContentsEqual(act, exp); private ExerciseDataTerminalBuilder(TestData data, Function streamF, Function terminalF) { this.data = data; @@ -423,23 +433,12 @@ public abstract class OpTestCase extends Assert { } public ExerciseDataTerminalBuilder equalator(BiConsumer equalityAsserter) { - this.sequentialEqualityAsserter = s -> equalityAsserter; - this.parallelEqualityAsserter = s -> equalityAsserter; + resultAsserter = (act, exp, ord, par) -> equalityAsserter.accept(act, exp); return this; } - public ExerciseDataTerminalBuilder sequentialEqualityAsserter(BiConsumer equalityAsserter) { - this.sequentialEqualityAsserter = s -> equalityAsserter; - return this; - } - - public ExerciseDataTerminalBuilder parallelEqualityAsserter(BiConsumer equalityAsserter) { - this.parallelEqualityAsserter = s -> equalityAsserter; - return this; - } - - public ExerciseDataTerminalBuilder parallelEqualityAsserter(Function> equalatorProvider) { - this.parallelEqualityAsserter = equalatorProvider; + public ExerciseDataTerminalBuilder resultAsserter(ResultAsserter resultAsserter) { + this.resultAsserter = resultAsserter; return this; } @@ -467,8 +466,9 @@ public abstract class OpTestCase extends Assert { // Build method public R exercise() { - S_OUT out = streamF.apply(data.stream()); + S_OUT out = streamF.apply(data.stream()).sequential(); AbstractPipeline ap = (AbstractPipeline) out; + boolean isOrdered = StreamOpFlag.ORDERED.isKnown(ap.getStreamFlags()); StreamShape shape = ap.getOutputShape(); Node node = ap.evaluateToArrayNode(size -> (U[]) new Object[size]); @@ -481,9 +481,8 @@ public abstract class OpTestCase extends Assert { S_OUT source = (S_OUT) createPipeline(shape, node.spliterator(), StreamOpFlag.IS_ORDERED | StreamOpFlag.IS_SIZED, false); - BiConsumer asserter = sequentialEqualityAsserter.apply(source); R result = terminalF.apply(source); - LambdaTestHelpers.launderAssertion(() -> asserter.accept(refResult, result), + LambdaTestHelpers.launderAssertion(() -> resultAsserter.assertResult(result, refResult, isOrdered, false), () -> String.format("Single sequential: %s != %s", refResult, result)); } @@ -491,11 +490,10 @@ public abstract class OpTestCase extends Assert { S_OUT source = (S_OUT) createPipeline(shape, node.spliterator(), StreamOpFlag.IS_ORDERED | StreamOpFlag.IS_SIZED, false); - // Force short-curcuit + // Force short-circuit source = (S_OUT) chain(source, new ShortCircuitOp(shape)); - BiConsumer asserter = sequentialEqualityAsserter.apply(source); R result = terminalF.apply(source); - LambdaTestHelpers.launderAssertion(() -> asserter.accept(refResult, result), + LambdaTestHelpers.launderAssertion(() -> resultAsserter.assertResult(result, refResult, isOrdered, false), () -> String.format("Single sequential pull: %s != %s", refResult, result)); } @@ -503,44 +501,39 @@ public abstract class OpTestCase extends Assert { S_OUT source = (S_OUT) createPipeline(shape, node.spliterator(), StreamOpFlag.IS_ORDERED | StreamOpFlag.IS_SIZED, true); - BiConsumer asserter = parallelEqualityAsserter.apply(source); R result = terminalF.apply(source); - LambdaTestHelpers.launderAssertion(() -> asserter.accept(refResult, result), + LambdaTestHelpers.launderAssertion(() -> resultAsserter.assertResult(result, refResult, isOrdered, true), () -> String.format("Single parallel: %s != %s", refResult, result)); } if (testSet.contains(TerminalTestScenario.ALL_SEQUENTIAL)) { // This may forEach or tryAdvance depending on the terminal op implementation S_OUT source = streamF.apply(data.stream()); - BiConsumer asserter = sequentialEqualityAsserter.apply(source); R result = terminalF.apply(source); - LambdaTestHelpers.launderAssertion(() -> asserter.accept(refResult, result), + LambdaTestHelpers.launderAssertion(() -> resultAsserter.assertResult(result, refResult, isOrdered, false), () -> String.format("All sequential: %s != %s", refResult, result)); } if (testSet.contains(TerminalTestScenario.ALL_SEQUENTIAL_SHORT_CIRCUIT)) { S_OUT source = streamF.apply(data.stream()); - // Force short-curcuit + // Force short-circuit source = (S_OUT) chain(source, new ShortCircuitOp(shape)); - BiConsumer asserter = sequentialEqualityAsserter.apply(source); R result = terminalF.apply(source); - LambdaTestHelpers.launderAssertion(() -> asserter.accept(refResult, result), + LambdaTestHelpers.launderAssertion(() -> resultAsserter.assertResult(result, refResult, isOrdered, false), () -> String.format("All sequential pull: %s != %s", refResult, result)); } if (testSet.contains(TerminalTestScenario.ALL_PARALLEL)) { S_OUT source = streamF.apply(data.parallelStream()); - BiConsumer asserter = parallelEqualityAsserter.apply(source); R result = terminalF.apply(source); - LambdaTestHelpers.launderAssertion(() -> asserter.accept(refResult, result), + LambdaTestHelpers.launderAssertion(() -> resultAsserter.assertResult(result, refResult, isOrdered, true), () -> String.format("All parallel: %s != %s", refResult, result)); } if (testSet.contains(TerminalTestScenario.ALL_PARALLEL_SEQUENTIAL)) { S_OUT source = streamF.apply(data.parallelStream()); - BiConsumer asserter = parallelEqualityAsserter.apply(source); R result = terminalF.apply(source.sequential()); - LambdaTestHelpers.launderAssertion(() -> asserter.accept(refResult, result), + LambdaTestHelpers.launderAssertion(() -> resultAsserter.assertResult(result, refResult, isOrdered, false), () -> String.format("All parallel then sequential: %s != %s", refResult, result)); } diff --git a/jdk/test/java/util/stream/bootlib/java/util/stream/SpliteratorTestHelper.java b/jdk/test/java/util/stream/bootlib/java/util/stream/SpliteratorTestHelper.java index 8cadf5fd824..7ba82a64616 100644 --- a/jdk/test/java/util/stream/bootlib/java/util/stream/SpliteratorTestHelper.java +++ b/jdk/test/java/util/stream/bootlib/java/util/stream/SpliteratorTestHelper.java @@ -65,7 +65,7 @@ public class SpliteratorTestHelper { } } - testSpliterator(supplier, c -> new BoxingAdapter(c)); + testSpliterator(supplier, BoxingAdapter::new); } public static void testLongSpliterator(Supplier supplier) { @@ -87,7 +87,7 @@ public class SpliteratorTestHelper { } } - testSpliterator(supplier, c -> new BoxingAdapter(c)); + testSpliterator(supplier, BoxingAdapter::new); } public static void testDoubleSpliterator(Supplier supplier) { @@ -109,7 +109,7 @@ public class SpliteratorTestHelper { } } - testSpliterator(supplier, c -> new BoxingAdapter(c)); + testSpliterator(supplier, BoxingAdapter::new); } static > void testSpliterator(Supplier supplier, diff --git a/jdk/test/java/util/stream/boottest/java/util/stream/DoubleNodeTest.java b/jdk/test/java/util/stream/boottest/java/util/stream/DoubleNodeTest.java index 23eee7d749a..c1e8a309e89 100644 --- a/jdk/test/java/util/stream/boottest/java/util/stream/DoubleNodeTest.java +++ b/jdk/test/java/util/stream/boottest/java/util/stream/DoubleNodeTest.java @@ -162,4 +162,18 @@ public class DoubleNodeTest extends OpTestCase { public void testSpliterator(double[] array, Node.OfDouble n) { SpliteratorTestHelper.testDoubleSpliterator(n::spliterator); } + + @Test(dataProvider = "nodes") + public void testTruncate(double[] array, Node.OfDouble n) { + int[] nums = new int[] { 0, 1, array.length / 2, array.length - 1, array.length }; + for (int start : nums) + for (int end : nums) { + if (start < 0 || end < 0 || end < start || end > array.length) + continue; + Node.OfDouble slice = n.truncate(start, end, Double[]::new); + double[] asArray = slice.asPrimitiveArray(); + for (int k = start; k < end; k++) + assertEquals(array[k], asArray[k - start]); + } + } } diff --git a/jdk/test/java/util/stream/boottest/java/util/stream/IntNodeTest.java b/jdk/test/java/util/stream/boottest/java/util/stream/IntNodeTest.java index 17e50bb1e03..e050e63d37b 100644 --- a/jdk/test/java/util/stream/boottest/java/util/stream/IntNodeTest.java +++ b/jdk/test/java/util/stream/boottest/java/util/stream/IntNodeTest.java @@ -160,4 +160,18 @@ public class IntNodeTest extends OpTestCase { public void testSpliterator(int[] array, Node.OfInt n) { SpliteratorTestHelper.testIntSpliterator(n::spliterator); } + + @Test(dataProvider = "nodes") + public void testTruncate(int[] array, Node.OfInt n) { + int[] nums = new int[] { 0, 1, array.length / 2, array.length - 1, array.length }; + for (int start : nums) + for (int end : nums) { + if (start < 0 || end < 0 || end < start || end > array.length) + continue; + Node.OfInt slice = n.truncate(start, end, Integer[]::new); + int[] asArray = slice.asPrimitiveArray(); + for (int k = start; k < end; k++) + assertEquals(array[k], asArray[k - start]); + } + } } diff --git a/jdk/test/java/util/stream/boottest/java/util/stream/LongNodeTest.java b/jdk/test/java/util/stream/boottest/java/util/stream/LongNodeTest.java index 6d1392316ce..d266fd7d04e 100644 --- a/jdk/test/java/util/stream/boottest/java/util/stream/LongNodeTest.java +++ b/jdk/test/java/util/stream/boottest/java/util/stream/LongNodeTest.java @@ -161,4 +161,18 @@ public class LongNodeTest extends OpTestCase { public void testSpliterator(long[] array, Node.OfLong n) { SpliteratorTestHelper.testLongSpliterator(n::spliterator); } + + @Test(dataProvider = "nodes") + public void testTruncate(long[] array, Node.OfLong n) { + int[] nums = new int[] { 0, 1, array.length / 2, array.length - 1, array.length }; + for (int start : nums) + for (int end : nums) { + if (start < 0 || end < 0 || end < start || end > array.length) + continue; + Node.OfLong slice = n.truncate(start, end, Long[]::new); + long[] asArray = slice.asPrimitiveArray(); + for (int k = start; k < end; k++) + assertEquals(array[k], asArray[k - start]); + } + } } diff --git a/jdk/test/java/util/stream/boottest/java/util/stream/NodeTest.java b/jdk/test/java/util/stream/boottest/java/util/stream/NodeTest.java index 8f5bff5cb66..da710033fda 100644 --- a/jdk/test/java/util/stream/boottest/java/util/stream/NodeTest.java +++ b/jdk/test/java/util/stream/boottest/java/util/stream/NodeTest.java @@ -137,4 +137,18 @@ public class NodeTest extends OpTestCase { public void testSpliterator(Integer[] array, Node n) { SpliteratorTestHelper.testSpliterator(n::spliterator); } + + @Test(dataProvider = "nodes") + public void testTruncate(Integer[] array, Node n) { + int[] nums = new int[] { 0, 1, array.length / 2, array.length - 1, array.length }; + for (int start : nums) + for (int end : nums) { + if (start < 0 || end < 0 || end < start || end > array.length) + continue; + Node slice = n.truncate(start, end, Integer[]::new); + Integer[] asArray = slice.asArray(Integer[]::new); + for (int k = start; k < end; k++) + assertEquals(array[k], asArray[k - start]); + } + } } diff --git a/jdk/test/java/util/stream/boottest/java/util/stream/UnorderedTest.java b/jdk/test/java/util/stream/boottest/java/util/stream/UnorderedTest.java index 48b4e7576e1..47eb533d8a2 100644 --- a/jdk/test/java/util/stream/boottest/java/util/stream/UnorderedTest.java +++ b/jdk/test/java/util/stream/boottest/java/util/stream/UnorderedTest.java @@ -184,7 +184,6 @@ public class UnorderedTest extends OpTestCase { UnaryOperator fi = interpose(f, (S s) -> (S) chain(s, checkClearOrderedOp)); withData(data). terminal(fi, terminalF). - without(TerminalTestScenario.ALL_PARALLEL_SEQUENTIAL). equalator(equalityAsserter). exercise(); } @@ -195,7 +194,6 @@ public class UnorderedTest extends OpTestCase { UnaryOperator fi = interpose(f, (S s) -> (S) chain(s, checkSetOrderedOp)); withData(data). terminal(fi, s -> terminalF.apply(s.sequential())). - without(TerminalTestScenario.ALL_PARALLEL_SEQUENTIAL). equalator(equalityAsserter). exercise(); } diff --git a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/DistinctOpTest.java b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/DistinctOpTest.java index cb492f8003a..ddadacc5a1d 100644 --- a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/DistinctOpTest.java +++ b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/DistinctOpTest.java @@ -64,7 +64,6 @@ public class DistinctOpTest extends OpTestCase { node = withData(data). stream(s -> s.unordered().distinct()). - parallelEqualityAsserter(LambdaTestHelpers::assertContentsUnordered). exercise(); assertUnique(node); diff --git a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ForEachOpTest.java b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ForEachOpTest.java index 99f4fdd82f5..d5bb72cda5b 100644 --- a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ForEachOpTest.java +++ b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ForEachOpTest.java @@ -58,6 +58,17 @@ public class ForEachOpTest extends OpTestCase { 55); } + private ResultAsserter> resultAsserter() { + return (act, exp, ord, par) -> { + if (par) { + LambdaTestHelpers.assertContentsUnordered(act, exp); + } + else { + LambdaTestHelpers.assertContents(act, exp); + } + }; + } + @Test public void testForEachOrdered() { List input = countTo(10000); @@ -93,13 +104,13 @@ public class ForEachOpTest extends OpTestCase { // Test head withData(data). terminal(terminalFunc). - parallelEqualityAsserter(LambdaTestHelpers::assertContentsUnordered). + resultAsserter(resultAsserter()). exercise(); // Test multiple stages withData(data). terminal(s -> s.map(LambdaTestHelpers.identity()), terminalFunc). - parallelEqualityAsserter(LambdaTestHelpers::assertContentsUnordered). + resultAsserter(resultAsserter()). exercise(); } @@ -141,13 +152,13 @@ public class ForEachOpTest extends OpTestCase { // Test head withData(data). terminal(terminalFunc). - parallelEqualityAsserter(LambdaTestHelpers::assertContentsUnordered). + resultAsserter(resultAsserter()). exercise(); // Test multiple stages withData(data). terminal(s -> s.map(i -> i), terminalFunc). - parallelEqualityAsserter(LambdaTestHelpers::assertContentsUnordered). + resultAsserter(resultAsserter()). exercise(); } @@ -189,13 +200,13 @@ public class ForEachOpTest extends OpTestCase { // Test head withData(data). terminal(terminalFunc). - parallelEqualityAsserter(LambdaTestHelpers::assertContentsUnordered). + resultAsserter(resultAsserter()). exercise(); // Test multiple stages withData(data). terminal(s -> s.map(i -> i), terminalFunc). - parallelEqualityAsserter(LambdaTestHelpers::assertContentsUnordered). + resultAsserter(resultAsserter()). exercise(); } @@ -237,13 +248,13 @@ public class ForEachOpTest extends OpTestCase { // Test head withData(data). terminal(terminalFunc). - parallelEqualityAsserter(LambdaTestHelpers::assertContentsUnordered). + resultAsserter(resultAsserter()). exercise(); // Test multiple stages withData(data). terminal(s -> s.map(i -> i), terminalFunc). - parallelEqualityAsserter(LambdaTestHelpers::assertContentsUnordered). + resultAsserter(resultAsserter()). exercise(); } diff --git a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/GroupByOpTest.java b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/GroupByOpTest.java index 7c6d6953c18..ce48d27734a 100644 --- a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/GroupByOpTest.java +++ b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/GroupByOpTest.java @@ -133,9 +133,16 @@ public class GroupByOpTest extends OpTestCase { Collector>> tab = Collectors.groupingBy(md.m); Map> result = withData(data) - .terminal(s -> s, s -> s.collect(tab)) - .parallelEqualityAsserter(s -> StreamOpFlagTestHelper.isStreamOrdered(s) ? GroupByOpTest::assertObjectEquals : GroupByOpTest::assertMultiMapEquals) - .exercise(); + .terminal(s -> s, s -> s.collect(tab)) + .resultAsserter((act, exp, ord, par) -> { + if (par & !ord) { + GroupByOpTest.assertMultiMapEquals(act, exp); + } + else { + GroupByOpTest.assertObjectEquals(act, exp); + } + }) + .exercise(); assertEquals(result.keySet().size(), md.expectedSize); } } diff --git a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntSliceOpTest.java b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntSliceOpTest.java index 6521f8b7abd..0d74f487325 100644 --- a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntSliceOpTest.java +++ b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntSliceOpTest.java @@ -145,6 +145,7 @@ public class IntSliceOpTest extends OpTestCase { List skips = sizes(data.size()); for (int s : skips) { + setContext("skip", s); Collection sr = exerciseOps(data, st -> st.substream(s)); assertEquals(sr.size(), sliceSize(data.size(), s)); @@ -159,7 +160,9 @@ public class IntSliceOpTest extends OpTestCase { List limits = skips; for (int s : skips) { + setContext("skip", s); for (int limit : limits) { + setContext("limit", limit); Collection sr = exerciseOps(data, st -> st.substream(s).limit(limit)); assertEquals(sr.size(), sliceSize(sliceSize(data.size(), s), 0, limit)); @@ -174,6 +177,7 @@ public class IntSliceOpTest extends OpTestCase { List limits = sizes(data.size()); for (int limit : limits) { + setContext("limit", limit); Collection sr = exerciseOps(data, st -> st.limit(limit)); assertEquals(sr.size(), sliceSize(data.size(), 0, limit)); @@ -189,6 +193,7 @@ public class IntSliceOpTest extends OpTestCase { @Test(groups = { "serialization-hostile" }) public void testLimitShortCircuit() { for (int l : Arrays.asList(0, 10)) { + setContext("limit", l); AtomicInteger ai = new AtomicInteger(); IntStream.range(1, 101) .peek(i -> ai.getAndIncrement()) diff --git a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntUniqOpTest.java b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntUniqOpTest.java index 8205d4d510d..3ec5d219a23 100644 --- a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntUniqOpTest.java +++ b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntUniqOpTest.java @@ -60,7 +60,6 @@ public class IntUniqOpTest extends OpTestCase { public void testOpSorted(String name, TestData.OfInt data) { Collection result = withData(data). stream(s -> s.sorted().distinct().boxed()). - parallelEqualityAsserter(LambdaTestHelpers::assertContentsUnordered). exercise(); assertUnique(result); diff --git a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MatchOpTest.java b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MatchOpTest.java index 84c43d0a748..e88a8d95e93 100644 --- a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MatchOpTest.java +++ b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MatchOpTest.java @@ -23,19 +23,16 @@ package org.openjdk.tests.java.util.stream; import java.util.Arrays; -import java.util.Collections; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.PrimitiveIterator; +import java.util.Spliterators; import java.util.function.DoublePredicate; -import java.util.function.DoubleSupplier; import java.util.function.Function; import java.util.function.IntPredicate; -import java.util.function.IntSupplier; import java.util.function.LongPredicate; -import java.util.function.LongSupplier; import java.util.function.Predicate; import java.util.function.Supplier; import java.util.stream.DoubleStream; @@ -46,6 +43,7 @@ import java.util.stream.LongStream; import java.util.stream.LongStreamTestDataProvider; import java.util.stream.OpTestCase; import java.util.stream.Stream; +import java.util.stream.StreamSupport; import java.util.stream.StreamTestDataProvider; import java.util.stream.TestData; @@ -97,6 +95,7 @@ public class MatchOpTest extends OpTestCase { private void assertPredicates(List source, Kind kind, Predicate[] predicates, boolean... answers) { for (int i = 0; i < predicates.length; i++) { + setContext("i", i); boolean match = this.kinds().get(kind).apply(predicates[i]).apply(source.stream()); assertEquals(answers[i], match, kind.toString() + predicates[i].toString()); } @@ -119,7 +118,9 @@ public class MatchOpTest extends OpTestCase { @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class) public void testStream(String name, TestData.OfRef data) { for (Predicate p : INTEGER_PREDICATES) { + setContext("p", p); for (Kind kind : Kind.values()) { + setContext("kind", kind); exerciseTerminalOps(data, this.kinds().get(kind).apply(p)); exerciseTerminalOps(data, s -> s.filter(pFalse), this.kinds().get(kind).apply(p)); exerciseTerminalOps(data, s -> s.filter(pEven), this.kinds().get(kind).apply(p)); @@ -128,29 +129,40 @@ public class MatchOpTest extends OpTestCase { } public void testInfinite() { - class CycleSupplier implements Supplier { - final Iterable source; - Iterator i = Collections.emptyIterator(); + class CycleIterator implements Iterator { + final Supplier> source; + Iterator i = null; - CycleSupplier(Iterable source) { + CycleIterator(Supplier> source) { this.source = source; } @Override - public T get() { - if (!i.hasNext()) { - i = source.iterator(); + public Integer next() { + if (i == null || !i.hasNext()) { + i = source.get(); } return i.next(); } + + @Override + public boolean hasNext() { + if (i == null || !i.hasNext()) { + i = source.get(); + } + return i.hasNext(); + } } - assertFalse(Stream.generate(new CycleSupplier<>(Arrays.asList(1, 2, 3, 4))).allMatch(i -> i > 3)); - assertTrue(Stream.generate(new CycleSupplier<>(Arrays.asList(1, 2, 3, 4))).anyMatch(i -> i > 3)); - assertFalse(Stream.generate(new CycleSupplier<>(Arrays.asList(1, 2, 3, 4))).noneMatch(i -> i > 3)); - assertFalse(Stream.generate(new CycleSupplier<>(Arrays.asList(1, 2, 3, 4))).parallel().allMatch(i -> i > 3)); - assertTrue(Stream.generate(new CycleSupplier<>(Arrays.asList(1, 2, 3, 4))).parallel().anyMatch(i -> i > 3)); - assertFalse(Stream.generate(new CycleSupplier<>(Arrays.asList(1, 2, 3, 4))).parallel().noneMatch(i -> i > 3)); + Supplier> source = () -> Arrays.asList(1, 2, 3, 4).iterator(); + Supplier> s = () -> StreamSupport.stream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0)); + + assertFalse(s.get().allMatch(i -> i > 3)); + assertTrue(s.get().anyMatch(i -> i > 3)); + assertFalse(s.get().noneMatch(i -> i > 3)); + assertFalse(s.get().parallel().allMatch(i -> i > 3)); + assertTrue(s.get().parallel().anyMatch(i -> i > 3)); + assertFalse(s.get().parallel().noneMatch(i -> i > 3)); } // @@ -168,6 +180,7 @@ public class MatchOpTest extends OpTestCase { private void assertIntPredicates(Supplier source, Kind kind, IntPredicate[] predicates, boolean... answers) { for (int i = 0; i < predicates.length; i++) { + setContext("i", i); boolean match = intKinds.get(kind).apply(predicates[i]).apply(source.get()); assertEquals(answers[i], match, kind.toString() + predicates[i].toString()); } @@ -189,40 +202,52 @@ public class MatchOpTest extends OpTestCase { @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class) public void testIntStream(String name, TestData.OfInt data) { - for (IntPredicate p : INT_PREDICATES) + for (IntPredicate p : INT_PREDICATES) { + setContext("p", p); for (Kind kind : Kind.values()) { + setContext("kind", kind); exerciseTerminalOps(data, intKinds.get(kind).apply(p)); exerciseTerminalOps(data, s -> s.filter(ipFalse), intKinds.get(kind).apply(p)); exerciseTerminalOps(data, s -> s.filter(ipEven), intKinds.get(kind).apply(p)); } + } } public void testIntInfinite() { - class CycleSupplier implements IntSupplier { + class CycleIterator implements PrimitiveIterator.OfInt { final Supplier source; PrimitiveIterator.OfInt i = null; - CycleSupplier(Supplier source) { + CycleIterator(Supplier source) { this.source = source; } @Override - public int getAsInt() { + public int nextInt() { if (i == null || !i.hasNext()) { i = source.get(); } return i.nextInt(); } + + @Override + public boolean hasNext() { + if (i == null || !i.hasNext()) { + i = source.get(); + } + return i.hasNext(); + } } Supplier source = () -> Arrays.stream(new int[]{1, 2, 3, 4}).iterator(); + Supplier s = () -> StreamSupport.intStream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0)); - assertFalse(IntStream.generate(new CycleSupplier(source)).allMatch(i -> i > 3)); - assertTrue(IntStream.generate(new CycleSupplier(source)).anyMatch(i -> i > 3)); - assertFalse(IntStream.generate(new CycleSupplier(source)).noneMatch(i -> i > 3)); - assertFalse(IntStream.generate(new CycleSupplier(source)).parallel().allMatch(i -> i > 3)); - assertTrue(IntStream.generate(new CycleSupplier(source)).parallel().anyMatch(i -> i > 3)); - assertFalse(IntStream.generate(new CycleSupplier(source)).parallel().noneMatch(i -> i > 3)); + assertFalse(s.get().allMatch(i -> i > 3)); + assertTrue(s.get().anyMatch(i -> i > 3)); + assertFalse(s.get().noneMatch(i -> i > 3)); + assertFalse(s.get().parallel().allMatch(i -> i > 3)); + assertTrue(s.get().parallel().anyMatch(i -> i > 3)); + assertFalse(s.get().parallel().noneMatch(i -> i > 3)); } // @@ -240,6 +265,7 @@ public class MatchOpTest extends OpTestCase { private void assertLongPredicates(Supplier source, Kind kind, LongPredicate[] predicates, boolean... answers) { for (int i = 0; i < predicates.length; i++) { + setContext("i", i); boolean match = longKinds.get(kind).apply(predicates[i]).apply(source.get()); assertEquals(answers[i], match, kind.toString() + predicates[i].toString()); } @@ -261,40 +287,52 @@ public class MatchOpTest extends OpTestCase { @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class) public void testLongStream(String name, TestData.OfLong data) { - for (LongPredicate p : LONG_PREDICATES) + for (LongPredicate p : LONG_PREDICATES) { + setContext("p", p); for (Kind kind : Kind.values()) { + setContext("kind", kind); exerciseTerminalOps(data, longKinds.get(kind).apply(p)); exerciseTerminalOps(data, s -> s.filter(lpFalse), longKinds.get(kind).apply(p)); exerciseTerminalOps(data, s -> s.filter(lpEven), longKinds.get(kind).apply(p)); } + } } public void testLongInfinite() { - class CycleSupplier implements LongSupplier { + class CycleIterator implements PrimitiveIterator.OfLong { final Supplier source; PrimitiveIterator.OfLong i = null; - CycleSupplier(Supplier source) { + CycleIterator(Supplier source) { this.source = source; } @Override - public long getAsLong() { + public long nextLong() { if (i == null || !i.hasNext()) { i = source.get(); } return i.nextLong(); } + + @Override + public boolean hasNext() { + if (i == null || !i.hasNext()) { + i = source.get(); + } + return i.hasNext(); + } } Supplier source = () -> Arrays.stream(new long[]{1, 2, 3, 4}).iterator(); + Supplier s = () -> StreamSupport.longStream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0)); - assertFalse(LongStream.generate(new CycleSupplier(source)).allMatch(i -> i > 3)); - assertTrue(LongStream.generate(new CycleSupplier(source)).anyMatch(i -> i > 3)); - assertFalse(LongStream.generate(new CycleSupplier(source)).noneMatch(i -> i > 3)); - assertFalse(LongStream.generate(new CycleSupplier(source)).parallel().allMatch(i -> i > 3)); - assertTrue(LongStream.generate(new CycleSupplier(source)).parallel().anyMatch(i -> i > 3)); - assertFalse(LongStream.generate(new CycleSupplier(source)).parallel().noneMatch(i -> i > 3)); + assertFalse(s.get().allMatch(i -> i > 3)); + assertTrue(s.get().anyMatch(i -> i > 3)); + assertFalse(s.get().noneMatch(i -> i > 3)); + assertFalse(s.get().parallel().allMatch(i -> i > 3)); + assertTrue(s.get().parallel().anyMatch(i -> i > 3)); + assertFalse(s.get().parallel().noneMatch(i -> i > 3)); } // @@ -312,6 +350,7 @@ public class MatchOpTest extends OpTestCase { private void assertDoublePredicates(Supplier source, Kind kind, DoublePredicate[] predicates, boolean... answers) { for (int i = 0; i < predicates.length; i++) { + setContext("i", i); boolean match = doubleKinds.get(kind).apply(predicates[i]).apply(source.get()); assertEquals(answers[i], match, kind.toString() + predicates[i].toString()); } @@ -333,39 +372,51 @@ public class MatchOpTest extends OpTestCase { @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class) public void testDoubleStream(String name, TestData.OfDouble data) { - for (DoublePredicate p : DOUBLE_PREDICATES) + for (DoublePredicate p : DOUBLE_PREDICATES) { + setContext("p", p); for (Kind kind : Kind.values()) { + setContext("kind", kind); exerciseTerminalOps(data, doubleKinds.get(kind).apply(p)); exerciseTerminalOps(data, s -> s.filter(dpFalse), doubleKinds.get(kind).apply(p)); exerciseTerminalOps(data, s -> s.filter(dpEven), doubleKinds.get(kind).apply(p)); } + } } public void testDoubleInfinite() { - class CycleSupplier implements DoubleSupplier { + class CycleIterator implements PrimitiveIterator.OfDouble { final Supplier source; PrimitiveIterator.OfDouble i = null; - CycleSupplier(Supplier source) { + CycleIterator(Supplier source) { this.source = source; } @Override - public double getAsDouble() { + public double nextDouble() { if (i == null || !i.hasNext()) { i = source.get(); } return i.nextDouble(); } + + @Override + public boolean hasNext() { + if (i == null || !i.hasNext()) { + i = source.get(); + } + return i.hasNext(); + } } Supplier source = () -> Arrays.stream(new double[]{1, 2, 3, 4}).iterator(); + Supplier s = () -> StreamSupport.doubleStream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0)); - assertFalse(DoubleStream.generate(new CycleSupplier(source)).allMatch(i -> i > 3)); - assertTrue(DoubleStream.generate(new CycleSupplier(source)).anyMatch(i -> i > 3)); - assertFalse(DoubleStream.generate(new CycleSupplier(source)).noneMatch(i -> i > 3)); - assertFalse(DoubleStream.generate(new CycleSupplier(source)).parallel().allMatch(i -> i > 3)); - assertTrue(DoubleStream.generate(new CycleSupplier(source)).parallel().anyMatch(i -> i > 3)); - assertFalse(DoubleStream.generate(new CycleSupplier(source)).parallel().noneMatch(i -> i > 3)); + assertFalse(s.get().allMatch(i -> i > 3)); + assertTrue(s.get().anyMatch(i -> i > 3)); + assertFalse(s.get().noneMatch(i -> i > 3)); + assertFalse(s.get().parallel().allMatch(i -> i > 3)); + assertTrue(s.get().parallel().anyMatch(i -> i > 3)); + assertFalse(s.get().parallel().noneMatch(i -> i > 3)); } } diff --git a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/RangeTest.java b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/RangeTest.java index 9109e036f74..1e6b343fc60 100644 --- a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/RangeTest.java +++ b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/RangeTest.java @@ -58,7 +58,9 @@ public class RangeTest extends OpTestCase { public void testIntRange() { // Half-open for (int start : Arrays.asList(1, 10, -1, -10)) { + setContext("start", start); for (int end : Arrays.asList(1, 10, -1, -10)) { + setContext("end", end); int size = (start < end) ? end - start : 0; int[] exp = new int[size]; for (int i = start, p = 0; i < end; i++, p++) { @@ -76,7 +78,9 @@ public class RangeTest extends OpTestCase { // Closed for (int start : Arrays.asList(1, 10, -1, -10)) { + setContext("start", start); for (int end : Arrays.asList(1, 10, -1, -10)) { + setContext("end", end); int size = (start <= end) ? end - start + 1 : 0; int[] exp = new int[size]; for (int i = start, p = 0; i <= end; i++, p++) { @@ -144,7 +148,9 @@ public class RangeTest extends OpTestCase { public void testLongRange() { // Half-open for (long start : Arrays.asList(1, 1000, -1, -1000)) { + setContext("start", start); for (long end : Arrays.asList(1, 1000, -1, -1000)) { + setContext("end", end); long size = start < end ? end - start : 0; long[] exp = new long[(int) size]; for (long i = start, p = 0; i < end; i++, p++) { @@ -162,7 +168,9 @@ public class RangeTest extends OpTestCase { // Closed for (long start : Arrays.asList(1, 1000, -1, -1000)) { + setContext("start", start); for (long end : Arrays.asList(1, 1000, -1, -1000)) { + setContext("end", end); long size = start <= end ? end - start + 1: 0; long[] exp = new long[(int) size]; for (long i = start, p = 0; i <= end; i++, p++) { diff --git a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ReduceByOpTest.java b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ReduceByOpTest.java index 539ed9beada..3fcb4691701 100644 --- a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ReduceByOpTest.java +++ b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ReduceByOpTest.java @@ -51,6 +51,7 @@ public class ReduceByOpTest extends OpTestCase { Map result = data.stream().collect(groupingBy(LambdaTestHelpers.forPredicate(pEven, true, false), reducing(0, rPlus))); assertEquals(result.size(), gbResult.size()); for (Map.Entry entry : result.entrySet()) { + setContext("entry", entry); Boolean key = entry.getKey(); assertEquals(entry.getValue(), data.stream().filter(e -> pEven.test(e) == key).reduce(0, rPlus)); } @@ -59,7 +60,9 @@ public class ReduceByOpTest extends OpTestCase { Map> mgResult = exerciseTerminalOps(data, s -> s.collect(groupingBy(mId))); Map miResult = exerciseTerminalOps(data, s -> s.collect(groupingBy(mId, reducing(0, e -> 1, Integer::sum)))); assertEquals(miResult.keySet().size(), uniqueSize); - for (Map.Entry entry : miResult.entrySet()) + for (Map.Entry entry : miResult.entrySet()) { + setContext("entry", entry); assertEquals((int) entry.getValue(), mgResult.get(entry.getKey()).size()); + } } } diff --git a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SequentialOpTest.java b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SequentialOpTest.java index e74810002fb..793b31daed4 100644 --- a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SequentialOpTest.java +++ b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SequentialOpTest.java @@ -22,13 +22,14 @@ */ package org.openjdk.tests.java.util.stream; +import java.util.Comparators; import java.util.stream.LambdaTestHelpers; import java.util.stream.OpTestCase; import java.util.stream.StreamTestDataProvider; import org.testng.annotations.Test; -import java.util.Comparators; import java.util.Iterator; +import java.util.Comparator; import java.util.concurrent.atomic.AtomicInteger; import java.util.function.Function; import java.util.function.Supplier; @@ -64,8 +65,12 @@ public class SequentialOpTest extends OpTestCase { (UnaryOperator>) s -> s.parallel().map(id).peek(e -> { counter.incrementAndGet(); }).map(id) }; - for (Supplier> supp : suppliers) - for (UnaryOperator> config : configs) { + for (int i = 0; i < suppliers.length; i++) { + setContext("supplierIndex", i); + Supplier> supp = suppliers[i]; + for (int j = 0; j < configs.length; j++) { + setContext("configIndex", j); + UnaryOperator> config = configs[j]; counter.set(0); Stream stream = config.apply(supp.get()); assertEquals(0, counter.get()); @@ -86,6 +91,7 @@ public class SequentialOpTest extends OpTestCase { }); assertTrue(data.size() == 0 || counter.get() > 0); } + } } @SuppressWarnings({"rawtypes", "unchecked"}) @@ -96,7 +102,8 @@ public class SequentialOpTest extends OpTestCase { = new UnaryOperator[] { (UnaryOperator>) s -> s, (UnaryOperator>) s -> s.sequential(), - (UnaryOperator>) s -> s.parallel() + (UnaryOperator>) s -> s.parallel(), + (UnaryOperator>) s -> s.unordered() }; UnaryOperator>[] stuff = new UnaryOperator[] { @@ -107,12 +114,23 @@ public class SequentialOpTest extends OpTestCase { (UnaryOperator>) s -> s.filter(LambdaTestHelpers.pEven).sorted(Comparators.naturalOrder()).map(id), }; - for (UnaryOperator> c1 : changers) - for (UnaryOperator> s1 : stuff) - for (UnaryOperator> c2 : changers) - for (UnaryOperator> s2 : stuff) { + for (int c1Index = 0; c1Index < changers.length; c1Index++) { + setContext("c1Index", c1Index); + UnaryOperator> c1 = changers[c1Index]; + for (int s1Index = 0; s1Index < stuff.length; s1Index++) { + setContext("s1Index", s1Index); + UnaryOperator> s1 = stuff[s1Index]; + for (int c2Index = 0; c2Index < changers.length; c2Index++) { + setContext("c2Index", c2Index); + UnaryOperator> c2 = changers[c2Index]; + for (int s2Index = 0; s2Index < stuff.length; s2Index++) { + setContext("s2Index", s2Index); + UnaryOperator> s2 = stuff[s2Index]; UnaryOperator> composed = s -> s2.apply(c2.apply(s1.apply(c1.apply(s)))); exerciseOps(data, composed); } + } + } + } } } diff --git a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java index 5074ce93c03..ff940035980 100644 --- a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java +++ b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java @@ -26,7 +26,11 @@ import org.testng.annotations.Test; import java.util.*; import java.util.concurrent.atomic.AtomicInteger; -import java.util.stream.Collectors; +import java.util.function.Function; +import java.util.stream.DoubleStream; +import java.util.stream.IntStream; +import java.util.stream.LambdaTestHelpers; +import java.util.stream.LongStream; import java.util.stream.OpTestCase; import java.util.stream.Stream; import java.util.stream.StreamTestDataProvider; @@ -145,19 +149,20 @@ public class SliceOpTest extends OpTestCase { List skips = sizes(data.size()); for (int s : skips) { - Collection sr = exerciseOpsInt(data, - st -> st.substream(s), - st -> st.substream(s), - st -> st.substream(s), - st -> st.substream(s)); - assertEquals(sr.size(), sliceSize(data.size(), s)); + setContext("skip", s); + testSliceMulti(data, + sliceSize(data.size(), s), + st -> st.substream(s), + st -> st.substream(s), + st -> st.substream(s), + st -> st.substream(s)); - sr = exerciseOpsInt(data, - st -> st.substream(s).substream(s / 2), - st -> st.substream(s).substream(s / 2), - st -> st.substream(s).substream(s / 2), - st -> st.substream(s).substream(s / 2)); - assertEquals(sr.size(), sliceSize(sliceSize(data.size(), s), s/2)); + testSliceMulti(data, + sliceSize(sliceSize(data.size(), s), s/2), + st -> st.substream(s).substream(s / 2), + st -> st.substream(s).substream(s / 2), + st -> st.substream(s).substream(s / 2), + st -> st.substream(s).substream(s / 2)); } } @@ -167,20 +172,22 @@ public class SliceOpTest extends OpTestCase { List limits = skips; for (int s : skips) { - for (int limit : limits) { - Collection sr = exerciseOpsInt(data, - st -> st.substream(s).limit(limit), - st -> st.substream(s).limit(limit), - st -> st.substream(s).limit(limit), - st -> st.substream(s).limit(limit)); - assertEquals(sr.size(), sliceSize(sliceSize(data.size(), s), 0, limit)); + setContext("skip", s); + for (int l : limits) { + setContext("limit", l); + testSliceMulti(data, + sliceSize(sliceSize(data.size(), s), 0, l), + st -> st.substream(s).limit(l), + st -> st.substream(s).limit(l), + st -> st.substream(s).limit(l), + st -> st.substream(s).limit(l)); - sr = exerciseOpsInt(data, - st -> st.substream(s, limit+s), - st -> st.substream(s, limit+s), - st -> st.substream(s, limit+s), - st -> st.substream(s, limit+s)); - assertEquals(sr.size(), sliceSize(data.size(), s, limit)); + testSliceMulti(data, + sliceSize(data.size(), s, l), + st -> st.substream(s, l+s), + st -> st.substream(s, l+s), + st -> st.substream(s, l+s), + st -> st.substream(s, l+s)); } } } @@ -189,20 +196,74 @@ public class SliceOpTest extends OpTestCase { public void testLimitOps(String name, TestData.OfRef data) { List limits = sizes(data.size()); - for (int limit : limits) { - Collection sr = exerciseOpsInt(data, - st -> st.limit(limit), - st -> st.limit(limit), - st -> st.limit(limit), - st -> st.limit(limit)); - assertEquals(sr.size(), sliceSize(data.size(), 0, limit)); + for (int l : limits) { + setContext("limit", l); + testSliceMulti(data, + sliceSize(data.size(), 0, l), + st -> st.limit(l), + st -> st.limit(l), + st -> st.limit(l), + st -> st.limit(l)); + } - sr = exerciseOpsInt(data, - st -> st.limit(limit).limit(limit / 2), - st -> st.limit(limit).limit(limit / 2), - st -> st.limit(limit).limit(limit / 2), - st -> st.limit(limit).limit(limit / 2)); - assertEquals(sr.size(), sliceSize(sliceSize(data.size(), 0, limit), 0, limit/2)); + for (int l : limits) { + setContext("limit", l); + testSliceMulti(data, + sliceSize(sliceSize(data.size(), 0, l), 0, l / 2), + st -> st.limit(l).limit(l / 2), + st -> st.limit(l).limit(l / 2), + st -> st.limit(l).limit(l / 2), + st -> st.limit(l).limit(l / 2)); + } + } + + private ResultAsserter> sliceResultAsserter(Iterable data, + int expectedSize) { + return (act, exp, ord, par) -> { + if (par & !ord) { + List expected = new ArrayList<>(); + data.forEach(expected::add); + + List actual = new ArrayList<>(); + act.forEach(actual::add); + + assertEquals(actual.size(), expectedSize); + assertTrue(expected.containsAll(actual)); + } + else { + LambdaTestHelpers.assertContents(act, exp); + } + }; + } + + private void testSliceMulti(TestData.OfRef data, + int expectedSize, + Function, Stream> mRef, + Function mInt, + Function mLong, + Function mDouble) { + + @SuppressWarnings({ "rawtypes", "unchecked" }) + Function, Stream>[] ms = new Function[4]; + ms[0] = mRef; + ms[1] = s -> mInt.apply(s.mapToInt(e -> e)).mapToObj(e -> e); + ms[2] = s -> mLong.apply(s.mapToLong(e -> e)).mapToObj(e -> (int) e); + ms[3] = s -> mDouble.apply(s.mapToDouble(e -> e)).mapToObj(e -> (int) e); + testSliceMulti(data, expectedSize, ms); + } + + @SafeVarargs + private final void testSliceMulti(TestData.OfRef data, + int expectedSize, + Function, Stream>... ms) { + for (int i = 0; i < ms.length; i++) { + setContext("mIndex", i); + Function, Stream> m = ms[i]; + Collection sr = withData(data) + .stream(m) + .resultAsserter(sliceResultAsserter(data, expectedSize)) + .exercise(); + assertEquals(sr.size(), expectedSize); } } @@ -215,6 +276,7 @@ public class SliceOpTest extends OpTestCase { @Test(groups = { "serialization-hostile" }) public void testLimitShortCircuit() { for (int l : Arrays.asList(0, 10)) { + setContext("l", l); AtomicInteger ai = new AtomicInteger(); countTo(100).stream() .peek(i -> ai.getAndIncrement()) @@ -224,18 +286,6 @@ public class SliceOpTest extends OpTestCase { } } - public void testSkipParallel() { - List l = countTo(1000).parallelStream().substream(200).limit(200).sequential().collect(Collectors.toList()); - assertEquals(l.size(), 200); - assertEquals(l.get(l.size() -1).intValue(), 400); - } - - public void testLimitParallel() { - List l = countTo(1000).parallelStream().limit(500).sequential().collect(Collectors.toList()); - assertEquals(l.size(), 500); - assertEquals(l.get(l.size() -1).intValue(), 500); - } - private List sizes(int size) { if (size < 4) { return Arrays.asList(0, 1, 2, 3, 4, 6); diff --git a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamLinkTest.java b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamLinkTest.java index e7629adae88..b4cae8946c9 100644 --- a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamLinkTest.java +++ b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamLinkTest.java @@ -47,6 +47,7 @@ public class StreamLinkTest extends OpTestCase { @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class) public void testManyStreams(String name, TestData.OfRef data) { for (int n : sizes) { + setContext("n", n); List expected = data.stream().map(e -> (Integer) (e + n)).collect(Collectors.toList()); withData(data). @@ -59,6 +60,7 @@ public class StreamLinkTest extends OpTestCase { @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class) public void testIntManyStreams(String name, TestData.OfInt data) { for (int n : sizes) { + setContext("n", n); int[] expected = data.stream().map(e -> e + n).toArray(); withData(data). @@ -71,6 +73,7 @@ public class StreamLinkTest extends OpTestCase { @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class) public void testLongManyStreams(String name, TestData.OfLong data) { for (int n : sizes) { + setContext("n", n); long[] expected = data.stream().map(e -> e + n).toArray(); withData(data). @@ -83,6 +86,7 @@ public class StreamLinkTest extends OpTestCase { @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class) public void testDoubleManyStreams(String name, TestData.OfDouble data) { for (int n : sizes) { + setContext("n", n); double[] expected = data.stream().map(e -> accumulate(e, n)).toArray(); withData(data). diff --git a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamSpliteratorTest.java b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamSpliteratorTest.java index 8a4d502dc2b..bd111cfdb27 100644 --- a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamSpliteratorTest.java +++ b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamSpliteratorTest.java @@ -256,9 +256,14 @@ public class StreamSpliteratorTest extends OpTestCase { s -> s.map(LambdaTestHelpers.identity()).parallel() ); - for (Consumer> terminalOp : terminalOps) { - for (UnaryOperator> intermediateOp : intermediateOps) { - for (boolean proxyEstimateSize : new boolean[]{false, true}) { + for (int i = 0; i < terminalOps.size(); i++) { + setContext("termOpIndex", i); + Consumer> terminalOp = terminalOps.get(i); + for (int j = 0; j < intermediateOps.size(); j++) { + setContext("intOpIndex", j); + UnaryOperator> intermediateOp = intermediateOps.get(j); + for (boolean proxyEstimateSize : new boolean[] {false, true}) { + setContext("proxyEstimateSize", proxyEstimateSize); Spliterator sp = intermediateOp.apply(l.stream()).spliterator(); ProxyNoExactSizeSpliterator psp = new ProxyNoExactSizeSpliterator<>(sp, proxyEstimateSize); Stream s = StreamSupport.parallelStream(psp); @@ -345,9 +350,14 @@ public class StreamSpliteratorTest extends OpTestCase { s -> s.map(i -> i).parallel() ); - for (Consumer terminalOp : terminalOps) { - for (UnaryOperator intermediateOp : intermediateOps) { - for (boolean proxyEstimateSize : new boolean[]{false, true}) { + for (int i = 0; i < terminalOps.size(); i++) { + setContext("termOpIndex", i); + Consumer terminalOp = terminalOps.get(i); + for (int j = 0; j < intermediateOps.size(); j++) { + setContext("intOpIndex", j); + UnaryOperator intermediateOp = intermediateOps.get(j); + for (boolean proxyEstimateSize : new boolean[] {false, true}) { + setContext("proxyEstimateSize", proxyEstimateSize); // Size is assumed to be larger than the target size for no splitting // @@@ Need way to obtain the target size Spliterator.OfInt sp = intermediateOp.apply(IntStream.range(0, 1000)).spliterator(); @@ -433,9 +443,14 @@ public class StreamSpliteratorTest extends OpTestCase { s -> s.map(i -> i).parallel() ); - for (Consumer terminalOp : terminalOps) { - for (UnaryOperator intermediateOp : intermediateOps) { - for (boolean proxyEstimateSize : new boolean[]{false, true}) { + for (int i = 0; i < terminalOps.size(); i++) { + Consumer terminalOp = terminalOps.get(i); + setContext("termOpIndex", i); + for (int j = 0; j < intermediateOps.size(); j++) { + setContext("intOpIndex", j); + UnaryOperator intermediateOp = intermediateOps.get(j); + for (boolean proxyEstimateSize : new boolean[] {false, true}) { + setContext("proxyEstimateSize", proxyEstimateSize); // Size is assumed to be larger than the target size for no splitting // @@@ Need way to obtain the target size Spliterator.OfLong sp = intermediateOp.apply(LongStream.range(0, 1000)).spliterator(); @@ -521,9 +536,14 @@ public class StreamSpliteratorTest extends OpTestCase { s -> s.map(i -> i).parallel() ); - for (Consumer terminalOp : terminalOps) { - for (UnaryOperator intermediateOp : intermediateOps) { - for (boolean proxyEstimateSize : new boolean[]{false, true}) { + for (int i = 0; i < terminalOps.size(); i++) { + Consumer terminalOp = terminalOps.get(i); + setContext("termOpIndex", i); + for (int j = 0; j < intermediateOps.size(); j++) { + UnaryOperator intermediateOp = intermediateOps.get(j); + setContext("intOpIndex", j); + for (boolean proxyEstimateSize : new boolean[] {false, true}) { + setContext("proxyEstimateSize", proxyEstimateSize); // Size is assumed to be larger than the target size for no splitting // @@@ Need way to obtain the target size Spliterator.OfDouble sp = intermediateOp.apply(IntStream.range(0, 1000).asDoubleStream()).spliterator(); diff --git a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java index 2dd8c55016e..b9087415c98 100644 --- a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java +++ b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java @@ -202,26 +202,38 @@ public class TabulatorsTest extends OpTestCase { } } + private ResultAsserter mapTabulationAsserter(boolean ordered) { + return (act, exp, ord, par) -> { + if (par & (!ordered || !ord)) { + TabulatorsTest.nestedMapEqualityAssertion(act, exp); + } + else { + LambdaTestHelpers.assertContentsEqual(act, exp); + } + }; + } + private void exerciseMapTabulation(TestData> data, Collector collector, TabulationAssertion assertion) throws ReflectiveOperationException { - boolean ordered = data.isOrdered() - && !collector.characteristics().contains(Collector.Characteristics.UNORDERED); + boolean ordered = !collector.characteristics().contains(Collector.Characteristics.UNORDERED); + M m = withData(data) .terminal(s -> s.collect(collector)) - .parallelEqualityAsserter(ordered ? LambdaTestHelpers::assertContentsEqual : this::nestedMapEqualityAssertion) + .resultAsserter(mapTabulationAsserter(ordered)) .exercise(); assertion.assertValue(m, () -> data.stream(), ordered); + m = withData(data) .terminal(s -> s.unordered().collect(collector)) - .parallelEqualityAsserter(this::nestedMapEqualityAssertion) + .resultAsserter(mapTabulationAsserter(ordered)) .exercise(); assertion.assertValue(m, () -> data.stream(), false); } - private void nestedMapEqualityAssertion(Object o1, Object o2) { + private static void nestedMapEqualityAssertion(Object o1, Object o2) { if (o1 instanceof Map) { Map m1 = (Map) o1; Map m2 = (Map) o2; diff --git a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ToArrayOpTest.java b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ToArrayOpTest.java index 0971e89fcf1..04475e87260 100644 --- a/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ToArrayOpTest.java +++ b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ToArrayOpTest.java @@ -29,6 +29,7 @@ import java.util.function.Function; import java.util.stream.*; import static java.util.stream.LambdaTestHelpers.*; +import static org.testng.Assert.assertEquals; /** @@ -134,15 +135,51 @@ public class ToArrayOpTest extends OpTestCase { s -> s.sorted() )); + private ResultAsserter statefulOpResultAsserter(TestData.OfRef 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 expected = new ArrayList<>(); + data.forEach(expected::add); + + List 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", dataProviderClass = StreamTestDataProvider.class) public void testStatefulOpPermutations(String name, TestData.OfRef data) { for (Function, Stream> f : statefulOpPermutations) { - exerciseTerminalOps(data, f, s -> s.toArray()); + withData(data).terminal(f, s -> s.toArray()) + .resultAsserter(statefulOpResultAsserter(data)) + .exercise(); - Integer[] is = exerciseTerminalOps(data, f, s -> s.toArray(Integer[]::new)); + Integer[] is = withData(data).terminal(f, s -> s.toArray(Integer[]::new)) + .resultAsserter(statefulOpResultAsserter(data)) + .exercise(); assertEquals(is.getClass(), Integer[].class); - Number[] ns = exerciseTerminalOps(data, f, s -> s.toArray(Number[]::new)); + Number[] ns = withData(data).terminal(f, s -> s.toArray(Number[]::new)) + .resultAsserter(statefulOpResultAsserter(data)) + .exercise(); assertEquals(ns.getClass(), Number[].class); if (data.size() > 0) {