From 0ce912b2415f6e04bf56483608ecc9f6a05aa5b4 Mon Sep 17 00:00:00 2001 From: psandoz Date: Thu, 9 Jan 2014 10:52:35 +0100 Subject: [PATCH] 8031187: DoubleStream.count is incorrect for a stream containing > Integer.MAX_VALUE elements Reviewed-by: darcy --- .../java/util/stream/DoublePipeline.java | 4 +- .../classes/java/util/stream/IntPipeline.java | 4 +- .../java/util/stream/CountLargeTest.java | 70 ++++++++++++++ .../tests/java/util/stream/CountTest.java | 91 +++++++++++++++++++ 4 files changed, 165 insertions(+), 4 deletions(-) create mode 100644 test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountLargeTest.java create mode 100644 test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountTest.java diff --git a/src/share/classes/java/util/stream/DoublePipeline.java b/src/share/classes/java/util/stream/DoublePipeline.java index ff708f6bf..3b6335b77 100644 --- a/src/share/classes/java/util/stream/DoublePipeline.java +++ b/src/share/classes/java/util/stream/DoublePipeline.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2013, 2014, 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 @@ -446,7 +446,7 @@ abstract class DoublePipeline @Override public final long count() { - return mapToObj(e -> null).mapToInt(e -> 1).sum(); + return mapToLong(e -> 1L).sum(); } @Override diff --git a/src/share/classes/java/util/stream/IntPipeline.java b/src/share/classes/java/util/stream/IntPipeline.java index 94dfb7e6c..5c3a8f125 100644 --- a/src/share/classes/java/util/stream/IntPipeline.java +++ b/src/share/classes/java/util/stream/IntPipeline.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 2014, 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 @@ -426,7 +426,7 @@ abstract class IntPipeline @Override public final long count() { - return asLongStream().map(e -> 1L).sum(); + return mapToLong(e -> 1L).sum(); } @Override diff --git a/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountLargeTest.java b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountLargeTest.java new file mode 100644 index 000000000..9b87a09f3 --- /dev/null +++ b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountLargeTest.java @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2014, 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. + */ + +/** + * @test + * @summary Tests counting of streams containing Integer.MAX_VALUE + 1 elements + * @bug 8031187 + */ + +package org.openjdk.tests.java.util.stream; + +import java.util.stream.LongStream; + +import org.testng.annotations.Test; + +import static org.testng.Assert.*; + +@Test +public class CountLargeTest { + + static final long EXPECTED_LARGE_COUNT = 1L + Integer.MAX_VALUE; + + public void testRefLarge() { + long count = LongStream.range(0, EXPECTED_LARGE_COUNT) + .mapToObj(e -> null).count(); + + assertEquals(count, EXPECTED_LARGE_COUNT); + } + + public void testIntLarge() { + long count = LongStream.range(0, EXPECTED_LARGE_COUNT) + .mapToInt(e -> 0).count(); + + assertEquals(count, EXPECTED_LARGE_COUNT); + } + + public void testLongLarge() { + long count = LongStream.range(0, EXPECTED_LARGE_COUNT) + .count(); + + assertEquals(count, EXPECTED_LARGE_COUNT); + } + + public void testDoubleLarge() { + long count = LongStream.range(0, EXPECTED_LARGE_COUNT) + .mapToDouble(e -> 0.0).count(); + + assertEquals(count, EXPECTED_LARGE_COUNT); + } +} diff --git a/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountTest.java b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountTest.java new file mode 100644 index 000000000..5bf2876f3 --- /dev/null +++ b/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountTest.java @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2014, 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. + */ + +/** + * @test + * @summary Tests counting of streams + * @bug 8031187 + */ + +package org.openjdk.tests.java.util.stream; + +import java.util.concurrent.atomic.AtomicLong; +import java.util.stream.DoubleStream; +import java.util.stream.DoubleStreamTestDataProvider; +import java.util.stream.IntStream; +import java.util.stream.IntStreamTestDataProvider; +import java.util.stream.LongStream; +import java.util.stream.LongStreamTestDataProvider; +import java.util.stream.OpTestCase; +import java.util.stream.Stream; +import java.util.stream.StreamTestDataProvider; +import java.util.stream.TestData; + +import org.testng.annotations.Test; + +public class CountTest extends OpTestCase { + + @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class) + public void testOps(String name, TestData.OfRef data) { + AtomicLong expectedCount = new AtomicLong(); + data.stream().forEach(e -> expectedCount.incrementAndGet()); + + withData(data). + terminal(Stream::count). + expectedResult(expectedCount.get()). + exercise(); + } + + @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class) + public void testOps(String name, TestData.OfInt data) { + AtomicLong expectedCount = new AtomicLong(); + data.stream().forEach(e -> expectedCount.incrementAndGet()); + + withData(data). + terminal(IntStream::count). + expectedResult(expectedCount.get()). + exercise(); + } + + @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class) + public void testOps(String name, TestData.OfLong data) { + AtomicLong expectedCount = new AtomicLong(); + data.stream().forEach(e -> expectedCount.incrementAndGet()); + + withData(data). + terminal(LongStream::count). + expectedResult(expectedCount.get()). + exercise(); + } + + @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class) + public void testOps(String name, TestData.OfDouble data) { + AtomicLong expectedCount = new AtomicLong(); + data.stream().forEach(e -> expectedCount.incrementAndGet()); + + withData(data). + terminal(DoubleStream::count). + expectedResult(expectedCount.get()). + exercise(); + } +} -- GitLab