changeset 22111:83c31b33708e

8031187: DoubleStream.count is incorrect for a stream containing > Integer.MAX_VALUE elements Reviewed-by: darcy
author psandoz
date Tue, 07 Jan 2014 11:15:11 +0100
parents 06e486bc20b6
children 4be0c49bc0c5
files jdk/src/share/classes/java/util/stream/DoublePipeline.java jdk/src/share/classes/java/util/stream/IntPipeline.java jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountLargeTest.java jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountTest.java
diffstat 4 files changed, 165 insertions(+), 4 deletions(-) [+]
line wrap: on
line diff
--- a/jdk/src/share/classes/java/util/stream/DoublePipeline.java	Tue Jan 07 09:54:16 2014 +0100
+++ b/jdk/src/share/classes/java/util/stream/DoublePipeline.java	Tue Jan 07 11:15:11 2014 +0100
@@ -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 @@
 
     @Override
     public final long count() {
-        return mapToObj(e -> null).mapToInt(e -> 1).sum();
+        return mapToLong(e -> 1L).sum();
     }
 
     @Override
--- a/jdk/src/share/classes/java/util/stream/IntPipeline.java	Tue Jan 07 09:54:16 2014 +0100
+++ b/jdk/src/share/classes/java/util/stream/IntPipeline.java	Tue Jan 07 11:15:11 2014 +0100
@@ -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 @@
 
     @Override
     public final long count() {
-        return asLongStream().map(e -> 1L).sum();
+        return mapToLong(e -> 1L).sum();
     }
 
     @Override
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountLargeTest.java	Tue Jan 07 11:15:11 2014 +0100
@@ -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 8020016
+ */
+
+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);
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountTest.java	Tue Jan 07 11:15:11 2014 +0100
@@ -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 8020016
+ */
+
+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<Integer>", dataProviderClass = StreamTestDataProvider.class)
+    public void testOps(String name, TestData.OfRef<Integer> 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();
+    }
+}