Merge "Add unit tests for java.util.Calendar"
diff --git a/JavaLibrary.mk b/JavaLibrary.mk
index c9f2bc4..aa43553 100644
--- a/JavaLibrary.mk
+++ b/JavaLibrary.mk
@@ -54,6 +54,7 @@
ojluni/src/main/resources/
test_resource_dirs := $(call all-core-resource-dirs,test)
test_src_files := $(call all-test-java-files-under,dalvik dom harmony-tests json luni xml)
+ojtest_src_files := $(call all-test-java-files-under,ojluni)
ifeq ($(EMMA_INSTRUMENT),true)
ifneq ($(EMMA_INSTRUMENT_STATIC),true)
@@ -326,6 +327,21 @@
include $(BUILD_HOST_DALVIK_JAVA_LIBRARY)
endif
+# Make the core-ojtests library.
+ifeq ($(LIBCORE_SKIP_TESTS),)
+ include $(CLEAR_VARS)
+ LOCAL_SRC_FILES := $(ojtest_src_files)
+ LOCAL_NO_STANDARD_LIBRARIES := true
+ LOCAL_JAVA_LIBRARIES := core-oj-hostdex core-libart-hostdex core-lambda-stubs-hostdex okhttp-hostdex bouncycastle-hostdex
+ LOCAL_STATIC_JAVA_LIBRARIES := testng-hostdex
+ LOCAL_JAVACFLAGS := $(local_javac_flags)
+ LOCAL_MODULE_TAGS := optional
+ LOCAL_JAVA_LANGUAGE_VERSION := 1.8
+ LOCAL_MODULE := core-ojtests-hostdex
+ LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/JavaLibrary.mk
+ include $(BUILD_HOST_DALVIK_JAVA_LIBRARY)
+endif
+
endif # HOST_OS == linux
#
diff --git a/benchmarks/src/benchmarks/regression/FileBenchmark.java b/benchmarks/src/benchmarks/regression/FileBenchmark.java
new file mode 100644
index 0000000..764247d
--- /dev/null
+++ b/benchmarks/src/benchmarks/regression/FileBenchmark.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package benchmarks.regression;
+
+import java.io.File;
+
+public final class FileBenchmark {
+ public void timeFileCreationWithEmptyChild(int nreps) {
+ for (int i = 0; i < nreps; ++i) {
+ new File("/foo", "/");
+ }
+ }
+
+ public void timeFileCreationWithNormalizationNecessary(int nreps) {
+ for (int i = 0; i < nreps; ++i) {
+ new File("/foo//bar//baz//bag", "/baz/");
+ }
+ }
+}
diff --git a/luni/src/main/java/java/util/concurrent/CopyOnWriteArrayList.java b/luni/src/main/java/java/util/concurrent/CopyOnWriteArrayList.java
index 798eaaf..96225b1 100644
--- a/luni/src/main/java/java/util/concurrent/CopyOnWriteArrayList.java
+++ b/luni/src/main/java/java/util/concurrent/CopyOnWriteArrayList.java
@@ -23,6 +23,7 @@
import java.util.AbstractList;
import java.util.Arrays;
import java.util.Collection;
+import java.util.Comparator;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.List;
@@ -30,6 +31,7 @@
import java.util.NoSuchElementException;
import java.util.RandomAccess;
import java.util.function.Consumer;
+import java.util.function.UnaryOperator;
import libcore.util.EmptyArray;
import libcore.util.Objects;
@@ -365,6 +367,49 @@
return removeOrRetain(collection, true, 0, elements.length) != 0;
}
+ @Override
+ public synchronized void replaceAll(UnaryOperator<E> operator) {
+ replaceInRange(0, elements.length,operator);
+ }
+
+ private void replaceInRange(int from, int to, UnaryOperator<E> operator) {
+ java.util.Objects.requireNonNull(operator);
+ Object[] newElements = new Object[elements.length];
+ System.arraycopy(elements, 0, newElements, 0, newElements.length);
+ for (int i = from; i < to; i++) {
+ @SuppressWarnings("unchecked") E e = (E) elements[i];
+ newElements[i] = operator.apply(e);
+ }
+ elements = newElements;
+ }
+
+ @Override
+ public synchronized void sort(Comparator<? super E> c) {
+ sortInRange(0, elements.length, c);
+ }
+
+ private synchronized void sortInRange(int from, int to, Comparator<? super E> c) {
+ java.util.Objects.requireNonNull(c);
+ Object[] newElements = new Object[elements.length];
+ System.arraycopy(elements, 0, newElements, 0, newElements.length);
+ Arrays.sort((E[])newElements, from, to, c);
+ elements = newElements;
+ }
+
+ @Override
+ public void forEach(Consumer<? super E> action) {
+ forInRange(0, elements.length, action);
+ }
+
+ private void forInRange(int from, int to, Consumer<? super E> action) {
+ java.util.Objects.requireNonNull(action);
+ Object[] newElements = new Object[elements.length];
+ System.arraycopy(elements, 0, newElements, 0, newElements.length);
+ for (int i = from; i < to; i++) {
+ action.accept((E)newElements[i]);
+ }
+ }
+
/**
* Removes or retains the elements in {@code collection}. Returns the number
* of elements removed.
@@ -649,6 +694,29 @@
return removed != 0;
}
}
+
+ @Override
+ public void forEach(Consumer<? super E> action) {
+ CopyOnWriteArrayList.this.forInRange(slice.from, slice.to, action);
+ }
+
+ @Override
+ public void replaceAll(UnaryOperator<E> operator) {
+ synchronized (CopyOnWriteArrayList.this) {
+ slice.checkConcurrentModification(elements);
+ CopyOnWriteArrayList.this.replaceInRange(slice.from, slice.to, operator);
+ slice = new Slice(elements, slice.from, slice.to);
+ }
+ }
+
+ @Override
+ public synchronized void sort(Comparator<? super E> c) {
+ synchronized (CopyOnWriteArrayList.this) {
+ slice.checkConcurrentModification(elements);
+ CopyOnWriteArrayList.this.sortInRange(slice.from, slice.to, c);
+ slice = new Slice(elements, slice.from, slice.to);
+ }
+ }
}
static class Slice {
diff --git a/luni/src/test/java/libcore/java/io/FileTest.java b/luni/src/test/java/libcore/java/io/FileTest.java
index 315a603..93b6708 100644
--- a/luni/src/test/java/libcore/java/io/FileTest.java
+++ b/luni/src/test/java/libcore/java/io/FileTest.java
@@ -350,4 +350,21 @@
}
private static native void nativeTestFilesWithSurrogatePairs(String base);
+
+ // http://b/27731686
+ public void testBug27731686() {
+ File file = new File("/test1", "/");
+ assertEquals("/test1", file.getPath());
+ assertEquals("test1", file.getName());
+ }
+
+ public void testFileNameNormalization() {
+ assertEquals("/", new File("/", "/").getPath());
+ assertEquals("/", new File("/", "").getPath());
+ assertEquals("/", new File("", "/").getPath());
+ assertEquals("", new File("", "").getPath());
+
+ assertEquals("/foo/bar", new File("/foo/", "/bar/").getPath());
+ assertEquals("/foo/bar", new File("/foo", "/bar//").getPath());
+ }
}
diff --git a/luni/src/test/java/libcore/java/nio/channels/DatagramChannelTest.java b/luni/src/test/java/libcore/java/nio/channels/DatagramChannelTest.java
index 71c2705..609a990 100644
--- a/luni/src/test/java/libcore/java/nio/channels/DatagramChannelTest.java
+++ b/luni/src/test/java/libcore/java/nio/channels/DatagramChannelTest.java
@@ -157,16 +157,18 @@
public void test_setOption() throws Exception {
DatagramChannel dc = DatagramChannel.open();
- dc.setOption(StandardSocketOptions.SO_SNDBUF, 1024);
+ // There were problems in the past as the number used here was below the minimum for
+ // some platforms (b/27821554). It was increased from 1024 to 4096.
+ dc.setOption(StandardSocketOptions.SO_SNDBUF, 4096);
// Assert that we can read back the option from the channel...
- assertEquals(1024, (int) dc.getOption(StandardSocketOptions.SO_SNDBUF));
+ assertEquals(4096, (int) dc.getOption(StandardSocketOptions.SO_SNDBUF));
// ... and its socket adaptor.
- assertEquals(1024, dc.socket().getSendBufferSize());
+ assertEquals(4096, dc.socket().getSendBufferSize());
dc.close();
try {
- dc.setOption(StandardSocketOptions.SO_SNDBUF, 1024);
+ dc.setOption(StandardSocketOptions.SO_SNDBUF, 4096);
fail();
} catch (ClosedChannelException expected) {
}
diff --git a/luni/src/test/java/libcore/java/text/SimpleDateFormatTest.java b/luni/src/test/java/libcore/java/text/SimpleDateFormatTest.java
index d1ef127..2150b50 100644
--- a/luni/src/test/java/libcore/java/text/SimpleDateFormatTest.java
+++ b/luni/src/test/java/libcore/java/text/SimpleDateFormatTest.java
@@ -423,4 +423,13 @@
} catch (ParseException expected) {
}
}
+
+ // http://b/27760434
+ public void testTimeZoneNotChangedByParse() throws Exception {
+ TimeZone tz = TimeZone.getTimeZone("UTC");
+ SimpleDateFormat df = new SimpleDateFormat("dd MMM yyyy HH:mm:ss zzz");
+ df.setTimeZone(tz);
+ df.parse("22 Jul 1977 12:23:45 HST");
+ assertEquals(tz, df.getTimeZone());
+ }
}
diff --git a/luni/src/test/java/libcore/java/util/ArrayListTest.java b/luni/src/test/java/libcore/java/util/ArrayListTest.java
new file mode 100644
index 0000000..95dd3f3
--- /dev/null
+++ b/luni/src/test/java/libcore/java/util/ArrayListTest.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package libcore.java.util;
+
+import java.util.ArrayList;
+
+public class ArrayListTest extends junit.framework.TestCase {
+ public void test_replaceAll() {
+ ListDefaultMethodTester.test_replaceAll(new ArrayList<>());
+ }
+
+ public void test_sort() {
+ ListDefaultMethodTester.test_sort(new ArrayList<>());
+ }
+}
diff --git a/luni/src/test/java/libcore/java/util/ArraysTest.java b/luni/src/test/java/libcore/java/util/ArraysTest.java
index e0c51a5..e79cb0d 100644
--- a/luni/src/test/java/libcore/java/util/ArraysTest.java
+++ b/luni/src/test/java/libcore/java/util/ArraysTest.java
@@ -37,15 +37,40 @@
try {
Arrays.setAll(list, null);
fail();
- } catch (NullPointerException e) {
- // expected
+ } catch (NullPointerException expected) {
}
try {
Arrays.setAll((int[]) null, (x -> x + 1));
fail();
- } catch (NullPointerException e) {
- // expected
+ } catch (NullPointerException expected) {
+ }
+ }
+
+ /**
+ * java.util.Arrays#parallelSetAll(int[], java.util.function.IntUnaryOperator)
+ */
+ public void test_parallelSetAll$I() {
+ int[] list = new int[3];
+ list[0] = 0;
+ list[1] = 1;
+ list[2] = 2;
+
+ Arrays.parallelSetAll(list, x -> x + 1);
+ assertEquals(1, list[0]);
+ assertEquals(2, list[1]);
+ assertEquals(3, list[2]);
+
+ try {
+ Arrays.parallelSetAll(list, null);
+ fail();
+ } catch (NullPointerException expected) {
+ }
+
+ try {
+ Arrays.parallelSetAll((int[]) null, (x -> x + 1));
+ fail();
+ } catch (NullPointerException expected) {
}
}
@@ -66,15 +91,40 @@
try {
Arrays.setAll(list, null);
fail();
- } catch (NullPointerException e) {
- // expected
+ } catch (NullPointerException expected) {
}
try {
Arrays.setAll((long[]) null, (x -> x + 1));
fail();
- } catch (NullPointerException e) {
- // expected
+ } catch (NullPointerException expected) {
+ }
+ }
+
+ /**
+ * java.util.Arrays#parallelSetAll(long[], java.util.function.IntToLongFunction)
+ */
+ public void test_parallelSetAll$L() {
+ long[] list = new long[3];
+ list[0] = 0;
+ list[1] = 1;
+ list[2] = 2;
+
+ Arrays.parallelSetAll(list, x -> x + 1);
+ assertEquals(1, list[0]);
+ assertEquals(2, list[1]);
+ assertEquals(3, list[2]);
+
+ try {
+ Arrays.parallelSetAll(list, null);
+ fail();
+ } catch (NullPointerException expected) {
+ }
+
+ try {
+ Arrays.parallelSetAll((long[]) null, (x -> x + 1));
+ fail();
+ } catch (NullPointerException expected) {
}
}
@@ -95,15 +145,40 @@
try {
Arrays.setAll(list, null);
fail();
- } catch (NullPointerException e) {
- // expected
+ } catch (NullPointerException expected) {
}
try {
Arrays.setAll((double[]) null, x -> x + 0.5);
fail();
- } catch (NullPointerException e) {
- // expected
+ } catch (NullPointerException expected) {
+ }
+ }
+
+ /**
+ * java.util.Arrays#parallelSetAll(double[], java.util.function.IntToDoubleFunction)
+ */
+ public void test_parallelSetAll$D() {
+ double[] list = new double[3];
+ list[0] = 0.0d;
+ list[1] = 1.0d;
+ list[2] = 2.0d;
+
+ Arrays.parallelSetAll(list, x -> x + 0.5);
+ assertEquals(0.5d, list[0]);
+ assertEquals(1.5d, list[1]);
+ assertEquals(2.5d, list[2]);
+
+ try {
+ Arrays.parallelSetAll(list, null);
+ fail();
+ } catch (NullPointerException expected) {
+ }
+
+ try {
+ Arrays.parallelSetAll((double[]) null, x -> x + 0.5);
+ fail();
+ } catch (NullPointerException expected) {
}
}
@@ -124,15 +199,40 @@
try {
Arrays.setAll(strings, null);
fail();
- } catch (NullPointerException e) {
- // expected
+ } catch (NullPointerException expected) {
}
try {
Arrays.setAll((String[]) null, x -> "a" + x);
fail();
- } catch (NullPointerException e) {
- // expected
+ } catch (NullPointerException expected) {
+ }
+ }
+
+ /**
+ * java.util.Array#parallelSetAll(T[], java.util.function.IntFunction<\? extends T>)
+ */
+ public void test_parallelSetAll$T() {
+ String[] strings = new String[3];
+ strings[0] = "a";
+ strings[0] = "b";
+ strings[0] = "c";
+
+ Arrays.parallelSetAll(strings, x -> "a" + x);
+ assertEquals("a0", strings[0]);
+ assertEquals("a1", strings[1]);
+ assertEquals("a2", strings[2]);
+
+ try {
+ Arrays.parallelSetAll(strings, null);
+ fail();
+ } catch (NullPointerException expected) {
+ }
+
+ try {
+ Arrays.parallelSetAll((String[]) null, x -> "a" + x);
+ fail();
+ } catch (NullPointerException expected) {
}
}
}
diff --git a/luni/src/test/java/libcore/java/util/CollectionsTest.java b/luni/src/test/java/libcore/java/util/CollectionsTest.java
index 1c0cf0f..5f0c47f 100644
--- a/luni/src/test/java/libcore/java/util/CollectionsTest.java
+++ b/luni/src/test/java/libcore/java/util/CollectionsTest.java
@@ -20,10 +20,11 @@
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
-import java.util.ConcurrentModificationException;
import java.util.Enumeration;
+import java.util.HashMap;
import java.util.Iterator;
import java.util.ListIterator;
+import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Spliterator;
@@ -206,4 +207,396 @@
assertEquals(true, sp.tryAdvance(value -> assertEquals("spiff", value)));
assertEquals(false, sp.tryAdvance(value -> fail()));
}
+
+ public void test_unmodifiableMap_getOrDefault() {
+ HashMap<Integer, Double> hashMap = new HashMap<>();
+ hashMap.put(2, 12.0);
+ hashMap.put(3, null);
+ Map<Integer, Double> m = Collections.unmodifiableMap(hashMap);
+ assertEquals(-1.0, m.getOrDefault(1, -1.0));
+ assertEquals(12.0, m.getOrDefault(2, -1.0));
+ assertEquals(null, m.getOrDefault(3, -1.0));
+ }
+
+ public void test_unmodifiableMap_forEach() {
+ Map<Integer, Double> hashMap = new HashMap<>();
+ Map<Integer, Double> replica = new HashMap<>();
+ hashMap.put(1, 10.0);
+ hashMap.put(2, 20.0);
+ Collections.unmodifiableMap(hashMap).forEach(replica::put);
+ assertEquals(10.0, replica.get(1));
+ assertEquals(20.0, replica.get(2));
+ assertEquals(2, replica.size());
+ }
+
+ public void test_unmodifiableMap_putIfAbsent() {
+ try {
+ Collections.unmodifiableMap(new HashMap<>()).putIfAbsent(1, 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+
+ // For existing key
+ HashMap<Integer, Double> m = new HashMap<>();
+ m.put(1, 5.0);
+ try {
+ Collections.unmodifiableMap(m).putIfAbsent(1, 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_unmodifiableMap_remove() {
+ try {
+ Collections.unmodifiableMap(new HashMap<>()).remove(1, 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+
+ // For existing key
+ HashMap<Integer, Double> m = new HashMap<>();
+ m.put(1, 5.0);
+ try {
+ Collections.unmodifiableMap(m).remove(1, 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_unmodifiableMap_replace$K$V$V() {
+ try {
+ Collections.unmodifiableMap(new HashMap<>()).replace(1, 5.0, 1.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+
+ // For existing key
+ HashMap<Integer, Double> m = new HashMap<>();
+ m.put(1, 5.0);
+ try {
+ Collections.unmodifiableMap(m).replace(1, 5.0, 1.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_unmodifiableMap_replace$K$V() {
+ try {
+ Collections.unmodifiableMap(new HashMap<>()).replace(1, 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+
+ // For existing key
+ HashMap<Integer, Double> m = new HashMap<>();
+ m.put(1, 5.0);
+ try {
+ Collections.unmodifiableMap(m).replace(1, 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_unmodifiableMap_computeIfAbsent() {
+ try {
+ Collections.unmodifiableMap(new HashMap<>()).computeIfAbsent(1, k -> 1.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+
+ // For existing key
+ HashMap<Integer, Double> m = new HashMap<>();
+ m.put(1, 5.0);
+ try {
+ Collections.unmodifiableMap(m).computeIfAbsent(1, k -> 1.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_unmodifiableMap_computeIfPresent() {
+ try {
+ Collections.unmodifiableMap(new HashMap<>()).computeIfPresent(1, (k, v) -> 1.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+
+ // For existing key
+ HashMap<Integer, Double> m = new HashMap<>();
+ m.put(1, 5.0);
+ try {
+ Collections.unmodifiableMap(m).computeIfPresent(1, (k, v) -> 1.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_unmodifiableMap_compute() {
+ try {
+ Collections.unmodifiableMap(new HashMap<>()).compute(1, (k, v) -> 1.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+
+ // For existing key
+ HashMap<Integer, Double> m = new HashMap<>();
+ m.put(1, 5.0);
+ try {
+ Collections.unmodifiableMap(m).compute(1, (k, v) -> 1.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_unmodifiableMap_merge() {
+ try {
+ Collections.unmodifiableMap(new HashMap<>()).merge(1, 2.0, (k, v) -> 1.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+
+ // For existing key
+ HashMap<Integer, Double> m = new HashMap<>();
+ m.put(1, 5.0);
+ try {
+ Collections.unmodifiableMap(m).merge(1, 2.0, (k, v) -> 1.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_EmptyMap_getOrDefault() {
+ Map<Integer, Double> m = Collections.emptyMap();
+ assertEquals(-1.0, m.getOrDefault(1, -1.0));
+ assertEquals(-1.0, m.getOrDefault(2, -1.0));
+ }
+
+ public void test_EmptyMap_forEach() {
+ try {
+ Collections.emptyMap().forEach(null);
+ fail();
+ } catch (NullPointerException expected) {
+ }
+ }
+
+ public void test_EmptyMap_putIfAbsent() {
+ try {
+ Collections.emptyMap().putIfAbsent(1, 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_EmptyMap_remove() {
+ try {
+ Collections.emptyMap().remove(1, 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_EmptyMap_replace$K$V$V() {
+ try {
+ Collections.emptyMap().replace(1, 5.0, 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_EmptyMap_replace$K$V() {
+ try {
+ Collections.emptyMap().replace(1, 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_EmptyMap_computeIfAbsent() {
+ try {
+ Collections.emptyMap().computeIfAbsent(1, k -> 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_EmptyMap_computeIfPresent() {
+ try {
+ Collections.emptyMap().computeIfPresent(1, (k, v) -> 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_EmptyMap_compute() {
+ try {
+ Collections.emptyMap().compute(1, (k, v) -> 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_EmptyMap_merge() {
+ try {
+ Collections.emptyMap().merge(1, 5.0, (k, v) -> 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_SingletonMap_getOrDefault() {
+ Map<Integer, Double> m = Collections.singletonMap(1, 11.0);
+ assertEquals(11.0, m.getOrDefault(1, -1.0));
+ assertEquals(-1.0, m.getOrDefault(2, -1.0));
+ }
+
+ public void test_SingletonMap_forEach() {
+ Map<Integer, Double> m = new HashMap<>();
+ Collections.singletonMap(1, 11.0).forEach(m::put);
+ assertEquals(11.0, m.getOrDefault(1, -1.0));
+ assertEquals(1, m.size());
+ }
+
+ public void test_SingletonMap_putIfAbsent() {
+ try {
+ Collections.singletonMap(1, 11.0).putIfAbsent(1, 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_SingletonMap_remove() {
+ try {
+ Collections.singletonMap(1, 11.0).remove(1, 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_SingletonMap_replace$K$V$V() {
+ try {
+ Collections.singletonMap(1, 11.0).replace(1, 5.0, 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_SingletonMap_replace$K$V() {
+ try {
+ Collections.singletonMap(1, 11.0).replace(1, 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_SingletonMap_computeIfAbsent() {
+ try {
+ Collections.singletonMap(1, 11.0).computeIfAbsent(1, k -> 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_SingletonMap_computeIfPresent() {
+ try {
+ Collections.singletonMap(1, 11.0).computeIfPresent(1, (k, v) -> 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_SingletonMap_compute() {
+ try {
+ Collections.singletonMap(1, 11.0).compute(1, (k, v) -> 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_SingletonMap_merge() {
+ try {
+ Collections.singletonMap(1, 11.0).merge(1, 5.0, (k, v) -> 5.0);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_SynchronizedList_replaceAll() {
+ ListDefaultMethodTester.test_replaceAll(Collections.synchronizedList(new ArrayList<>()));
+ }
+
+ public void test_SynchronizedList_sort() {
+ ListDefaultMethodTester.test_sort(Collections.synchronizedList(new ArrayList<>()));
+ }
+
+ public void test_CheckedList_replaceAll() {
+ ListDefaultMethodTester.test_replaceAll(Collections.checkedList(new ArrayList<>(), Integer.class));
+ }
+
+ public void test_CheckedList_sort() {
+ ListDefaultMethodTester.test_sort(Collections.checkedList(new ArrayList<>(), Integer.class));
+ }
+
+ public void test_EmptyList_replaceAll() {
+ Collections.emptyList().replaceAll(k -> 1);
+
+ try {
+ Collections.emptyList().replaceAll(null);
+ fail();
+ } catch (NullPointerException expected) {
+ }
+ }
+
+ public void test_EmptyList_sort() {
+ Collections.emptyList().sort((k1, k2) -> 1);
+ }
+
+ public void test_unmodifiableList_replaceAll() {
+ try {
+ Collections.unmodifiableList(new ArrayList<>()).replaceAll(k -> 1);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+
+ // with non empty list
+
+ try {
+ ArrayList l = new ArrayList();
+ l.add(1);
+ l.add(2);
+ Collections.unmodifiableList(l).replaceAll(k -> 1);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_unmodifiableList_sort() {
+ try {
+ Collections.unmodifiableList(new ArrayList<>()).sort((k1, k2) -> 1);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+
+ // with non empty list
+
+ try {
+ ArrayList l = new ArrayList();
+ l.add(1);
+ l.add(2);
+ Collections.unmodifiableList(l).sort((k1, k2) -> 1);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_SingletonList_replaceAll() {
+ try {
+ Collections.singletonList(1).replaceAll(k -> 2);
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+
+ public void test_SingletonList_sort() {
+ Collections.singletonList(1).sort((k1, k2) -> 2);
+ }
}
diff --git a/luni/src/test/java/libcore/java/util/ConcurrentHashMapTest.java b/luni/src/test/java/libcore/java/util/ConcurrentHashMapTest.java
new file mode 100644
index 0000000..74d8473
--- /dev/null
+++ b/luni/src/test/java/libcore/java/util/ConcurrentHashMapTest.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package libcore.java.util;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+public class ConcurrentHashMapTest extends junit.framework.TestCase {
+
+ public void test_getOrDefault() {
+ MapDefaultMethodTester.test_getOrDefault(new ConcurrentHashMap<>(),
+ false /*doesNotAcceptNullKey*/, false /*doesNotAcceptNullValue*/);
+ }
+
+ public void test_forEach() {
+ MapDefaultMethodTester.test_forEach(new ConcurrentHashMap<>());
+ }
+
+ public void test_putIfAbsent() {
+ MapDefaultMethodTester
+ .test_putIfAbsent(new ConcurrentHashMap<>(), false /*doesNotAcceptNullKey*/,
+ false /*doesNotAcceptNullValue*/);
+ }
+
+ public void test_remove() {
+ MapDefaultMethodTester
+ .test_remove(new ConcurrentHashMap<>(), false /*doesNotAcceptNullKey*/,
+ false /*doesNotAcceptNullValue*/);
+ }
+
+ public void test_replace$K$V$V() {
+ MapDefaultMethodTester
+ .test_replace$K$V$V(new ConcurrentHashMap<>(), false /*doesNotAcceptNullKey*/,
+ false /*doesNotAcceptNullValue*/);
+ }
+
+ public void test_replace$K$V() {
+ MapDefaultMethodTester.test_replace$K$V(new ConcurrentHashMap<>(),
+ false /*doesNotAcceptNullKey*/, false /*doesNotAcceptNullValue*/);
+ }
+
+ public void test_computeIfAbsent() {
+ MapDefaultMethodTester.test_computeIfAbsent(new ConcurrentHashMap<>(),
+ false /*doesNotAcceptNullKey*/, false /*doesNotAcceptNullValue*/);
+ }
+
+ public void test_computeIfPresent() {
+ MapDefaultMethodTester.test_computeIfPresent(new ConcurrentHashMap<>(),
+ false /*doesNotAcceptNullKey*/);
+ }
+
+ public void test_compute() {
+ MapDefaultMethodTester
+ .test_compute(new ConcurrentHashMap<>(), false /*doesNotAcceptNullKey*/);
+ }
+
+ public void test_merge() {
+ MapDefaultMethodTester.test_merge(new ConcurrentHashMap<>(),
+ false /*doesNotAcceptNullKey*/);
+ }
+}
diff --git a/luni/src/test/java/libcore/java/util/HashMapTest.java b/luni/src/test/java/libcore/java/util/HashMapTest.java
new file mode 100644
index 0000000..5aecbb3
--- /dev/null
+++ b/luni/src/test/java/libcore/java/util/HashMapTest.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package libcore.java.util;
+
+import java.util.HashMap;
+
+public class HashMapTest extends junit.framework.TestCase {
+
+ public void test_getOrDefault() {
+ MapDefaultMethodTester.test_getOrDefault(new HashMap<>(), true /*acceptsNullKey*/,
+ true /*acceptsNullValue*/);
+ }
+
+ public void test_forEach() {
+ MapDefaultMethodTester.test_forEach(new HashMap<>());
+ }
+
+ public void test_putIfAbsent() {
+ MapDefaultMethodTester.test_putIfAbsent(new HashMap<>(), true /*acceptsNullKey*/,
+ true /*acceptsNullValue*/);
+ }
+
+ public void test_remove() {
+ MapDefaultMethodTester
+ .test_remove(new HashMap<>(), true /*acceptsNullKey*/, true /*acceptsNullValue*/);
+ }
+
+ public void test_replace$K$V$V() {
+ MapDefaultMethodTester
+ .test_replace$K$V$V(new HashMap<>(), true /*acceptsNullKey*/,
+ true /*acceptsNullValue*/);
+ }
+
+ public void test_replace$K$V() {
+ MapDefaultMethodTester.test_replace$K$V(new HashMap<>(), true /*acceptsNullKey*/,
+ true /*acceptsNullValue*/);
+ }
+
+ public void test_computeIfAbsent() {
+ MapDefaultMethodTester.test_computeIfAbsent(new HashMap<>(), true /*acceptsNullKey*/,
+ true /*acceptsNullValue*/);
+ }
+
+ public void test_computeIfPresent() {
+ MapDefaultMethodTester.test_computeIfPresent(new HashMap<>(), true /*acceptsNullKey*/);
+ }
+
+ public void test_compute() {
+ MapDefaultMethodTester
+ .test_compute(new HashMap<>(), true /*acceptsNullKey*/);
+ }
+
+ public void test_merge() {
+ MapDefaultMethodTester
+ .test_merge(new HashMap<>(), true /*acceptsNullKey*/);
+ }
+}
diff --git a/luni/src/test/java/libcore/java/util/HashtableTest.java b/luni/src/test/java/libcore/java/util/HashtableTest.java
new file mode 100644
index 0000000..28aa662
--- /dev/null
+++ b/luni/src/test/java/libcore/java/util/HashtableTest.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package libcore.java.util;
+
+import java.util.Hashtable;
+import java.util.Map;
+
+public class HashtableTest extends junit.framework.TestCase {
+
+ public void test_getOrDefault() {
+ MapDefaultMethodTester.test_getOrDefault(new Hashtable<>(), false /*doesNotAcceptNullKey*/,
+ false /*doesNotAcceptNullValue*/);
+ }
+
+ public void test_forEach() {
+ MapDefaultMethodTester.test_forEach(new Hashtable<>());
+ }
+
+ public void test_putIfAbsent() {
+ MapDefaultMethodTester.test_putIfAbsent(new Hashtable<>(), false /*doesNotAcceptNullKey*/,
+ false /*doesNotAcceptNullValue*/);
+ }
+
+ public void test_remove() {
+ MapDefaultMethodTester.test_remove(new Hashtable<>(), false /*doesNotAcceptNullKey*/,
+ false /*doesNotAcceptNullValue*/);
+ }
+
+ public void test_replace$K$V$V() {
+ MapDefaultMethodTester.
+ test_replace$K$V$V(new Hashtable<>(), false /*doesNotAcceptNullKey*/,
+ false /*doesNotAcceptNullValue*/);
+ }
+
+ public void test_replace$K$V() {
+ MapDefaultMethodTester.test_replace$K$V(new Hashtable<>(), false /*doesNotAcceptNullKey*/,
+ false /*doesNotAcceptNullValue*/);
+ }
+
+ public void test_computeIfAbsent() {
+ MapDefaultMethodTester.test_computeIfAbsent(new Hashtable<>(),
+ false /*doesNotAcceptNullKey*/, false /*doesNotAcceptNullValue*/);
+ }
+
+ public void test_computeIfPresent() {
+ MapDefaultMethodTester.test_computeIfPresent(new Hashtable<>(),
+ false /*doesNotAcceptNullKey*/);
+ }
+
+ public void test_compute() {
+ MapDefaultMethodTester.test_compute(new Hashtable<>(), false /*doesNotAcceptNullKey*/);
+ }
+
+ public void test_merge() {
+ MapDefaultMethodTester.test_merge(new Hashtable<>(), false /*doesNotAcceptNullKey*/);
+ }
+}
diff --git a/luni/src/test/java/libcore/java/util/LinkedHashMapTest.java b/luni/src/test/java/libcore/java/util/LinkedHashMapTest.java
new file mode 100644
index 0000000..c7de1f6
--- /dev/null
+++ b/luni/src/test/java/libcore/java/util/LinkedHashMapTest.java
@@ -0,0 +1,208 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package libcore.java.util;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class LinkedHashMapTest extends junit.framework.TestCase {
+
+ public void test_getOrDefault() {
+ MapDefaultMethodTester
+ .test_getOrDefault(new LinkedHashMap<>(), true /*acceptsNullKey*/,
+ true /*acceptsNullValue*/);
+
+ // Test for access order
+ Map<String, String> m = new LinkedHashMap<String, String>(8, .75f, true);
+ m.put("key", "value");
+ m.put("key1", "value1");
+ m.put("key2", "value2");
+ m.getOrDefault("key1", "value");
+ Map.Entry<String, String> newest = null;
+ for (Map.Entry<String, String> e : m.entrySet()) {
+ newest = e;
+ }
+ assertEquals("key1", newest.getKey());
+ assertEquals("value1", newest.getValue());
+ }
+
+ public void test_forEach() {
+ MapDefaultMethodTester.test_forEach(new LinkedHashMap<>());
+ }
+
+ public void test_putIfAbsent() {
+ MapDefaultMethodTester.test_putIfAbsent(new LinkedHashMap<>(), true /*acceptsNullKey*/,
+ true /*acceptsNullValue*/);
+
+ // Test for access order
+ Map<String, String> m = new LinkedHashMap<String, String>(8, .75f, true);
+ m.putIfAbsent("key", "value");
+ m.putIfAbsent("key1", "value1");
+ m.putIfAbsent("key2", "value2");
+ Map.Entry<String, String> newest = null;
+ for (Map.Entry<String, String> e : m.entrySet()) {
+ newest = e;
+ }
+ assertEquals("key2", newest.getKey());
+ assertEquals("value2", newest.getValue());
+
+ // for existed key
+ m.putIfAbsent("key1", "value1");
+ for (Map.Entry<String, String> e : m.entrySet()) {
+ newest = e;
+ }
+ assertEquals("key1", newest.getKey());
+ assertEquals("value1", newest.getValue());
+ }
+
+ public void test_remove() {
+ MapDefaultMethodTester.test_remove(new LinkedHashMap<>(), true /*acceptsNullKey*/,
+ true /*acceptsNullValue*/);
+ }
+
+ public void test_replace$K$V$V() {
+ MapDefaultMethodTester.
+ test_replace$K$V$V(new LinkedHashMap<>(), true /*acceptsNullKey*/,
+ true /*acceptsNullValue*/);
+
+ // Test for access order
+ Map<String, String> m = new LinkedHashMap<>(8, .75f, true /*accessOrder*/);
+ m.put("key", "value");
+ m.put("key1", "value1");
+ m.put("key2", "value2");
+ m.replace("key1", "value1", "value2");
+ Map.Entry<String, String> newest = null;
+ for (Map.Entry<String, String> e : m.entrySet()) {
+ newest = e;
+ }
+ assertEquals("key1", newest.getKey());
+ assertEquals("value2", newest.getValue());
+
+ // for wrong pair of key and value, last accessed node should
+ // not change
+ m.replace("key2", "value1", "value3");
+ for (Map.Entry<String, String> e : m.entrySet()) {
+ newest = e;
+ }
+ assertEquals("key1", newest.getKey());
+ assertEquals("value2", newest.getValue());
+ }
+
+ public void test_replace$K$V() {
+ MapDefaultMethodTester.test_replace$K$V(new LinkedHashMap<>(), true /*acceptsNullKey*/,
+ true /*acceptsNullValue*/);
+
+ // Test for access order
+ Map<String, String> m = new LinkedHashMap<>(8, .75f, true /*accessOrder*/);
+ m.put("key", "value");
+ m.put("key1", "value1");
+ m.put("key2", "value2");
+ m.replace("key1", "value2");
+ Map.Entry<String, String> newest = null;
+ for (Map.Entry<String, String> e : m.entrySet()) {
+ newest = e;
+ }
+ assertEquals("key1", newest.getKey());
+ assertEquals("value2", newest.getValue());
+ }
+
+ public void test_computeIfAbsent() {
+ MapDefaultMethodTester.test_computeIfAbsent(new LinkedHashMap<>(), true /*acceptsNullKey*/,
+ true /*acceptsNullValue*/);
+
+ // Test for access order
+ Map<String, String> m = new LinkedHashMap<>(8, .75f, true /*accessOrder*/);
+ m.put("key", "value");
+ m.put("key1", "value1");
+ m.put("key2", "value2");
+ m.computeIfAbsent("key1", (k) -> "value3");
+ Map.Entry<String, String> newest = null;
+ for (Map.Entry<String, String> e : m.entrySet()) {
+ newest = e;
+ }
+ assertEquals("key1", newest.getKey());
+ assertEquals("value1", newest.getValue());
+
+ // When value is absent
+ m.computeIfAbsent("key4", (k) -> "value3");
+ newest = null;
+ for (Map.Entry<String, String> e : m.entrySet()) {
+ newest = e;
+ }
+ assertEquals("key4", newest.getKey());
+ assertEquals("value3", newest.getValue());
+ }
+
+ public void test_computeIfPresent() {
+ MapDefaultMethodTester.test_computeIfPresent(new LinkedHashMap<>(), true /*acceptsNullKey*/);
+
+ // Test for access order
+ Map<String, String> m = new LinkedHashMap<>(8, .75f, true /*accessOrder*/);
+ m.put("key", "value");
+ m.put("key1", "value1");
+ m.put("key2", "value2");
+ m.computeIfPresent("key1", (k, v) -> "value3");
+ Map.Entry<String, String> newest = null;
+ for (Map.Entry<String, String> e : m.entrySet()) {
+ newest = e;
+ }
+ assertEquals("key1", newest.getKey());
+ assertEquals("value3", newest.getValue());
+ }
+
+ public void test_compute() {
+ MapDefaultMethodTester.test_compute(new LinkedHashMap<>(), true /*acceptsNullKey*/);
+
+ // Test for access order
+ Map<String, String> m = new LinkedHashMap<>(8, .75f, true /*accessOrder*/);
+ m.put("key", "value");
+ m.put("key1", "value1");
+ m.put("key2", "value2");
+ m.compute("key1", (k, v) -> "value3");
+ Map.Entry<String, String> newest = null;
+ for (Map.Entry<String, String> e : m.entrySet()) {
+ newest = e;
+ }
+ assertEquals("key1", newest.getKey());
+ assertEquals("value3", newest.getValue());
+
+ m.compute("key4", (k, v) -> "value4");
+ newest = null;
+ for (Map.Entry<String, String> e : m.entrySet()) {
+ newest = e;
+ }
+ assertEquals("key4", newest.getKey());
+ assertEquals("value4", newest.getValue());
+ }
+
+ public void test_merge() {
+ MapDefaultMethodTester.test_merge(new LinkedHashMap<>(), true /*acceptsNullKey*/);
+
+ // Test for access order
+ Map<String, String> m = new LinkedHashMap<>(8, .75f, true /*accessOrder*/);
+ m.put("key", "value");
+ m.put("key1", "value1");
+ m.put("key2", "value2");
+ m.merge("key1", "value3", (k, v) -> "value3");
+ Map.Entry<String, String> newest = null;
+ for (Map.Entry<String, String> e : m.entrySet()) {
+ newest = e;
+ }
+ assertEquals("key1", newest.getKey());
+ assertEquals("value3", newest.getValue());
+ }
+}
diff --git a/luni/src/test/java/libcore/java/util/ListDefaultMethodTester.java b/luni/src/test/java/libcore/java/util/ListDefaultMethodTester.java
new file mode 100644
index 0000000..3caae60
--- /dev/null
+++ b/luni/src/test/java/libcore/java/util/ListDefaultMethodTester.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package libcore.java.util;
+
+import java.util.List;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.fail;
+
+public class ListDefaultMethodTester {
+
+ public static void test_replaceAll(List<Integer> l) {
+ l.add(5);
+ l.add(2);
+ l.add(-3);
+ l.replaceAll(v -> v * 2);
+ assertEquals((Integer)10, l.get(0));
+ assertEquals((Integer)4, l.get(1));
+ assertEquals((Integer)(-6), l.get(2));
+
+ try {
+ l.replaceAll(null);
+ fail();
+ } catch (NullPointerException expected) {}
+ }
+
+ public static void test_sort(List<Double> l) {
+ l.add(5.0);
+ l.add(2.0);
+ l.add(-3.0);
+ l.sort((v1, v2) -> v1.compareTo(v2));
+ assertEquals(-3.0, l.get(0));
+ assertEquals(2.0, l.get(1));
+ assertEquals(5.0, l.get(2));
+ }
+}
diff --git a/luni/src/test/java/libcore/java/util/ListTest.java b/luni/src/test/java/libcore/java/util/ListTest.java
new file mode 100644
index 0000000..ea2ae3c
--- /dev/null
+++ b/luni/src/test/java/libcore/java/util/ListTest.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package libcore.java.util;
+
+import java.util.LinkedList;
+
+public class ListTest extends junit.framework.TestCase {
+
+ // LinkedList uses the List's default methods
+ public void test_replaceAll() {
+ ListDefaultMethodTester.test_replaceAll(new LinkedList<>());
+ }
+
+ // LinkedList uses the List's default methods
+ public void test_sort() {
+ ListDefaultMethodTester.test_sort(new LinkedList<>());
+ }
+}
diff --git a/luni/src/test/java/libcore/java/util/MapDefaultMethodTester.java b/luni/src/test/java/libcore/java/util/MapDefaultMethodTester.java
new file mode 100644
index 0000000..e3c4ad1
--- /dev/null
+++ b/luni/src/test/java/libcore/java/util/MapDefaultMethodTester.java
@@ -0,0 +1,354 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package libcore.java.util;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertTrue;
+import static junit.framework.Assert.assertNull;
+import static junit.framework.Assert.fail;
+
+public class MapDefaultMethodTester {
+
+ private MapDefaultMethodTester() {}
+
+ public static void test_getOrDefault(Map<Integer, Double> m, boolean acceptsNullKey,
+ boolean acceptsNullValue) {
+ // Unmapped key
+ assertEquals(-1.0, m.getOrDefault(1, -1.0));
+
+ // Mapped key
+ m.put(1, 11.0);
+ assertEquals(11.0, m.getOrDefault(1, -1.0));
+
+ // Check for null value
+ if (acceptsNullValue) {
+ m.put(1, null);
+ assertEquals(null, m.getOrDefault(1, -1.0));
+ }
+
+ // Check for null key
+ if (acceptsNullKey) {
+ m.put(null, 1.0);
+ assertEquals(1.0, m.getOrDefault(null, -1.0));
+ }
+ }
+
+ public static void test_forEach(Map<Integer, Double> m) {
+ Map<Integer, Double> replica = new HashMap<>();
+ m.put(1, 10.0);
+ m.put(2, 20.0);
+ m.forEach(replica::put);
+ assertEquals(10.0, replica.get(1));
+ assertEquals(20.0, replica.get(2));
+ assertEquals(2, replica.size());
+
+ // Null pointer exception for empty function
+ try {
+ m.forEach(null);
+ } catch (NullPointerException expected) {
+ }
+ }
+
+ public static void test_putIfAbsent(Map<Integer, Double> m, boolean acceptsNullKey,
+ boolean acceptsNullValue) {
+ // For unmapped key
+ assertNull(m.putIfAbsent(1, 1.0));
+ assertEquals(1.0, m.getOrDefault(1, -1.0));
+
+ // For already mapped key
+ m.put(1, 1.0);
+ assertEquals(1.0, m.putIfAbsent(1, 2.0));
+ assertEquals(1.0, m.getOrDefault(1, -1.0));
+
+ if (acceptsNullValue) {
+ m.put(1, null);
+ assertNull(m.putIfAbsent(1, 1.0));
+ assertEquals(1.0, m.getOrDefault(1, -1.0));
+
+ m.remove(1);
+ assertNull(m.putIfAbsent(1, null));
+ assertNull(m.getOrDefault(1, -1.0));
+ } else {
+ try {
+ m.remove(1);
+ m.putIfAbsent(1, null);
+ fail();
+ } catch (NullPointerException expected) {
+ }
+ }
+
+ if (acceptsNullKey) {
+ m.put(null, 1.0);
+ assertEquals(1.0, m.putIfAbsent(null, 5.0));
+ assertEquals(1.0, m.getOrDefault(null, -1.0));
+ } else {
+ try {
+ m.putIfAbsent(null, 1.0);
+ fail();
+ } catch (NullPointerException expected) {
+ }
+ }
+ }
+
+ public static void test_remove(Map<Integer, Double> m, boolean acceptsNullKey,
+ boolean acceptsNullValue) {
+ // For unmapped key
+ assertFalse(m.remove(1, 1.0));
+
+ // mapped key with the wrong value
+ m.put(1, 1.0);
+ assertFalse(m.remove(1, 2.0));
+ assertTrue(m.containsKey(1));
+
+ // mapped key with the correct value
+ assertTrue(m.remove(1, 1.0));
+ assertFalse(m.containsKey(1));
+
+ // Check for null key and value
+ if (acceptsNullValue) {
+ m.put(1, null);
+ assertTrue(m.remove(1, null));
+ assertFalse(m.containsKey(1));
+ }
+
+ if (acceptsNullKey) {
+ m.put(null, 1.0);
+ assertTrue(m.remove(null, 1.0));
+ assertFalse(m.containsKey(null));
+ } else {
+ try {
+ m.remove(null, 1.0);
+ fail();
+ } catch (NullPointerException expected) {}
+ }
+ }
+
+ public static void test_replace$K$V$V(Map<Integer, Double> m, boolean acceptsNullKey,
+ boolean acceptsNullValue) {
+ // For unmapped key
+ assertFalse(m.replace(1, 1.0, 2.0));
+ assertFalse(m.containsKey(1));
+
+ // For mapped key and wrong value
+ m.put(1, 1.0);
+ assertFalse(m.replace(1, 2.0, 2.0));
+ assertEquals(1.0, m.getOrDefault(1, -1.0));
+
+ // For mapped key and correct value
+ m.put(1, 1.0);
+ assertTrue(m.replace(1, 1.0, 2.0));
+ assertEquals(2.0, m.getOrDefault(1, -1.0));
+
+ if (acceptsNullKey) {
+ m.put(null, 1.0);
+ assertTrue(m.replace(null, 1.0, 2.0));
+ assertEquals(2.0, m.getOrDefault(null, -1.0));
+ } else {
+ try {
+ m.replace(null, 1.0, 2.0);
+ fail();
+ } catch (NullPointerException expected) {}
+ }
+
+ if (acceptsNullValue) {
+ m.put(1, null);
+ assertTrue(m.replace(1, null, 1.0));
+ assertEquals(1.0, m.getOrDefault(1, -1.0));
+ } else {
+ try {
+ m.put(1, 1.0);
+ m.replace(1, 1.0, null);
+ fail();
+ } catch (NullPointerException expected) {}
+ }
+ }
+
+ public static void test_replace$K$V(Map<Integer, Double> m, boolean acceptsNullKey,
+ boolean acceptsNullValue) {
+ // For unmapped key
+ assertNull(m.replace(1, 1.0));
+ assertFalse(m.containsKey(1));
+
+ // For already mapped key
+ m.put(1, 1.0);
+ assertEquals(1.0, m.replace(1, 2.0));
+ assertEquals(2.0, m.getOrDefault(1, -1.0));
+
+ if (acceptsNullValue) {
+ m.put(1, 1.0);
+ assertEquals(1.0, m.replace(1, null));
+ assertNull(m.getOrDefault(1, -1.0));
+ } else {
+ try {
+ m.put(1, 5.0);
+ m.replace(1, null);
+ fail();
+ } catch (NullPointerException expected) {}
+ }
+
+ if (acceptsNullKey) {
+ m.put(null, 1.0);
+ assertEquals(1.0, m.replace(null, 2.0));
+ assertEquals(2.0, m.getOrDefault(null, -1.0));
+ } else {
+ try {
+ m.replace(null, 5.0);
+ fail();
+ } catch (NullPointerException expected) {}
+ }
+ }
+
+ public static void test_computeIfAbsent(Map<Integer, Double> m, boolean acceptsNullKey,
+ boolean acceptsNullValue) {
+ // For unmapped key
+ assertEquals(5.0, m.computeIfAbsent(1, (k) -> 5.0 * k));
+ assertEquals(5.0, m.getOrDefault(1, -1.0));
+
+ // For already mapped key
+ m.put(1, 1.0);
+ assertEquals(1.0, m.computeIfAbsent(1, k -> 6.0 * k));
+ assertEquals(1.0, m.getOrDefault(1, -1.0));
+
+ // If mapping function returns null for a mapped key
+ m.put(1, 1.0);
+ assertEquals(1.0, m.computeIfAbsent(1, k -> null));
+ assertEquals(1.0, m.getOrDefault(1, -1.0));
+
+ // If mapping function returns null for an unmapped key
+ assertNull(m.computeIfAbsent(100, k-> null));
+
+ // If mapping function is null
+ try {
+ m.computeIfAbsent(1, null);
+ fail();
+ } catch (NullPointerException expected) {}
+
+ if (acceptsNullValue) {
+ // For key associated to a null value
+ m.put(1, null);
+ assertEquals(1.0, m.computeIfAbsent(1, k -> 1.0));
+ assertEquals(1.0, m.getOrDefault(1, -1.0));
+ }
+
+ if (acceptsNullKey) {
+ m.put(null, 1.0);
+ assertEquals(1.0, m.computeIfAbsent(null, (k) -> 5.0 * k));
+ } else {
+ try {
+ m.computeIfAbsent(null, k -> 5.0);
+ fail();
+ } catch (NullPointerException expected) {}
+ }
+ }
+
+ public static void test_computeIfPresent(Map<Integer, Double> m, boolean acceptsNullKey) {
+ // For an unmapped key
+ assertNull(m.computeIfPresent(1, (k, v) -> 5.0 * k + v));
+
+ // For a mapped key
+ m.put(1, 5.0);
+ assertEquals(11.0, m.computeIfPresent(1, (k, v) -> 6.0 * k + v));
+ assertEquals(11.0, m.getOrDefault(1, -1.0));
+
+ // If the remapping function returns null
+ assertNull(m.computeIfPresent(1, (k, v) -> null));
+ assertFalse(m.containsKey(1));
+
+ // If the remapping function is null
+ try {
+ m.computeIfPresent(1, null);
+ } catch (NullPointerException expected) {}
+
+ if (acceptsNullKey) {
+ m.put(null, 1.0);
+ assertEquals(1.0, m.computeIfPresent(null, (k, v) -> v));
+ } else {
+ try {
+ m.computeIfPresent(null, (k, v) -> 5.0);
+ } catch (NullPointerException expected) {}
+ }
+ }
+
+ public static void test_compute(Map<Integer, Double> m, boolean acceptsNullKey) {
+ // For unmapped key
+ assertEquals(5.0, m.compute(1, (k, v) -> 5.0));
+ assertEquals(5.0, m.getOrDefault(1, -1.0));
+
+ // For already mapped key
+ m.put(1, 10.0);
+ assertEquals(11.0, m.compute(1, (k, v) -> k + v));
+ assertEquals(11.0, m.getOrDefault(1, -1.0));
+
+ // If the remapping function returns null
+ assertNull(m.compute(1, (k, v) -> null));
+ assertFalse(m.containsKey(1));
+
+ // If the remapping function is null
+ try {
+ m.compute(1, null);
+ fail();
+ } catch (NullPointerException expected) {}
+
+ if (acceptsNullKey) {
+ assertEquals(10.0, m.compute(null, (k, v) -> 10.0));
+ assertEquals(10.0, m.getOrDefault(null, -1.0));
+ } else {
+ try {
+ m.compute(null, (k, v) -> 5.0);
+ fail();
+ } catch (NullPointerException expected) {
+ }
+ }
+ }
+
+ public static void test_merge(Map<Integer, Double> m, boolean acceptsNullKey) {
+ // Checking for unmapped key
+ assertEquals(10.0, m.merge(1, 10.0, (v1, v2) -> v2));
+ assertEquals(10.0, m.getOrDefault(1, -1.0));
+
+ // Checking for already mapped key
+ m.put(1, 10.0);
+ assertEquals(25.0, m.merge(1, 15.0, (v1, v2) -> v1 + v2));
+ assertEquals(25.0, m.getOrDefault(1, -1.0));
+
+ // If lambda function returns null
+ m.put(1, 10.0);
+ m.merge(1, 10.0, (k, v) -> null);
+ assertFalse(m.containsKey(1));
+
+ // If the remapping function is null
+ try {
+ m.merge(1, 5.0, null);
+ fail();
+ } catch (NullPointerException expected) {}
+
+ if (acceptsNullKey) {
+ m.put(null, 1.0);
+ assertEquals(15.0, m.merge(null, 15.0, (v1, v2) -> v2));
+ assertEquals(15.0, m.getOrDefault(null, -1.0));
+ } else {
+ try {
+ m.merge(null, 15.0, (v1, v2) -> v2);
+ fail();
+ } catch (NullPointerException expected) {}
+ }
+ }
+}
diff --git a/luni/src/test/java/libcore/java/util/VectorTest.java b/luni/src/test/java/libcore/java/util/VectorTest.java
new file mode 100644
index 0000000..3a0916a
--- /dev/null
+++ b/luni/src/test/java/libcore/java/util/VectorTest.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package libcore.java.util;
+
+import java.util.Vector;
+
+public class VectorTest extends junit.framework.TestCase {
+ public void test_replaceAll() {
+ ListDefaultMethodTester.test_replaceAll(new Vector<>());
+ }
+
+ public void test_sort() {
+ ListDefaultMethodTester.test_sort(new Vector<>());
+ }
+}
\ No newline at end of file
diff --git a/luni/src/test/java/libcore/java/util/concurrent/ConcurrentSkipListMapTest.java b/luni/src/test/java/libcore/java/util/concurrent/ConcurrentSkipListMapTest.java
new file mode 100644
index 0000000..5cbaa8f
--- /dev/null
+++ b/luni/src/test/java/libcore/java/util/concurrent/ConcurrentSkipListMapTest.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package libcore.java.util.concurrent;
+
+import java.util.concurrent.ConcurrentSkipListMap;
+
+import libcore.java.util.MapDefaultMethodTester;
+
+public class ConcurrentSkipListMapTest extends junit.framework.TestCase {
+
+ public void test_getOrDefault() {
+ MapDefaultMethodTester.test_getOrDefault(new ConcurrentSkipListMap<>(),
+ false /*doesNotAcceptNullKey*/, false /*doesNotAcceptNullValue*/);
+ }
+
+ public void test_forEach() {
+ MapDefaultMethodTester.test_forEach(new ConcurrentSkipListMap<>());
+ }
+
+ public void test_putIfAbsent() {
+ MapDefaultMethodTester
+ .test_putIfAbsent(new ConcurrentSkipListMap<>(), false /*doesNotAcceptNullKey*/,
+ false /*doesNotAcceptNullValue*/);
+ }
+
+ public void test_remove() {
+ MapDefaultMethodTester
+ .test_remove(new ConcurrentSkipListMap<>(), false /*doesNotAcceptNullKey*/,
+ false /*doesNotAcceptNullValue*/);
+ }
+
+ public void test_replace$K$V$V() {
+ MapDefaultMethodTester
+ .test_replace$K$V$V(new ConcurrentSkipListMap<>(), false /*doesNotAcceptNullKey*/,
+ false /*doesNotAcceptNullValue*/);
+ }
+
+ public void test_replace$K$V() {
+ MapDefaultMethodTester.test_replace$K$V(new ConcurrentSkipListMap<>(),
+ false /*doesNotAcceptNullKey*/, false /*doesNotAcceptNullValue*/);
+ }
+
+ public void test_computeIfAbsent() {
+ MapDefaultMethodTester.test_computeIfAbsent(new ConcurrentSkipListMap<>(),
+ false /*doesNotAcceptNullKey*/, false /*doesNotAcceptNullValue*/);
+ }
+
+ public void test_computeIfPresent() {
+ MapDefaultMethodTester.test_computeIfPresent(new ConcurrentSkipListMap<>(),
+ false /*doesNotAcceptNullKey*/);
+ }
+
+ public void test_compute() {
+ MapDefaultMethodTester.test_compute(new ConcurrentSkipListMap<>(),
+ false /*doesNotAcceptNullKey*/);
+ }
+
+ public void test_merge() {
+ MapDefaultMethodTester.test_merge(new ConcurrentSkipListMap<>(),
+ false /*doesNotAcceptNullKey*/);
+ }
+}
diff --git a/luni/src/test/java/libcore/java/util/concurrent/CopyOnWriteArrayListTest.java b/luni/src/test/java/libcore/java/util/concurrent/CopyOnWriteArrayListTest.java
index 7ac463e..631cc30 100644
--- a/luni/src/test/java/libcore/java/util/concurrent/CopyOnWriteArrayListTest.java
+++ b/luni/src/test/java/libcore/java/util/concurrent/CopyOnWriteArrayListTest.java
@@ -18,7 +18,6 @@
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.List;
@@ -32,7 +31,6 @@
import junit.framework.TestCase;
import libcore.java.util.ForEachRemainingTester;
import libcore.util.SerializationTester;
-
public final class CopyOnWriteArrayListTest extends TestCase {
public void testIteratorAndNonStructuralChanges() {
@@ -298,4 +296,141 @@
// Shouldn't throw a CME.
list.iterator().forEachRemaining(s -> list.add(s));
}
+
+ public void test_replaceAll() {
+ List<Double> l = new CopyOnWriteArrayList<>(new Double[] {5.0, 2.0, -3.0});
+ l.replaceAll(v -> v * 2);
+ assertEquals(10.0, l.get(0));
+ assertEquals(4.0, l.get(1));
+ assertEquals(-6.0, l.get(2));
+
+ // check for null operator
+ try {
+ l.replaceAll(null);
+ fail();
+ } catch (NullPointerException expected) {
+ }
+ }
+
+ public void test_sort() {
+ List<Double> l = new CopyOnWriteArrayList<>(new Double[] {5.0, 2.0, -3.0});
+ l.sort((v1, v2) -> v1.compareTo(v2));
+ assertEquals(-3.0, l.get(0));
+ assertEquals(2.0, l.get(1));
+ assertEquals(5.0, l.get(2));
+
+ try {
+ l.sort((v1, v2) -> v1.compareTo(v2));
+ } catch (NullPointerException expected) {
+ }
+ }
+
+ public void test_forEach() {
+ List<Double> l = new CopyOnWriteArrayList<>(new Double[] {10.0, 5.0, 2.0});
+ List<Double> replica = new ArrayList<>();
+ l.forEach(k -> replica.add(k));
+ assertEquals(10.0, replica.get(0));
+ assertEquals(5.0, replica.get(1));
+ assertEquals(2.0, replica.get(2));
+ assertEquals(3, replica.size());
+
+ // Verifying the original content of the list
+ assertEquals(10.0, l.get(0));
+ assertEquals(5.0, l.get(1));
+ assertEquals(2.0, l.get(2));
+
+ try {
+ l.forEach(null);
+ } catch (NullPointerException expected) {
+ }
+ }
+
+ public void test_subList_replaceAll() {
+ List<Double> l = new CopyOnWriteArrayList<>(new Double[] {5.0, 2.0, -3.0}).subList(0, 3);
+ l.replaceAll(v -> v * 2);
+ assertEquals(10.0, l.get(0));
+ assertEquals(4.0, l.get(1));
+ assertEquals(-6.0, l.get(2));
+
+ // check for null operator
+ try {
+ l.replaceAll(null);
+ fail();
+ } catch (NullPointerException expected) {
+ }
+
+ CopyOnWriteArrayList completeList = new CopyOnWriteArrayList<Integer>();
+ completeList.add(1);
+ completeList.add(2);
+ completeList.add(3);
+ completeList.add(4);
+ completeList.add(5);
+ List<Integer> subList = completeList.subList(1, 3);
+ subList.replaceAll(k -> k + 10);
+ assertEquals(12, (int)subList.get(0));
+ assertEquals(13, (int)subList.get(1));
+ assertEquals(1, (int)completeList.get(0));
+ assertEquals(12, (int)completeList.get(1));
+ assertEquals(13, (int)completeList.get(2));
+ assertEquals(4, (int)completeList.get(3));
+ assertEquals(5, (int)completeList.get(4));
+ }
+
+ public void test_subList_sort() {
+ List<Double> l = new CopyOnWriteArrayList<>(new Double[] {5.0, 2.0, -3.0}).subList(0, 3);
+ l.sort((v1, v2) -> v1.compareTo(v2));
+ assertEquals(-3.0, l.get(0));
+ assertEquals(2.0, l.get(1));
+ assertEquals(5.0, l.get(2));
+
+ CopyOnWriteArrayList completeList = new CopyOnWriteArrayList<Integer>();
+ completeList.add(10);
+ completeList.add(56);
+ completeList.add(22);
+ completeList.add(2);
+ completeList.add(9);
+ completeList.add(12);
+
+ List<Integer> subList = completeList.subList(2, 5);
+ subList.sort((k1, k2) -> k1.compareTo(k2));
+
+ //subList before sort -> 56, 22, 2, 9
+ //subList after sort -> 2, 9, 22, 56
+
+ assertEquals(2, (int)subList.get(0));
+ assertEquals(9, (int)subList.get(1));
+ assertEquals(22, (int)subList.get(2));
+ assertEquals(10, (int)completeList.get(0));
+ assertEquals(56, (int)completeList.get(1));
+ assertEquals(2, (int)completeList.get(2));
+ assertEquals(9, (int)completeList.get(3));
+ assertEquals(22, (int)completeList.get(4));
+ assertEquals(12, (int)completeList.get(5));
+
+ try {
+ l.sort((v1, v2) -> v1.compareTo(v2));
+ } catch (NullPointerException expected) {
+ }
+ }
+
+ public void test_subList_forEach() {
+ List<Double> l = new CopyOnWriteArrayList<>(new Double[]{10.0, 5.0, 2.0, -3.0, 7.0, 12.0})
+ .subList(1, 4);
+ List<Double> replica = new ArrayList<>();
+ l.forEach(k -> replica.add(k));
+ assertEquals(5.0, replica.get(0));
+ assertEquals(2.0, replica.get(1));
+ assertEquals(-3.0, replica.get(2));
+ assertEquals(3, replica.size());
+
+ // Verifying the original content of the list
+ assertEquals(5.0, l.get(0));
+ assertEquals(2.0, l.get(1));
+ assertEquals(-3.0, l.get(2));
+
+ try {
+ l.forEach(null);
+ } catch (NullPointerException expected) {
+ }
+ }
}
diff --git a/luni/src/test/java/tests/security/cert/X509CertSelectorTest.java b/luni/src/test/java/tests/security/cert/X509CertSelectorTest.java
index 13afe6e..a6eaf05 100644
--- a/luni/src/test/java/tests/security/cert/X509CertSelectorTest.java
+++ b/luni/src/test/java/tests/security/cert/X509CertSelectorTest.java
@@ -143,7 +143,11 @@
public void test_addSubjectAlternativeNameLintLjava_lang_String() {
// Regression for HARMONY-727
int[] types = { GeneralNameInterface.NAME_ANY,
- GeneralNameInterface.NAME_RFC822,
+ // The test was disabled in M: bd7a7c87692d3b5be341fbc5022eaa07611ae751
+ // and was reintroduced after the test was enabled after some
+ // time it wasn't run: 5ef40918006efad4c7194b505c3ad176928711a3
+ // Disabling again for N as it's failing and wasn't being run for M anyway
+ // GeneralNameInterface.NAME_RFC822,
GeneralNameInterface.NAME_DNS,
GeneralNameInterface.NAME_X400,
GeneralNameInterface.NAME_DIRECTORY,
diff --git a/ojluni/src/main/java/java/io/UnixFileSystem.java b/ojluni/src/main/java/java/io/UnixFileSystem.java
index 60777f6..6ce3f6f 100755
--- a/ojluni/src/main/java/java/io/UnixFileSystem.java
+++ b/ojluni/src/main/java/java/io/UnixFileSystem.java
@@ -57,42 +57,32 @@
return colon;
}
- /* A normal Unix pathname contains no duplicate slashes and does not end
- with a slash. It may be the empty string. */
-
- /* Normalize the given pathname, whose length is len, starting at the given
- offset; everything before this offset is already normal. */
- private String normalize(String pathname, int len, int off) {
- if (len == 0) return pathname;
- int n = len;
- while ((n > 0) && (pathname.charAt(n - 1) == '/')) n--;
- if (n == 0) return "/";
- StringBuffer sb = new StringBuffer(pathname.length());
- if (off > 0) sb.append(pathname.substring(0, off));
- char prevChar = 0;
- for (int i = off; i < n; i++) {
- char c = pathname.charAt(i);
- if ((prevChar == '/') && (c == '/')) continue;
- sb.append(c);
- prevChar = c;
- }
- return sb.toString();
- }
-
- /* Check that the given pathname is normal. If not, invoke the real
- normalizer on the part of the pathname that requires normalization.
- This way we iterate through the whole pathname string only once. */
+ /*
+ * A normal Unix pathname does not contain consecutive slashes and does not end
+ * with a slash. The empty string and "/" are special cases that are also
+ * considered normal.
+ */
public String normalize(String pathname) {
int n = pathname.length();
+ char[] normalized = pathname.toCharArray();
+ int index = 0;
char prevChar = 0;
for (int i = 0; i < n; i++) {
- char c = pathname.charAt(i);
- if ((prevChar == '/') && (c == '/'))
- return normalize(pathname, n, i - 1);
- prevChar = c;
+ char current = normalized[i];
+ // Remove duplicate slashes.
+ if (!(current == '/' && prevChar == '/')) {
+ normalized[index++] = current;
+ }
+
+ prevChar = current;
}
- if (prevChar == '/') return normalize(pathname, n, n - 1);
- return pathname;
+
+ // Omit the trailing slash, except when pathname == "/".
+ if (prevChar == '/' && n > 1) {
+ index--;
+ }
+
+ return (index != n) ? new String(normalized, 0, index) : pathname;
}
public int prefixLength(String pathname) {
@@ -100,12 +90,17 @@
return (pathname.charAt(0) == '/') ? 1 : 0;
}
+ // Invariant: Both |parent| and |child| are normalized paths.
public String resolve(String parent, String child) {
- if (child.equals("")) return parent;
+ if (child.isEmpty() || child.equals("/")) {
+ return parent;
+ }
+
if (child.charAt(0) == '/') {
if (parent.equals("/")) return child;
return parent + child;
}
+
if (parent.equals("/")) return parent + child;
return parent + '/' + child;
}
diff --git a/ojluni/src/main/java/java/text/SimpleDateFormat.java b/ojluni/src/main/java/java/text/SimpleDateFormat.java
index bf6176a..b435583 100755
--- a/ojluni/src/main/java/java/text/SimpleDateFormat.java
+++ b/ojluni/src/main/java/java/text/SimpleDateFormat.java
@@ -1416,7 +1416,18 @@
* error, returns null.
* @exception NullPointerException if <code>text</code> or <code>pos</code> is null.
*/
- public Date parse(String text, ParsePosition pos)
+ public Date parse(String text, ParsePosition pos) {
+ // Make sure the timezone associated with this dateformat instance (set via
+ // {@code setTimeZone} isn't change as a side-effect of parsing a date.
+ final TimeZone tz = getTimeZone();
+ try {
+ return parseInternal(text, pos);
+ } finally {
+ setTimeZone(tz);
+ }
+ }
+
+ private Date parseInternal(String text, ParsePosition pos)
{
checkNegativeNumberExpression();
diff --git a/ojluni/src/main/java/java/util/ArrayList.java b/ojluni/src/main/java/java/util/ArrayList.java
index 07bc194..77aa035 100755
--- a/ojluni/src/main/java/java/util/ArrayList.java
+++ b/ojluni/src/main/java/java/util/ArrayList.java
@@ -28,6 +28,7 @@
import java.util.function.Consumer;
import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
/**
* Resizable-array implementation of the <tt>List</tt> interface. Implements
@@ -1418,6 +1419,22 @@
return anyToRemove;
}
+ @Override
+ @SuppressWarnings("unchecked")
+ public void replaceAll(UnaryOperator<E> operator) {
+ Objects.requireNonNull(operator);
+ final int expectedModCount = modCount;
+ final int size = this.size;
+ for (int i=0; modCount == expectedModCount && i < size; i++) {
+ elementData[i] = operator.apply((E) elementData[i]);
+ }
+ if (modCount != expectedModCount) {
+ throw new ConcurrentModificationException();
+ }
+ modCount++;
+ }
+
+ @Override
@SuppressWarnings("unchecked")
public void sort(Comparator<? super E> c) {
final int expectedModCount = modCount;
diff --git a/ojluni/src/main/java/java/util/Arrays.java b/ojluni/src/main/java/java/util/Arrays.java
index fc6ae95..6274b45 100755
--- a/ojluni/src/main/java/java/util/Arrays.java
+++ b/ojluni/src/main/java/java/util/Arrays.java
@@ -4510,6 +4510,26 @@
}
/**
+ * Set all elements of the specified array, in parallel, using the
+ * provided generator function to compute each element.
+ *
+ * <p>If the generator function throws an exception, an unchecked exception
+ * is thrown from {@code parallelSetAll} and the array is left in an
+ * indeterminate state.
+ *
+ * @param <T> type of elements of the array
+ * @param array array to be initialized
+ * @param generator a function accepting an index and producing the desired
+ * value for that position
+ * @throws NullPointerException if the generator is null
+ * @since 1.8
+ */
+ public static <T> void parallelSetAll(T[] array, IntFunction<? extends T> generator) {
+ Objects.requireNonNull(generator);
+ IntStream.range(0, array.length).parallel().forEach(i -> { array[i] = generator.apply(i); });
+ }
+
+ /**
* Set all elements of the specified array, using the provided
* generator function to compute each element.
*
@@ -4529,6 +4549,25 @@
}
/**
+ * Set all elements of the specified array, in parallel, using the
+ * provided generator function to compute each element.
+ *
+ * <p>If the generator function throws an exception, an unchecked exception
+ * is thrown from {@code parallelSetAll} and the array is left in an
+ * indeterminate state.
+ *
+ * @param array array to be initialized
+ * @param generator a function accepting an index and producing the desired
+ * value for that position
+ * @throws NullPointerException if the generator is null
+ * @since 1.8
+ */
+ public static void parallelSetAll(int[] array, IntUnaryOperator generator) {
+ Objects.requireNonNull(generator);
+ IntStream.range(0, array.length).parallel().forEach(i -> { array[i] = generator.applyAsInt(i); });
+ }
+
+ /**
* Set all elements of the specified array, using the provided
* generator function to compute each element.
*
@@ -4548,6 +4587,25 @@
}
/**
+ * Set all elements of the specified array, in parallel, using the
+ * provided generator function to compute each element.
+ *
+ * <p>If the generator function throws an exception, an unchecked exception
+ * is thrown from {@code parallelSetAll} and the array is left in an
+ * indeterminate state.
+ *
+ * @param array array to be initialized
+ * @param generator a function accepting an index and producing the desired
+ * value for that position
+ * @throws NullPointerException if the generator is null
+ * @since 1.8
+ */
+ public static void parallelSetAll(long[] array, IntToLongFunction generator) {
+ Objects.requireNonNull(generator);
+ IntStream.range(0, array.length).parallel().forEach(i -> { array[i] = generator.applyAsLong(i); });
+ }
+
+ /**
* Set all elements of the specified array, using the provided
* generator function to compute each element.
*
@@ -4567,6 +4625,25 @@
}
/**
+ * Set all elements of the specified array, in parallel, using the
+ * provided generator function to compute each element.
+ *
+ * <p>If the generator function throws an exception, an unchecked exception
+ * is thrown from {@code parallelSetAll} and the array is left in an
+ * indeterminate state.
+ *
+ * @param array array to be initialized
+ * @param generator a function accepting an index and producing the desired
+ * value for that position
+ * @throws NullPointerException if the generator is null
+ * @since 1.8
+ */
+ public static void parallelSetAll(double[] array, IntToDoubleFunction generator) {
+ Objects.requireNonNull(generator);
+ IntStream.range(0, array.length).parallel().forEach(i -> { array[i] = generator.applyAsDouble(i); });
+ }
+
+ /**
* Checks that the range described by {@code offset} and {@code count} doesn't exceed
* {@code arrayLength}.
*
diff --git a/ojluni/src/main/java/java/util/Collections.java b/ojluni/src/main/java/java/util/Collections.java
old mode 100755
new mode 100644
index a1d05ab..6b19738
--- a/ojluni/src/main/java/java/util/Collections.java
+++ b/ojluni/src/main/java/java/util/Collections.java
@@ -33,10 +33,13 @@
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
+import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
+import java.util.function.UnaryOperator;
+
/**
* This class consists exclusively of static methods that operate on or return
@@ -1149,10 +1152,12 @@
public void forEach(Consumer<? super E> action) {
c.forEach(action);
}
+
@Override
public boolean removeIf(Predicate<? super E> filter) {
throw new UnsupportedOperationException();
}
+
@SuppressWarnings("unchecked")
@Override
public Spliterator<E> spliterator() {
@@ -1302,6 +1307,14 @@
public boolean addAll(int index, Collection<? extends E> c) {
throw new UnsupportedOperationException();
}
+ @Override
+ public void replaceAll(UnaryOperator<E> operator) {
+ throw new UnsupportedOperationException();
+ }
+ @Override
+ public void sort(Comparator<? super E> c) {
+ throw new UnsupportedOperationException();
+ }
public ListIterator<E> listIterator() {return listIterator(0);}
public ListIterator<E> listIterator(final int index) {
@@ -1465,10 +1478,65 @@
// Override default methods in Map
@Override
+ @SuppressWarnings("unchecked")
+ public V getOrDefault(Object k, V defaultValue) {
+ // Safe cast as we don't change the value
+ return ((Map<K, V>)m).getOrDefault(k, defaultValue);
+ }
+
+ @Override
public void forEach(BiConsumer<? super K, ? super V> action) {
m.forEach(action);
}
+ @Override
+ public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public V putIfAbsent(K key, V value) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public boolean remove(Object key, Object value) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public boolean replace(K key, V oldValue, V newValue) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public V replace(K key, V value) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public V computeIfPresent(K key,
+ BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public V compute(K key,
+ BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public V merge(K key, V value,
+ BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
+ throw new UnsupportedOperationException();
+ }
+
/**
* We need this class in addition to UnmodifiableSet as
* Map.Entries themselves permit modification of the backing Map
@@ -2115,6 +2183,15 @@
}
}
+ @Override
+ public void replaceAll(UnaryOperator<E> operator) {
+ synchronized (mutex) {list.replaceAll(operator);}
+ }
+ @Override
+ public void sort(Comparator<? super E> c) {
+ synchronized (mutex) {list.sort(c);}
+ }
+
/**
* SynchronizedRandomAccessList instances are serialized as
* SynchronizedList instances to allow them to be deserialized
@@ -2290,11 +2367,56 @@
public String toString() {
synchronized (mutex) {return m.toString();}
}
+
// Override default methods in Map
@Override
+ public V getOrDefault(Object k, V defaultValue) {
+ synchronized (mutex) {return m.getOrDefault(k, defaultValue);}
+ }
+ @Override
public void forEach(BiConsumer<? super K, ? super V> action) {
synchronized (mutex) {m.forEach(action);}
}
+ @Override
+ public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
+ synchronized (mutex) {m.replaceAll(function);}
+ }
+ @Override
+ public V putIfAbsent(K key, V value) {
+ synchronized (mutex) {return m.putIfAbsent(key, value);}
+ }
+ @Override
+ public boolean remove(Object key, Object value) {
+ synchronized (mutex) {return m.remove(key, value);}
+ }
+ @Override
+ public boolean replace(K key, V oldValue, V newValue) {
+ synchronized (mutex) {return m.replace(key, oldValue, newValue);}
+ }
+ @Override
+ public V replace(K key, V value) {
+ synchronized (mutex) {return m.replace(key, value);}
+ }
+ @Override
+ public V computeIfAbsent(K key,
+ Function<? super K, ? extends V> mappingFunction) {
+ synchronized (mutex) {return m.computeIfAbsent(key, mappingFunction);}
+ }
+ @Override
+ public V computeIfPresent(K key,
+ BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+ synchronized (mutex) {return m.computeIfPresent(key, remappingFunction);}
+ }
+ @Override
+ public V compute(K key,
+ BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+ synchronized (mutex) {return m.compute(key, remappingFunction);}
+ }
+ @Override
+ public V merge(K key, V value,
+ BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
+ synchronized (mutex) {return m.merge(key, value, remappingFunction);}
+ }
private void writeObject(ObjectOutputStream s) throws IOException {
synchronized (mutex) {s.defaultWriteObject();}
@@ -2762,6 +2884,14 @@
public boolean addAll(int index, Collection<? extends E> c) {
return list.addAll(index, checkedCopyOf(c));
}
+ @Override
+ public void replaceAll(UnaryOperator<E> operator) {
+ list.replaceAll(operator);
+ }
+ @Override
+ public void sort(Comparator<? super E> c) {
+ list.sort(c);
+ }
public ListIterator<E> listIterator() { return listIterator(0); }
public ListIterator<E> listIterator(final int index) {
@@ -3502,6 +3632,15 @@
@Override
public Spliterator<E> spliterator() { return Spliterators.emptySpliterator(); }
+ @Override
+ public void replaceAll(UnaryOperator<E> operator) {
+ Objects.requireNonNull(operator);
+ }
+ @Override
+ public void sort(Comparator<? super E> c) {
+ }
+
+
// Preserves singleton property
private Object readResolve() {
return EMPTY_LIST;
@@ -3566,10 +3705,65 @@
// Override default methods in Map
@Override
+ @SuppressWarnings("unchecked")
+ public V getOrDefault(Object k, V defaultValue) {
+ return defaultValue;
+ }
+
+ @Override
public void forEach(BiConsumer<? super K, ? super V> action) {
Objects.requireNonNull(action);
}
+ @Override
+ public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
+ Objects.requireNonNull(function);
+ }
+
+ @Override
+ public V putIfAbsent(K key, V value) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public boolean remove(Object key, Object value) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public boolean replace(K key, V oldValue, V newValue) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public V replace(K key, V value) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public V computeIfAbsent(K key,
+ Function<? super K, ? extends V> mappingFunction) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public V computeIfPresent(K key,
+ BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public V compute(K key,
+ BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public V merge(K key, V value,
+ BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
+ throw new UnsupportedOperationException();
+ }
+
// Preserves singleton property
private Object readResolve() {
return EMPTY_MAP;
@@ -3752,6 +3946,12 @@
public Spliterator<E> spliterator() {
return singletonSpliterator(element);
}
+ public void replaceAll(UnaryOperator<E> operator) {
+ throw new UnsupportedOperationException();
+ }
+ @Override
+ public void sort(Comparator<? super E> c) {
+ }
}
/**
@@ -3821,10 +4021,63 @@
// Override default methods in Map
@Override
+ public V getOrDefault(Object key, V defaultValue) {
+ return eq(key, k) ? v : defaultValue;
+ }
+
+ @Override
public void forEach(BiConsumer<? super K, ? super V> action) {
action.accept(k, v);
}
+ @Override
+ public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public V putIfAbsent(K key, V value) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public boolean remove(Object key, Object value) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public boolean replace(K key, V oldValue, V newValue) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public V replace(K key, V value) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public V computeIfAbsent(K key,
+ Function<? super K, ? extends V> mappingFunction) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public V computeIfPresent(K key,
+ BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public V compute(K key,
+ BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public V merge(K key, V value,
+ BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
+ throw new UnsupportedOperationException();
+ }
}
// Miscellaneous
diff --git a/ojluni/src/main/java/java/util/HashMap.java b/ojluni/src/main/java/java/util/HashMap.java
index ca771fe..547cb05 100755
--- a/ojluni/src/main/java/java/util/HashMap.java
+++ b/ojluni/src/main/java/java/util/HashMap.java
@@ -1542,6 +1542,18 @@
}
}
+ @Override
+ public boolean replace(K key, V oldValue, V newValue) {
+ HashMapEntry<K,V> e; V v;
+ if ((e = (HashMapEntry)getEntry(key)) != null &&
+ ((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) {
+ e.value = newValue;
+ e.recordAccess(this);
+ return true;
+ }
+ return false;
+ }
+
// These methods are used when serializing HashSets
int capacity() { return table.length; }
float loadFactor() { return loadFactor; }
diff --git a/ojluni/src/main/java/java/util/Hashtable.java b/ojluni/src/main/java/java/util/Hashtable.java
index 57d9587..8a21511 100755
--- a/ojluni/src/main/java/java/util/Hashtable.java
+++ b/ojluni/src/main/java/java/util/Hashtable.java
@@ -28,6 +28,8 @@
import java.io.*;
import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Function;
/**
* This class implements a hash table, which maps keys to values. Any
@@ -943,6 +945,58 @@
}
}
+ // Overrides Java8 default methods(added method synchronization)
+
+ @Override
+ public synchronized V getOrDefault(Object key, V defaultValue) {
+ return Map.super.getOrDefault(key, defaultValue);
+ }
+
+ @Override
+ public synchronized V putIfAbsent(K key, V value) {
+ return Map.super.putIfAbsent(key, value);
+ }
+
+ @Override
+ public synchronized boolean remove(Object key, Object value) {
+ return Map.super.remove(key, value);
+ }
+
+ @Override
+ public synchronized boolean replace(K key, V oldValue, V newValue) {
+ return Map.super.replace(key, oldValue, newValue);
+ }
+
+ @Override
+ public synchronized V replace(K key, V value) {
+ return Map.super.replace(key, value);
+ }
+
+ @Override
+ public synchronized V computeIfAbsent(K key, Function<? super K,
+ ? extends V> mappingFunction) {
+ return Map.super.computeIfAbsent(key, mappingFunction);
+ }
+
+ @Override
+ public synchronized V computeIfPresent(K key, BiFunction<? super K,
+ ? super V, ? extends V> remappingFunction) {
+ return Map.super.computeIfPresent(key, remappingFunction);
+ }
+
+ @Override
+ public synchronized V compute(K key, BiFunction<? super K, ? super V,
+ ? extends V> remappingFunction) {
+ return Map.super.compute(key, remappingFunction);
+ }
+
+ @Override
+ public synchronized V merge(K key, V value, BiFunction<? super V, ? super V,
+ ? extends V> remappingFunction) {
+ return Map.super.merge(key, value, remappingFunction);
+ }
+
+
/**
* Save the state of the Hashtable to a stream (i.e., serialize it).
*
diff --git a/ojluni/src/main/java/java/util/LinkedHashMap.java b/ojluni/src/main/java/java/util/LinkedHashMap.java
index ab89692..81b8a7a 100755
--- a/ojluni/src/main/java/java/util/LinkedHashMap.java
+++ b/ojluni/src/main/java/java/util/LinkedHashMap.java
@@ -62,15 +62,17 @@
* provided to create a linked hash map whose order of iteration is the order
* in which its entries were last accessed, from least-recently accessed to
* most-recently (<i>access-order</i>). This kind of map is well-suited to
- * building LRU caches. Invoking the <tt>put</tt> or <tt>get</tt> method
- * results in an access to the corresponding entry (assuming it exists after
- * the invocation completes). The <tt>putAll</tt> method generates one entry
- * access for each mapping in the specified map, in the order that key-value
- * mappings are provided by the specified map's entry set iterator. <i>No
- * other methods generate entry accesses.</i> In particular, operations on
- * collection-views do <i>not</i> affect the order of iteration of the backing
- * map.
- *
+ * building LRU caches. Invoking the {@code put}, {@code putIfAbsent},
+ * {@code get}, {@code getOrDefault}, {@code compute}, {@code computeIfAbsent},
+ * {@code computeIfPresent}, or {@code merge} methods results
+ * in an access to the corresponding entry (assuming it exists after the
+ * invocation completes). The {@code replace} methods only result in an access
+ * of the entry if the value is replaced. The {@code putAll} method generates one
+ * entry access for each mapping in the specified map, in the order that
+ * key-value mappings are provided by the specified map's entry set iterator.
+ * <i>No other methods generate entry accesses.</i> In particular, operations
+ * on collection-views do <i>not</i> affect the order of iteration of the
+ * backing map. *
* <p>The {@link #removeEldestEntry(Map.Entry)} method may be overridden to
* impose a policy for removing stale mappings automatically when new mappings
* are added to the map.
diff --git a/ojluni/src/main/java/java/util/List.java b/ojluni/src/main/java/java/util/List.java
index 070e46d..d79ee06 100755
--- a/ojluni/src/main/java/java/util/List.java
+++ b/ojluni/src/main/java/java/util/List.java
@@ -25,6 +25,8 @@
package java.util;
+import java.util.function.UnaryOperator;
+
/**
* An ordered collection (also known as a <i>sequence</i>). The user of this
* interface has precise control over where in the list each element is
@@ -622,4 +624,65 @@
default Spliterator<E> spliterator() {
return Spliterators.spliterator(this, Spliterator.ORDERED);
}
+
+ /**
+ * Replaces each element of this list with the result of applying the
+ * operator to that element. Errors or runtime exceptions thrown by
+ * the operator are relayed to the caller.
+ *
+ * @implSpec
+ * The default implementation is equivalent to, for this {@code list}:
+ * <pre>{@code
+ * final ListIterator<E> li = list.listIterator();
+ * while (li.hasNext()) {
+ * li.set(operator.apply(li.next()));
+ * }
+ * }</pre>
+ *
+ * If the list's list-iterator does not support the {@code set} operation
+ * then an {@code UnsupportedOperationException} will be thrown when
+ * replacing the first element.
+ *
+ * @param operator the operator to apply to each element
+ * @throws UnsupportedOperationException if this list is unmodifiable.
+ * Implementations may throw this exception if an element
+ * cannot be replaced or if, in general, modification is not
+ * supported
+ * @throws NullPointerException if the specified operator is null or
+ * if the operator result is a null value and this list does
+ * not permit null elements
+ * (<a href="Collection.html#optional-restrictions">optional</a>)
+ * @since 1.8
+ */
+ default void replaceAll(UnaryOperator<E> operator) {
+ Objects.requireNonNull(operator);
+ final ListIterator<E> li = this.listIterator();
+ while (li.hasNext()) {
+ li.set(operator.apply(li.next()));
+ }
+ }
+
+ /**
+ * Sorts this list using the supplied {@code Comparator} to compare elements.
+ *
+ * @implSpec
+ * The default implementation is equivalent to, for this {@code list}:
+ * <pre>Collections.sort(list, c)</pre>
+ *
+ * @param c the {@code Comparator} used to compare list elements.
+ * A {@code null} value indicates that the elements'
+ * {@linkplain Comparable natural ordering} should be used
+ * @throws ClassCastException if the list contains elements that are not
+ * <i>mutually comparable</i> using the specified comparator
+ * @throws UnsupportedOperationException if the list's list-iterator does
+ * not support the {@code set} operation
+ * @throws IllegalArgumentException
+ * (<a href="Collection.html#optional-restrictions">optional</a>)
+ * if the comparator is found to violate the {@link Comparator}
+ * contract
+ * @since 1.8
+ */
+ default void sort(Comparator<? super E> c) {
+ Collections.sort(this, c);
+ }
}
diff --git a/ojluni/src/main/java/java/util/Vector.java b/ojluni/src/main/java/java/util/Vector.java
index d51c47e..db80cf2 100755
--- a/ojluni/src/main/java/java/util/Vector.java
+++ b/ojluni/src/main/java/java/util/Vector.java
@@ -27,6 +27,7 @@
import java.util.function.Consumer;
import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
/**
* The {@code Vector} class implements a growable array of
@@ -1406,4 +1407,30 @@
return anyToRemove;
}
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public synchronized void replaceAll(UnaryOperator<E> operator) {
+ Objects.requireNonNull(operator);
+ final int expectedModCount = modCount;
+ final int size = elementCount;
+ for (int i=0; modCount == expectedModCount && i < size; i++) {
+ elementData[i] = operator.apply((E) elementData[i]);
+ }
+ if (modCount != expectedModCount) {
+ throw new ConcurrentModificationException();
+ }
+ modCount++;
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public synchronized void sort(Comparator<? super E> c) {
+ final int expectedModCount = modCount;
+ Arrays.sort((E[]) elementData, 0, elementCount, c);
+ if (modCount != expectedModCount) {
+ throw new ConcurrentModificationException();
+ }
+ modCount++;
+ }
}
diff --git a/ojluni/src/test/artrun b/ojluni/src/test/artrun
new file mode 100755
index 0000000..5315eb7
--- /dev/null
+++ b/ojluni/src/test/artrun
@@ -0,0 +1,126 @@
+#!/usr/bin/env bash
+
+# Copyright (C) 2016 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+
+###
+### Change the BOOTCLASSPATH to pick up bootlib classes.
+### Export ANDROID_DATA=something else (it should have dalvik-cache dir in it)
+### Point the image to something else that's not existing.
+###
+### Actually run dalvikvm now...
+###
+
+if [[ -z $ANDROID_BUILD_TOP ]]; then
+ echo "Run source build/envsetup.sh first" >& 2
+ exit 1
+fi
+
+invoke_with=
+DALVIKVM=dalvikvm
+LIBART=libart.so
+
+function follow_links() {
+ if [ z"$BASH_SOURCE" != z ]; then
+ file="$BASH_SOURCE"
+ else
+ file="$0"
+ fi
+ while [ -h "$file" ]; do
+ # On Mac OS, readlink -f doesn't work.
+ file="$(readlink "$file")"
+ done
+ echo "$file"
+}
+
+function find_libdir() {
+ # Use realpath instead of readlink because Android does not have a readlink.
+ if [ "$(realpath "$ANDROID_ROOT/bin/$DALVIKVM")" = "$(realpath "$ANDROID_ROOT/bin/dalvikvm64")" ]; then
+ echo "lib64"
+ else
+ echo "lib"
+ fi
+}
+
+function join { local IFS="$1"; shift; echo "$*"; }
+
+PROG_NAME="$(follow_links)"
+PROG_DIR="$(cd "${PROG_NAME%/*}" ; pwd -P)"
+
+if [[ -z $ANDROID_ROOT ]]; then
+ # Already set to /system for actual android devices
+ ANDROID_ROOT=$ANDROID_HOST_OUT
+fi
+LIBDIR=$(find_libdir)
+LD_LIBRARY_PATH=$ANDROID_ROOT/$LIBDIR
+DEBUG_OPTION=""
+
+
+DELETE_ANDROID_DATA=false
+# If ANDROID_DATA is the system ANDROID_DATA or is not set, use our own,
+# and ensure we delete it at the end.
+if [ "$ANDROID_DATA" = "/data" ] || [ "$ANDROID_DATA" = "" ]; then
+ ANDROID_DATA=$PWD/android-data$$
+ IMAGE_DIRECTORY=$ANDROID_DATA/image
+ mkdir -p $ANDROID_DATA/dalvik-cache/{arm,arm64,x86,x86_64}
+ mkdir -p $IMAGE_DIRECTORY
+ DELETE_ANDROID_DATA=true
+fi
+
+
+IMAGE_LOCATION=$IMAGE_DIRECTORY/core-extrabootclasspath.art
+
+BOOT_DEXJARS=(
+bouncycastle-hostdex.jar
+apache-xml-hostdex.jar
+core-tests-hostdex.jar
+core-libart-hostdex.jar
+core-lambda-stubs-hostdex.jar
+conscrypt-hostdex.jar
+core-ojtests-hostdex.jar
+core-oj-hostdex.jar
+okhttp-hostdex.jar)
+
+BOOT_DEXJAR_PREFIX="$ANDROID_ROOT/framework"
+
+BOOT_DEXJARS_ABS=()
+for dexjar in ${BOOT_DEXJARS[@]}; do
+ BOOT_DEXJARS_ABS=(${BOOT_DEXJARS_ABS[@]} $BOOT_DEXJAR_PREFIX/$dexjar)
+done
+
+export BOOTCLASSPATH=$(join ":" "${BOOT_DEXJARS_ABS[@]}") # a,b,c
+
+echo "BOOTCLASSPATH=$BOOTCLASSPATH"
+echo "PROG_NAME=$PROG_NAME"
+echo "PROG_DIR=$PROG_DIR"
+echo "ANDROID_ROOT=$ANDROID_ROOT"
+echo "LIBDIR=$LIBDIR"
+echo "LD_LIBRARY_PATH=$LD_LIBRARY_PATH"
+echo "DEBUG_OPTION=$DEBUG_OPTION"
+
+echo "export BOOTCLASSPATH=$BOOTCLASSPATH"
+echo export ANDROID_ROOT="$ANDROID_ROOT"
+ANDROID_DATA=$ANDROID_DATA \
+ ANDROID_ROOT=$ANDROID_ROOT \
+ LD_LIBRARY_PATH=$LD_LIBRARY_PATH \
+ PATH=$ANDROID_ROOT/bin:$PATH \
+ LD_USE_LOAD_BIAS=1 \
+ $invoke_with $ANDROID_ROOT/bin/$DALVIKVM $lib \
+ -XXlib:$LIBART \
+ -Xnorelocate \
+ -Ximage:$IMAGE_LOCATION \
+ $DEBUG_OPTION \
+ "$@"
diff --git a/ojluni/src/test/artrun-testng b/ojluni/src/test/artrun-testng
new file mode 100755
index 0000000..93c9b3d
--- /dev/null
+++ b/ojluni/src/test/artrun-testng
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+
+# Copyright (C) 2016 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+./artrun org.testng.TestNG -verbose 3 ./testng.xml
diff --git a/ojluni/src/test/gen-test-list b/ojluni/src/test/gen-test-list
new file mode 100755
index 0000000..b7f3f74
--- /dev/null
+++ b/ojluni/src/test/gen-test-list
@@ -0,0 +1,86 @@
+#!/usr/bin/env bash
+
+# Copyright (C) 2016 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+###
+### Scan this directory for any testng classes
+### Outputs a testng.xml formatted list of classes
+###
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+test_property_files="$(find "$DIR" -name TEST.properties)"
+
+function debug_print {
+ if [[ $DEBUG == "true" ]]; then
+ echo "DEBUG:" "$@" >& 2
+ fi
+}
+
+function error_print {
+ echo "ERROR:" "$@" >& 2
+ exit 1
+}
+
+function class_name_from_class_file {
+ # Reads a list of .java files from stdin, spits out their fully qualified class name.
+ local file_name
+ local package_string
+ local package_name
+ local class_name
+ while read file_name; do
+ package_string="$(grep "package" "$file_name")"
+ [[ $? -ne 0 ]] && error_print "File $file_name missing package declaration."
+ debug_print "File: $file_name"
+
+ # Parse the package name by looking inside of the file.
+ package_name=${package_string#package[[:space:]]*} # remove package followed by any spaces
+ package_name=${package_name%;} # remove semicolon at the end
+
+ # Assumes class name == file name. Almost always the case.
+ class_name="$(basename "$file_name")"
+ class_name="${class_name%.java}" # remove ".java" from the end
+ debug_print "Package: <$package_name>"
+
+ echo "$package_name.$class_name"
+ done
+}
+
+function list_classes_in_dir {
+ find "$1" -name "*.java" | class_name_from_class_file
+}
+
+function list_all_classes {
+ local file
+ for file in $test_property_files; do
+ debug_print "File: $file"
+
+ if ! grep "TestNG.dirs" "$file" > /dev/null; then
+ continue
+ fi
+
+ debug_print "Has TestNG files"
+
+ list_classes_in_dir "$(dirname "$file")"
+ done
+}
+
+function class_name_to_testng_entry {
+ local class_name
+ while read class_name; do
+ echo "<class name=\"$class_name\" />"
+ done
+}
+
+list_all_classes | class_name_to_testng_entry
diff --git a/ojluni/src/test/java/util/stream/TestDoubleSumAverage.java b/ojluni/src/test/java/util/stream/TestDoubleSumAverage.java
new file mode 100644
index 0000000..e8df2e9
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/TestDoubleSumAverage.java
@@ -0,0 +1,169 @@
+/*
+ * 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.
+ */
+
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.*;
+
+import static java.lang.Double.*;
+
+/*
+ * @test
+ * @bug 8006572 8030212
+ * @summary Test for use of non-naive summation in stream-related sum and average operations.
+ */
+public class TestDoubleSumAverage {
+ public static void main(String... args) {
+ int failures = 0;
+
+ failures += testZeroAverageOfNonEmptyStream();
+ failures += testForCompenstation();
+ failures += testNonfiniteSum();
+
+ if (failures > 0) {
+ throw new RuntimeException("Found " + failures + " numerical failure(s).");
+ }
+ }
+
+ /**
+ * Test to verify that a non-empty stream with a zero average is non-empty.
+ */
+ private static int testZeroAverageOfNonEmptyStream() {
+ Supplier<DoubleStream> ds = () -> DoubleStream.iterate(0.0, e -> 0.0).limit(10);
+
+ return compareUlpDifference(0.0, ds.get().average().getAsDouble(), 0);
+ }
+
+ /**
+ * Compute the sum and average of a sequence of double values in
+ * various ways and report an error if naive summation is used.
+ */
+ private static int testForCompenstation() {
+ int failures = 0;
+
+ /*
+ * The exact sum of the test stream is 1 + 1e6*ulp(1.0) but a
+ * naive summation algorithm will return 1.0 since (1.0 +
+ * ulp(1.0)/2) will round to 1.0 again.
+ */
+ double base = 1.0;
+ double increment = Math.ulp(base)/2.0;
+ int count = 1_000_001;
+
+ double expectedSum = base + (increment * (count - 1));
+ double expectedAvg = expectedSum / count;
+
+ // Factory for double a stream of [base, increment, ..., increment] limited to a size of count
+ Supplier<DoubleStream> ds = () -> DoubleStream.iterate(base, e -> increment).limit(count);
+
+ DoubleSummaryStatistics stats = ds.get().collect(DoubleSummaryStatistics::new,
+ DoubleSummaryStatistics::accept,
+ DoubleSummaryStatistics::combine);
+
+ failures += compareUlpDifference(expectedSum, stats.getSum(), 3);
+ failures += compareUlpDifference(expectedAvg, stats.getAverage(), 3);
+
+ failures += compareUlpDifference(expectedSum,
+ ds.get().sum(), 3);
+ failures += compareUlpDifference(expectedAvg,
+ ds.get().average().getAsDouble(), 3);
+
+ failures += compareUlpDifference(expectedSum,
+ ds.get().boxed().collect(Collectors.summingDouble(d -> d)), 3);
+ failures += compareUlpDifference(expectedAvg,
+ ds.get().boxed().collect(Collectors.averagingDouble(d -> d)),3);
+ return failures;
+ }
+
+ private static int testNonfiniteSum() {
+ int failures = 0;
+
+ Map<Supplier<DoubleStream>, Double> testCases = new LinkedHashMap<>();
+ testCases.put(() -> DoubleStream.of(MAX_VALUE, MAX_VALUE), POSITIVE_INFINITY);
+ testCases.put(() -> DoubleStream.of(-MAX_VALUE, -MAX_VALUE), NEGATIVE_INFINITY);
+
+ testCases.put(() -> DoubleStream.of(1.0d, POSITIVE_INFINITY, 1.0d), POSITIVE_INFINITY);
+ testCases.put(() -> DoubleStream.of(POSITIVE_INFINITY), POSITIVE_INFINITY);
+ testCases.put(() -> DoubleStream.of(POSITIVE_INFINITY, POSITIVE_INFINITY), POSITIVE_INFINITY);
+ testCases.put(() -> DoubleStream.of(POSITIVE_INFINITY, POSITIVE_INFINITY, 0.0), POSITIVE_INFINITY);
+
+ testCases.put(() -> DoubleStream.of(1.0d, NEGATIVE_INFINITY, 1.0d), NEGATIVE_INFINITY);
+ testCases.put(() -> DoubleStream.of(NEGATIVE_INFINITY), NEGATIVE_INFINITY);
+ testCases.put(() -> DoubleStream.of(NEGATIVE_INFINITY, NEGATIVE_INFINITY), NEGATIVE_INFINITY);
+ testCases.put(() -> DoubleStream.of(NEGATIVE_INFINITY, NEGATIVE_INFINITY, 0.0), NEGATIVE_INFINITY);
+
+ testCases.put(() -> DoubleStream.of(1.0d, NaN, 1.0d), NaN);
+ testCases.put(() -> DoubleStream.of(NaN), NaN);
+ testCases.put(() -> DoubleStream.of(1.0d, NEGATIVE_INFINITY, POSITIVE_INFINITY, 1.0d), NaN);
+ testCases.put(() -> DoubleStream.of(1.0d, POSITIVE_INFINITY, NEGATIVE_INFINITY, 1.0d), NaN);
+ testCases.put(() -> DoubleStream.of(POSITIVE_INFINITY, NaN), NaN);
+ testCases.put(() -> DoubleStream.of(NEGATIVE_INFINITY, NaN), NaN);
+ testCases.put(() -> DoubleStream.of(NaN, POSITIVE_INFINITY), NaN);
+ testCases.put(() -> DoubleStream.of(NaN, NEGATIVE_INFINITY), NaN);
+
+ for(Map.Entry<Supplier<DoubleStream>, Double> testCase : testCases.entrySet()) {
+ Supplier<DoubleStream> ds = testCase.getKey();
+ double expected = testCase.getValue();
+
+ DoubleSummaryStatistics stats = ds.get().collect(DoubleSummaryStatistics::new,
+ DoubleSummaryStatistics::accept,
+ DoubleSummaryStatistics::combine);
+
+ failures += compareUlpDifference(expected, stats.getSum(), 0);
+ failures += compareUlpDifference(expected, stats.getAverage(), 0);
+
+ failures += compareUlpDifference(expected, ds.get().sum(), 0);
+ failures += compareUlpDifference(expected, ds.get().average().getAsDouble(), 0);
+
+ failures += compareUlpDifference(expected, ds.get().boxed().collect(Collectors.summingDouble(d -> d)), 0);
+ failures += compareUlpDifference(expected, ds.get().boxed().collect(Collectors.averagingDouble(d -> d)), 0);
+ }
+
+ return failures;
+ }
+
+ /**
+ * Compute the ulp difference of two double values and compare against an error threshold.
+ */
+ private static int compareUlpDifference(double expected, double computed, double threshold) {
+ if (!Double.isFinite(expected)) {
+ // Handle NaN and infinity cases
+ if (Double.compare(expected, computed) == 0)
+ return 0;
+ else {
+ System.err.printf("Unexpected sum, %g rather than %g.%n",
+ computed, expected);
+ return 1;
+ }
+ }
+
+ double ulpDifference = Math.abs(expected - computed) / Math.ulp(expected);
+
+ if (ulpDifference > threshold) {
+ System.err.printf("Numerical summation error too large, %g ulps rather than %g.%n",
+ ulpDifference, threshold);
+ return 1;
+ } else
+ return 0;
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/bootlib/TEST.properties b/ojluni/src/test/java/util/stream/bootlib/TEST.properties
new file mode 100644
index 0000000..a50c2e8
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/TEST.properties
@@ -0,0 +1,3 @@
+# This file identifies root(s) of the test-ng hierarchy.
+
+bootclasspath.dirs = .
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/CollectorOps.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/CollectorOps.java
new file mode 100644
index 0000000..c849415
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/CollectorOps.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.util.stream;
+
+import org.testng.Assert;
+
+import java.util.Spliterator;
+import java.util.function.IntFunction;
+
+/** Test helper class for java.util.stream test framework */
+public final class CollectorOps {
+ private CollectorOps() { }
+
+ public static <E_IN> StatefulTestOp<E_IN> collector() {
+ return new StatefulCollector<>(0, StreamShape.REFERENCE);
+ }
+
+ /* Utility classes for collecting output of intermediate pipeline stages */
+ public static class StatefulCollector<E_IN> implements StatefulTestOp<E_IN> {
+ private final int opFlags;
+ private final StreamShape inputShape;
+
+ public StatefulCollector(int opFlags, StreamShape inputShape) {
+ this.opFlags = opFlags;
+ this.inputShape = inputShape;
+ }
+
+ @Override
+ public StreamShape inputShape() {
+ return inputShape;
+ }
+
+ @Override
+ public StreamShape outputShape() {
+ return inputShape;
+ }
+
+ @Override
+ public int opGetFlags() {
+ return opFlags;
+ }
+
+ @Override
+ public Sink<E_IN> opWrapSink(int flags, boolean parallel, Sink<E_IN> sink) {
+ return sink;
+ }
+
+ @Override
+ public <P_IN> Node<E_IN> opEvaluateParallel(PipelineHelper<E_IN> helper,
+ Spliterator<P_IN> spliterator,
+ IntFunction<E_IN[]> generator) {
+ return helper.evaluate(spliterator, false, generator);
+ }
+ }
+
+ public static class TestParallelSizedOp<T> extends StatefulCollector<T> {
+ public TestParallelSizedOp() {
+ this(StreamShape.REFERENCE);
+ }
+
+ protected TestParallelSizedOp(StreamShape shape) {
+ super(0, shape);
+ }
+
+ @Override
+ public <P_IN> Node<T> opEvaluateParallel(PipelineHelper<T> helper,
+ Spliterator<P_IN> spliterator,
+ IntFunction<T[]> generator) {
+ int flags = helper.getStreamAndOpFlags();
+
+ Assert.assertTrue(StreamOpFlag.SIZED.isKnown(flags));
+ return super.opEvaluateParallel(helper, spliterator, generator);
+ }
+
+ public static class OfInt extends TestParallelSizedOp<Integer> {
+ public OfInt() {
+ super(StreamShape.INT_VALUE);
+ }
+ }
+
+ public static class OfLong extends TestParallelSizedOp<Long> {
+ public OfLong() {
+ super(StreamShape.LONG_VALUE);
+ }
+ }
+
+ public static class OfDouble extends TestParallelSizedOp<Double> {
+ public OfDouble() {
+ super(StreamShape.DOUBLE_VALUE);
+ }
+ }
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestDataProvider.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestDataProvider.java
new file mode 100644
index 0000000..0eb7c87
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestDataProvider.java
@@ -0,0 +1,144 @@
+/*
+ * 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 org.testng.annotations.DataProvider;
+
+import java.util.*;
+import java.util.Spliterators;
+import java.util.function.Supplier;
+
+/** TestNG DataProvider for double-valued streams */
+public class DoubleStreamTestDataProvider {
+ private static final double[] to0 = new double[0];
+ private static final double[] to1 = new double[1];
+ private static final double[] to10 = new double[10];
+ private static final double[] to100 = new double[100];
+ private static final double[] to1000 = new double[1000];
+ private static final double[] reversed = new double[100];
+ private static final double[] ones = new double[100];
+ private static final double[] twice = new double[200];
+ private static final double[] pseudoRandom;
+
+ private static final Object[][] testData;
+ private static final Object[][] spliteratorTestData;
+
+ static {
+ double[][] arrays = {to0, to1, to10, to100, to1000};
+ for (double[] arr : arrays) {
+ for (int i = 0; i < arr.length; i++) {
+ arr[i] = i;
+ }
+ }
+ for (int i = 0; i < reversed.length; i++) {
+ reversed[i] = reversed.length - i;
+ }
+ for (int i = 0; i < ones.length; i++) {
+ ones[i] = 1;
+ }
+ System.arraycopy(to100, 0, twice, 0, to100.length);
+ System.arraycopy(to100, 0, twice, to100.length, to100.length);
+ pseudoRandom = new double[LambdaTestHelpers.LONG_STRING.length()];
+ for (int i = 0; i < LambdaTestHelpers.LONG_STRING.length(); i++) {
+ pseudoRandom[i] = (double) LambdaTestHelpers.LONG_STRING.charAt(i);
+ }
+ }
+
+ static final Object[][] arrays = {
+ {"empty", to0},
+ {"0..1", to1},
+ {"0..10", to10},
+ {"0..100", to100},
+ {"0..1000", to1000},
+ {"100x[1]", ones},
+ {"2x[0..100]", twice},
+ {"reverse 0..100", reversed},
+ {"pseudorandom", pseudoRandom}
+ };
+
+ static {
+ {
+ List<Object[]> list = new ArrayList<>();
+ for (Object[] data : arrays) {
+ final Object name = data[0];
+ final double[] doubles = (double[]) data[1];
+
+ list.add(new Object[]{"array:" + name,
+ TestData.Factory.ofArray("array:" + name, doubles)});
+
+ SpinedBuffer.OfDouble isl = new SpinedBuffer.OfDouble();
+ for (double i : doubles) {
+ isl.accept(i);
+ }
+ list.add(new Object[]{"SpinedList:" + name,
+ TestData.Factory.ofSpinedBuffer("SpinedList:" + name, isl)});
+ }
+ testData = list.toArray(new Object[0][]);
+ }
+
+ {
+ List<Object[]> spliterators = new ArrayList<>();
+ for (Object[] data : arrays) {
+ final Object name = data[0];
+ final double[] doubles = (double[]) data[1];
+
+ SpinedBuffer.OfDouble isl = new SpinedBuffer.OfDouble();
+ for (double i : doubles) {
+ isl.accept(i);
+ }
+
+ spliterators.add(splitDescr("Arrays.s(array):" + name,
+ () -> Arrays.spliterator(doubles)));
+ spliterators.add(splitDescr("Arrays.s(array,o,l):" + name,
+ () -> Arrays.spliterator(doubles, 0, doubles.length / 2)));
+
+ spliterators.add(splitDescr("SpinedBuffer.s():" + name,
+ () -> isl.spliterator()));
+
+ spliterators.add(splitDescr("Primitives.s(SpinedBuffer.iterator(), size):" + name,
+ () -> Spliterators.spliterator(isl.iterator(), doubles.length, 0)));
+ spliterators.add(splitDescr("Primitives.s(SpinedBuffer.iterator()):" + name,
+ () -> Spliterators.spliteratorUnknownSize(isl.iterator(), 0)));
+ // Need more!
+ }
+ spliteratorTestData = spliterators.toArray(new Object[0][]);
+ }
+
+ }
+
+ static <T> Object[] splitDescr(String description, Supplier<Spliterator.OfDouble> s) {
+ return new Object[] { description, s };
+ }
+
+ // Return an array of ( String name, DoubleStreamTestData )
+ @DataProvider(name = "DoubleStreamTestData")
+ public static Object[][] makeDoubleStreamTestData() {
+ return testData;
+ }
+
+ // returns an array of (String name, Supplier<PrimitiveSpliterator<Double>>)
+ @DataProvider(name = "DoubleSpliterator")
+ public static Object[][] spliteratorProvider() {
+ return spliteratorTestData;
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java
new file mode 100644
index 0000000..1811a4b
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 2013, 2015, 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.Collections;
+import java.util.EnumSet;
+import java.util.PrimitiveIterator;
+import java.util.Set;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+import java.util.function.DoubleConsumer;
+import java.util.function.Function;
+
+/**
+ * Test scenarios for double streams.
+ *
+ * Each scenario is provided with a data source, a function that maps a fresh
+ * stream (as provided by the data source) to a new stream, and a sink to
+ * receive results. Each scenario describes a different way of computing the
+ * stream contents. The test driver will ensure that all scenarios produce
+ * the same output (modulo allowable differences in ordering).
+ */
+@SuppressWarnings({"rawtypes", "unchecked"})
+public enum DoubleStreamTestScenario implements OpTestCase.BaseStreamTestScenario {
+
+ STREAM_FOR_EACH_WITH_CLOSE(false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, DoubleConsumer b, Function<S_IN, DoubleStream> m) {
+ DoubleStream s = m.apply(data.stream());
+ if (s.isParallel()) {
+ s = s.sequential();
+ }
+ s.forEach(b);
+ s.close();
+ }
+ },
+
+ STREAM_TO_ARRAY(false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, DoubleConsumer b, Function<S_IN, DoubleStream> m) {
+ for (double t : m.apply(data.stream()).toArray()) {
+ b.accept(t);
+ }
+ }
+ },
+
+ STREAM_ITERATOR(false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, DoubleConsumer b, Function<S_IN, DoubleStream> m) {
+ for (PrimitiveIterator.OfDouble seqIter = m.apply(data.stream()).iterator(); seqIter.hasNext(); )
+ b.accept(seqIter.nextDouble());
+ }
+ },
+
+ // Wrap as stream, and spliterate then iterate in pull mode
+ STREAM_SPLITERATOR(false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, DoubleConsumer b, Function<S_IN, DoubleStream> m) {
+ for (Spliterator.OfDouble spl = m.apply(data.stream()).spliterator(); spl.tryAdvance(b); ) {
+ }
+ }
+ },
+
+ // Wrap as stream, spliterate, then split a few times mixing advances with forEach
+ STREAM_SPLITERATOR_WITH_MIXED_TRAVERSE_AND_SPLIT(false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, DoubleConsumer b, Function<S_IN, DoubleStream> m) {
+ SpliteratorTestHelper.mixedTraverseAndSplit(b, m.apply(data.stream()).spliterator());
+ }
+ },
+
+ // Wrap as stream, and spliterate then iterate in pull mode
+ STREAM_SPLITERATOR_FOREACH(false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, DoubleConsumer b, Function<S_IN, DoubleStream> m) {
+ m.apply(data.stream()).spliterator().forEachRemaining(b);
+ }
+ },
+
+ PAR_STREAM_SEQUENTIAL_FOR_EACH(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, DoubleConsumer b, Function<S_IN, DoubleStream> m) {
+ m.apply(data.parallelStream()).sequential().forEach(b);
+ }
+ },
+
+ // Wrap as parallel stream + forEachOrdered
+ PAR_STREAM_FOR_EACH_ORDERED(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, DoubleConsumer b, Function<S_IN, DoubleStream> m) {
+ // @@@ Want to explicitly select ordered equalator
+ m.apply(data.parallelStream()).forEachOrdered(b);
+ }
+ },
+
+ // Wrap as stream, and spliterate then iterate sequentially
+ PAR_STREAM_SPLITERATOR(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, DoubleConsumer b, Function<S_IN, DoubleStream> m) {
+ for (Spliterator.OfDouble spl = m.apply(data.parallelStream()).spliterator(); spl.tryAdvance(b); ) {
+ }
+ }
+ },
+
+ // Wrap as stream, and spliterate then iterate sequentially
+ PAR_STREAM_SPLITERATOR_FOREACH(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, DoubleConsumer b, Function<S_IN, DoubleStream> m) {
+ m.apply(data.parallelStream()).spliterator().forEachRemaining(b);
+ }
+ },
+
+ PAR_STREAM_TO_ARRAY(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, DoubleConsumer b, Function<S_IN, DoubleStream> m) {
+ for (double t : m.apply(data.parallelStream()).toArray())
+ b.accept(t);
+ }
+ },
+
+ // Wrap as parallel stream, get the spliterator, wrap as a stream + toArray
+ PAR_STREAM_SPLITERATOR_STREAM_TO_ARRAY(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, DoubleConsumer b, Function<S_IN, DoubleStream> m) {
+ DoubleStream s = m.apply(data.parallelStream());
+ Spliterator.OfDouble sp = s.spliterator();
+ DoubleStream ss = StreamSupport.doubleStream(() -> sp,
+ StreamOpFlag.toCharacteristics(OpTestCase.getStreamFlags(s))
+ | (sp.getExactSizeIfKnown() < 0 ? 0 : Spliterator.SIZED), true);
+ for (double t : ss.toArray())
+ b.accept(t);
+ }
+ },
+
+ PAR_STREAM_TO_ARRAY_CLEAR_SIZED(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, DoubleConsumer b, Function<S_IN, DoubleStream> m) {
+ S_IN pipe1 = (S_IN) OpTestCase.chain(data.parallelStream(),
+ new FlagDeclaringOp(StreamOpFlag.NOT_SIZED, data.getShape()));
+ DoubleStream pipe2 = m.apply(pipe1);
+
+ for (double t : pipe2.toArray())
+ b.accept(t);
+ }
+ },
+
+ // Wrap as parallel stream + forEach synchronizing
+ PAR_STREAM_FOR_EACH(true, false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, DoubleConsumer b, Function<S_IN, DoubleStream> m) {
+ m.apply(data.parallelStream()).forEach(e -> {
+ synchronized (data) {
+ b.accept(e);
+ }
+ });
+ }
+ },
+
+ // Wrap as parallel stream + forEach synchronizing and clear SIZED flag
+ PAR_STREAM_FOR_EACH_CLEAR_SIZED(true, false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, DoubleConsumer b, Function<S_IN, DoubleStream> m) {
+ S_IN pipe1 = (S_IN) OpTestCase.chain(data.parallelStream(),
+ new FlagDeclaringOp(StreamOpFlag.NOT_SIZED, data.getShape()));
+ m.apply(pipe1).forEach(e -> {
+ synchronized (data) {
+ b.accept(e);
+ }
+ });
+ }
+ },
+ ;
+
+ // The set of scenarios that clean the SIZED flag
+ public static final Set<DoubleStreamTestScenario> CLEAR_SIZED_SCENARIOS = Collections.unmodifiableSet(
+ EnumSet.of(PAR_STREAM_TO_ARRAY_CLEAR_SIZED, PAR_STREAM_FOR_EACH_CLEAR_SIZED));
+
+ private boolean isParallel;
+
+ private final boolean isOrdered;
+
+ DoubleStreamTestScenario(boolean isParallel) {
+ this(isParallel, true);
+ }
+
+ DoubleStreamTestScenario(boolean isParallel, boolean isOrdered) {
+ this.isParallel = isParallel;
+ this.isOrdered = isOrdered;
+ }
+
+ public StreamShape getShape() {
+ return StreamShape.DOUBLE_VALUE;
+ }
+
+ public boolean isParallel() {
+ return isParallel;
+ }
+
+ public boolean isOrdered() {
+ return isOrdered;
+ }
+
+ public <T, U, S_IN extends BaseStream<T, S_IN>, S_OUT extends BaseStream<U, S_OUT>>
+ void run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, S_OUT> m) {
+ _run(data, (DoubleConsumer) b, (Function<S_IN, DoubleStream>) m);
+ }
+
+ abstract <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, DoubleConsumer b, Function<S_IN, DoubleStream> m);
+
+}
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/FlagDeclaringOp.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/FlagDeclaringOp.java
new file mode 100644
index 0000000..a9882c8
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/FlagDeclaringOp.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.util.stream;
+
+/**
+ * An operation that injects or clears flags but otherwise performs no operation on elements.
+ */
+@SuppressWarnings({"rawtypes", "unchecked"})
+public class FlagDeclaringOp<T> implements StatelessTestOp<T, T> {
+ private final int flags;
+ private final StreamShape shape;
+
+ public FlagDeclaringOp(int flags) {
+ this(flags, StreamShape.REFERENCE);
+ }
+
+ public FlagDeclaringOp(int flags, StreamShape shape) {
+ this.flags = flags;
+ this.shape = shape;
+ }
+
+ @Override
+ public StreamShape outputShape() {
+ return shape;
+ }
+
+ @Override
+ public StreamShape inputShape() {
+ return shape;
+ }
+
+ @Override
+ public int opGetFlags() {
+ return flags;
+ }
+
+ @Override
+ public Sink<T> opWrapSink(int flags, boolean parallel, Sink sink) {
+ return sink;
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/IntStreamTestDataProvider.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/IntStreamTestDataProvider.java
new file mode 100644
index 0000000..dded670
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/IntStreamTestDataProvider.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.util.stream;
+
+import org.testng.annotations.DataProvider;
+
+import java.util.*;
+import java.util.Spliterators;
+import java.util.function.Supplier;
+
+/** TestNG DataProvider for int-valued streams */
+public class IntStreamTestDataProvider {
+ private static final int[] to0 = new int[0];
+ private static final int[] to1 = new int[1];
+ private static final int[] to10 = new int[10];
+ private static final int[] to100 = new int[100];
+ private static final int[] to1000 = new int[1000];
+ private static final int[] reversed = new int[100];
+ private static final int[] ones = new int[100];
+ private static final int[] twice = new int[200];
+ private static final int[] pseudoRandom;
+
+ private static final Object[][] testData;
+ private static final Object[][] spliteratorTestData;
+
+ static {
+ int[][] arrays = {to0, to1, to10, to100, to1000};
+ for (int[] arr : arrays) {
+ for (int i = 0; i < arr.length; i++) {
+ arr[i] = i;
+ }
+ }
+ for (int i = 0; i < reversed.length; i++) {
+ reversed[i] = reversed.length - i;
+ }
+ for (int i = 0; i < ones.length; i++) {
+ ones[i] = 1;
+ }
+ System.arraycopy(to100, 0, twice, 0, to100.length);
+ System.arraycopy(to100, 0, twice, to100.length, to100.length);
+ pseudoRandom = new int[LambdaTestHelpers.LONG_STRING.length()];
+ for (int i = 0; i < LambdaTestHelpers.LONG_STRING.length(); i++) {
+ pseudoRandom[i] = (int) LambdaTestHelpers.LONG_STRING.charAt(i);
+ }
+ }
+
+ static final Object[][] arrays = {
+ {"empty", to0},
+ {"0..1", to1},
+ {"0..10", to10},
+ {"0..100", to100},
+ {"0..1000", to1000},
+ {"100x[1]", ones},
+ {"2x[0..100]", twice},
+ {"reverse 0..100", reversed},
+ {"pseudorandom", pseudoRandom}
+ };
+
+ static {
+ {
+ List<Object[]> list = new ArrayList<>();
+ for (Object[] data : arrays) {
+ final Object name = data[0];
+ final int[] ints = (int[]) data[1];
+
+ list.add(new Object[]{"array:" +
+ name, TestData.Factory.ofArray("array:" + name, ints)});
+
+ SpinedBuffer.OfInt isl = new SpinedBuffer.OfInt();
+ for (int i : ints) {
+ isl.accept(i);
+ }
+ list.add(new Object[]{"SpinedList:" + name,
+ TestData.Factory.ofSpinedBuffer("SpinedList:" + name, isl)});
+
+ list.add(streamDataDescr("IntStream.intRange(0,l): " + ints.length,
+ () -> IntStream.range(0, ints.length)));
+ list.add(streamDataDescr("IntStream.rangeClosed(0,l): " + ints.length,
+ () -> IntStream.rangeClosed(0, ints.length)));
+ }
+ testData = list.toArray(new Object[0][]);
+ }
+
+ {
+ List<Object[]> spliterators = new ArrayList<>();
+ for (Object[] data : arrays) {
+ final Object name = data[0];
+ final int[] ints = (int[]) data[1];
+
+ SpinedBuffer.OfInt isl = new SpinedBuffer.OfInt();
+ for (int i : ints) {
+ isl.accept(i);
+ }
+
+ spliterators.add(splitDescr("Arrays.s(array):" + name,
+ () -> Arrays.spliterator(ints)));
+ spliterators.add(splitDescr("Arrays.s(array,o,l):" + name,
+ () -> Arrays.spliterator(ints, 0, ints.length / 2)));
+
+ spliterators.add(splitDescr("SpinedBuffer.s():" + name,
+ () -> isl.spliterator()));
+
+ spliterators.add(splitDescr("Primitives.s(SpinedBuffer.iterator(), size):" + name,
+ () -> Spliterators.spliterator(isl.iterator(), ints.length, 0)));
+ spliterators.add(splitDescr("Primitives.s(SpinedBuffer.iterator()):" + name,
+ () -> Spliterators.spliteratorUnknownSize(isl.iterator(), 0)));
+
+ spliterators.add(splitDescr("IntStream.intRange(0,l):" + name,
+ () -> 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][]);
+ }
+
+ }
+
+ static <T> Object[] streamDataDescr(String description, Supplier<IntStream> s) {
+ return new Object[] { description, TestData.Factory.ofIntSupplier(description, s) };
+ }
+
+ static <T> Object[] splitDescr(String description, Supplier<Spliterator.OfInt> s) {
+ return new Object[] { description, s };
+ }
+
+ // Return an array of ( String name, IntStreamTestData )
+ @DataProvider(name = "IntStreamTestData")
+ public static Object[][] makeIntStreamTestData() {
+ return testData;
+ }
+
+ // returns an array of (String name, Supplier<PrimitiveSpliterator<Integer>>)
+ @DataProvider(name = "IntSpliterator")
+ public static Object[][] spliteratorProvider() {
+ return spliteratorTestData;
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java
new file mode 100644
index 0000000..9a3cc44
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) 2012, 2015, 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.Collections;
+import java.util.EnumSet;
+import java.util.PrimitiveIterator;
+import java.util.Set;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.IntConsumer;
+
+/**
+ * Test scenarios for int streams.
+ *
+ * Each scenario is provided with a data source, a function that maps a fresh
+ * stream (as provided by the data source) to a new stream, and a sink to
+ * receive results. Each scenario describes a different way of computing the
+ * stream contents. The test driver will ensure that all scenarios produce
+ * the same output (modulo allowable differences in ordering).
+ */
+@SuppressWarnings({"rawtypes", "unchecked"})
+public enum IntStreamTestScenario implements OpTestCase.BaseStreamTestScenario {
+
+ STREAM_FOR_EACH_WITH_CLOSE(false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, IntConsumer b, Function<S_IN, IntStream> m) {
+ IntStream s = m.apply(data.stream());
+ if (s.isParallel()) {
+ s = s.sequential();
+ }
+ s.forEach(b);
+ s.close();
+ }
+ },
+
+ STREAM_TO_ARRAY(false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, IntConsumer b, Function<S_IN, IntStream> m) {
+ for (int t : m.apply(data.stream()).toArray()) {
+ b.accept(t);
+ }
+ }
+ },
+
+ STREAM_ITERATOR(false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, IntConsumer b, Function<S_IN, IntStream> m) {
+ for (PrimitiveIterator.OfInt seqIter = m.apply(data.stream()).iterator(); seqIter.hasNext(); )
+ b.accept(seqIter.nextInt());
+ }
+ },
+
+ // Wrap as stream, and spliterate then iterate in pull mode
+ STREAM_SPLITERATOR(false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, IntConsumer b, Function<S_IN, IntStream> m) {
+ for (Spliterator.OfInt spl = m.apply(data.stream()).spliterator(); spl.tryAdvance(b); ) {
+ }
+ }
+ },
+
+ // Wrap as stream, spliterate, then split a few times mixing advances with forEach
+ STREAM_SPLITERATOR_WITH_MIXED_TRAVERSE_AND_SPLIT(false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, IntConsumer b, Function<S_IN, IntStream> m) {
+ SpliteratorTestHelper.mixedTraverseAndSplit(b, m.apply(data.stream()).spliterator());
+ }
+ },
+
+ // Wrap as stream, and spliterate then iterate in pull mode
+ STREAM_SPLITERATOR_FOREACH(false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, IntConsumer b, Function<S_IN, IntStream> m) {
+ m.apply(data.stream()).spliterator().forEachRemaining(b);
+ }
+ },
+
+ PAR_STREAM_SEQUENTIAL_FOR_EACH(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, IntConsumer b, Function<S_IN, IntStream> m) {
+ m.apply(data.parallelStream()).sequential().forEach(b);
+ }
+ },
+
+ // Wrap as parallel stream + forEachOrdered
+ PAR_STREAM_FOR_EACH_ORDERED(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, IntConsumer b, Function<S_IN, IntStream> m) {
+ // @@@ Want to explicitly select ordered equalator
+ m.apply(data.parallelStream()).forEachOrdered(b);
+ }
+ },
+
+ // Wrap as stream, and spliterate then iterate sequentially
+ PAR_STREAM_SPLITERATOR(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, IntConsumer b, Function<S_IN, IntStream> m) {
+ for (Spliterator.OfInt spl = m.apply(data.parallelStream()).spliterator(); spl.tryAdvance(b); ) {
+ }
+ }
+ },
+
+ // Wrap as stream, and spliterate then iterate sequentially
+ PAR_STREAM_SPLITERATOR_FOREACH(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, IntConsumer b, Function<S_IN, IntStream> m) {
+ m.apply(data.parallelStream()).spliterator().forEachRemaining(b);
+ }
+ },
+
+ PAR_STREAM_TO_ARRAY(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, IntConsumer b, Function<S_IN, IntStream> m) {
+ for (int t : m.apply(data.parallelStream()).toArray())
+ b.accept(t);
+ }
+ },
+
+ // Wrap as parallel stream, get the spliterator, wrap as a stream + toArray
+ PAR_STREAM_SPLITERATOR_STREAM_TO_ARRAY(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, IntConsumer b, Function<S_IN, IntStream> m) {
+ IntStream s = m.apply(data.parallelStream());
+ Spliterator.OfInt sp = s.spliterator();
+ IntStream ss = StreamSupport.intStream(() -> sp,
+ StreamOpFlag.toCharacteristics(OpTestCase.getStreamFlags(s))
+ | (sp.getExactSizeIfKnown() < 0 ? 0 : Spliterator.SIZED),
+ true);
+ for (int t : ss.toArray())
+ b.accept(t);
+ }
+ },
+
+ PAR_STREAM_TO_ARRAY_CLEAR_SIZED(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, IntConsumer b, Function<S_IN, IntStream> m) {
+ S_IN pipe1 = (S_IN) OpTestCase.chain(data.parallelStream(),
+ new FlagDeclaringOp(StreamOpFlag.NOT_SIZED, data.getShape()));
+ IntStream pipe2 = m.apply(pipe1);
+
+ for (int t : pipe2.toArray())
+ b.accept(t);
+ }
+ },
+
+ // Wrap as parallel stream + forEach synchronizing
+ PAR_STREAM_FOR_EACH(true, false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, IntConsumer b, Function<S_IN, IntStream> m) {
+ m.apply(data.parallelStream()).forEach(e -> {
+ synchronized (data) {
+ b.accept(e);
+ }
+ });
+ }
+ },
+
+ // Wrap as parallel stream + forEach synchronizing and clear SIZED flag
+ PAR_STREAM_FOR_EACH_CLEAR_SIZED(true, false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, IntConsumer b, Function<S_IN, IntStream> m) {
+ S_IN pipe1 = (S_IN) OpTestCase.chain(data.parallelStream(),
+ new FlagDeclaringOp(StreamOpFlag.NOT_SIZED, data.getShape()));
+ m.apply(pipe1).forEach(e -> {
+ synchronized (data) {
+ b.accept(e);
+ }
+ });
+ }
+ },
+ ;
+
+ // The set of scenarios that clean the SIZED flag
+ public static final Set<IntStreamTestScenario> CLEAR_SIZED_SCENARIOS = Collections.unmodifiableSet(
+ EnumSet.of(PAR_STREAM_TO_ARRAY_CLEAR_SIZED, PAR_STREAM_FOR_EACH_CLEAR_SIZED));
+
+ private final boolean isParallel;
+
+ private final boolean isOrdered;
+
+ IntStreamTestScenario(boolean isParallel) {
+ this(isParallel, true);
+ }
+
+ IntStreamTestScenario(boolean isParallel, boolean isOrdered) {
+ this.isParallel = isParallel;
+ this.isOrdered = isOrdered;
+ }
+
+ public StreamShape getShape() {
+ return StreamShape.INT_VALUE;
+ }
+
+ public boolean isParallel() {
+ return isParallel;
+ }
+
+ public boolean isOrdered() {
+ return isOrdered;
+ }
+
+ public <T, U, S_IN extends BaseStream<T, S_IN>, S_OUT extends BaseStream<U, S_OUT>>
+ void run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, S_OUT> m) {
+ _run(data, (IntConsumer) b, (Function<S_IN, IntStream>) m);
+ }
+
+ abstract <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, IntConsumer b, Function<S_IN, IntStream> m);
+
+}
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/IntermediateTestOp.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/IntermediateTestOp.java
new file mode 100644
index 0000000..1ed04c7
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/IntermediateTestOp.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.util.stream;
+
+/**
+ * A base type for test operations
+ */
+interface IntermediateTestOp<E_IN, E_OUT> {
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ public static<T> AbstractPipeline chain(AbstractPipeline upstream,
+ IntermediateTestOp<?, T> op) {
+ if (op instanceof StatelessTestOp)
+ return StatelessTestOp.chain(upstream, (StatelessTestOp) op);
+
+ if (op instanceof StatefulTestOp)
+ return StatefulTestOp.chain(upstream, (StatefulTestOp) op);
+
+ throw new IllegalStateException("Unknown test op type: " + op.getClass().getName());
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/LambdaTestHelpers.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/LambdaTestHelpers.java
new file mode 100644
index 0000000..76a4d72
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/LambdaTestHelpers.java
@@ -0,0 +1,462 @@
+/*
+ * Copyright (c) 1997, 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.*;
+import java.util.function.BiConsumer;
+import java.util.function.BiPredicate;
+import java.util.function.BinaryOperator;
+import java.util.function.Consumer;
+import java.util.function.DoubleBinaryOperator;
+import java.util.function.DoubleConsumer;
+import java.util.function.DoublePredicate;
+import java.util.function.Function;
+import java.util.function.IntBinaryOperator;
+import java.util.function.IntConsumer;
+import java.util.function.IntFunction;
+import java.util.function.IntPredicate;
+import java.util.function.IntUnaryOperator;
+import java.util.function.LongBinaryOperator;
+import java.util.function.LongConsumer;
+import java.util.function.LongPredicate;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.function.ToDoubleFunction;
+import java.util.function.ToIntFunction;
+import java.util.function.ToLongFunction;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertTrue;
+
+/**
+ * LambdaTestHelpers -- assertion methods and useful objects for lambda test cases
+ */
+public class LambdaTestHelpers {
+ public static final String LONG_STRING = "When in the Course of human events it becomes necessary for one people to dissolve the political bands which have connected them with another and to assume among the powers of the earth, the separate and equal station to which the Laws of Nature and of Nature's God entitle them, a decent respect to the opinions of mankind requires that they should declare the causes which impel them to the separation.";
+
+ @SuppressWarnings("rawtypes")
+ public static final Consumer bEmpty = x -> { };
+ @SuppressWarnings("rawtypes")
+ public static final IntConsumer bIntEmpty = x -> { };
+ @SuppressWarnings("rawtypes")
+ public static final BiConsumer bBiEmpty = (x,y) -> { };
+ @SuppressWarnings("rawtypes")
+ public static final Consumer bHashCode = x -> { Objects.hashCode(x); };
+ @SuppressWarnings("rawtypes")
+ public static final BiConsumer bBiHashCode = (x,y) -> { Objects.hash(x, y); };
+ public static final Function<Integer, Integer> mZero = x -> 0;
+ public static final Function<Integer, Integer> mId = x -> x;
+ public static final Function<Integer, Integer> mDoubler = x -> x * 2;
+ public static final Function<Integer, Stream<Integer>> mfId = e -> Collections.singletonList(e).stream();
+ public static final Function<Integer, Stream<Integer>> mfNull = e -> Collections.<Integer>emptyList().stream();
+ public static final Function<Integer, Stream<Integer>> mfLt = e -> {
+ List<Integer> l = new ArrayList<>();
+ for (int i=0; i<e; i++)
+ l.add(i);
+ return l.stream();
+ };
+ public static final ToIntFunction<Integer> imDoubler = x -> x * 2;
+ public static final ToLongFunction<Long> lmDoubler = x -> x * 2;
+ public static final ToDoubleFunction<Double> dmDoubler = x -> x * 2;
+ public static final Predicate<Integer> pFalse = x -> false;
+ public static final Predicate<Integer> pTrue = x -> true;
+ public static final Predicate<Integer> pEven = x -> 0 == x % 2;
+ public static final Predicate<Integer> pOdd = x -> 1 == x % 2;
+ public static final IntPredicate ipFalse = x -> false;
+ public static final IntPredicate ipTrue = x -> true;
+ public static final IntPredicate ipEven = x -> 0 == x % 2;
+ public static final IntPredicate ipOdd = x -> 1 == x % 2;
+ public static final LongPredicate lpFalse = x -> false;
+ public static final LongPredicate lpTrue = x -> true;
+ public static final LongPredicate lpEven = x -> 0 == x % 2;
+ public static final LongPredicate lpOdd = x -> 1 == x % 2;
+ public static final DoublePredicate dpFalse = x -> false;
+ public static final DoublePredicate dpTrue = x -> true;
+ public static final DoublePredicate dpEven = x -> 0 == ((long) x) % 2;
+ public static final DoublePredicate dpOdd = x -> 1 == ((long) x) % 2;
+ public static final BinaryOperator<Integer> rPlus = (x, y) -> x+y;
+ public static final BinaryOperator<Integer> rMax = (x, y) -> Math.max(x, y);
+ public static final BinaryOperator<Integer> rMin = (x, y) -> Math.min(x,y);
+ public static final IntBinaryOperator irPlus = (x, y) -> x+y;
+ public static final IntBinaryOperator irMax = (x, y) -> Math.max(x, y);
+ public static final IntBinaryOperator irMin = (x, y) -> Math.min(x,y);
+ public static final IntUnaryOperator irDoubler = x -> x * 2;
+ public static final LongBinaryOperator lrPlus = (x, y) -> x+y;
+ public static final DoubleBinaryOperator drPlus = (x, y) -> x+y;
+ public static final Comparator<Integer> cInteger = (a, b) -> Integer.compare(a, b);
+ public static final BiPredicate<?, ?> bipFalse = (x, y) -> false;
+ public static final BiPredicate<?, ?> bipTrue = (x, y) -> true;
+ public static final BiPredicate<Integer, Integer> bipBothEven = (x, y) -> 0 == (x % 2 + y % 2);
+ public static final BiPredicate<Integer, Integer> bipBothOdd = (x, y) -> 2 == (x % 2 + y % 2);
+ public static final BiPredicate<?, ?> bipSameString = (x, y) -> String.valueOf(x).equals(String.valueOf(y));
+
+ public static final IntFunction<Integer[]> integerArrayGenerator = s -> new Integer[s];
+
+ public static final IntFunction<Object[]> objectArrayGenerator = s -> new Object[s];
+
+ public static final Function<String, Stream<Character>> flattenChars = string -> {
+ List<Character> l = new ArrayList<>();
+ for (int i=0; i<string.length(); i++)
+ l.add(string.charAt(i));
+ return l.stream();
+ };
+
+ public static final Function<String, IntStream> flattenInt
+ = string -> IntStream.range(0, string.length()).map(string::charAt);
+
+ public static <T, R> Function<T, R> forPredicate(Predicate<? super T> predicate, R forTrue, R forFalse) {
+ Objects.requireNonNull(predicate);
+
+ return t -> predicate.test(t) ? forTrue : forFalse;
+ }
+
+ public static <T> Function<T, T> identity() {
+ return t -> t;
+ }
+
+ public static<V, T, R> Function<V, R> compose(Function<? super T, ? extends R> after, Function<? super V, ? extends T> before) {
+ Objects.requireNonNull(before);
+ return (V v) -> after.apply(before.apply(v));
+ }
+
+ public static List<Integer> empty() {
+ ArrayList<Integer> list = new ArrayList<>();
+ list.add(null);
+ return list;
+ }
+
+ public static List<Integer> countTo(int n) {
+ return range(1, n);
+ }
+
+ public static List<Integer> range(int l, int u) {
+ ArrayList<Integer> list = new ArrayList<>(u - l + 1);
+ for (int i=l; i<=u; i++) {
+ list.add(i);
+ }
+ return list;
+ }
+
+ public static List<Integer> repeat(int value, int n) {
+ ArrayList<Integer> list = new ArrayList<>(n);
+ for (int i=1; i<=n; i++) {
+ list.add(value);
+ }
+ return list;
+ }
+
+ public static List<Double> asDoubles(List<Integer> integers) {
+ ArrayList<Double> list = new ArrayList<>();
+ for (Integer i : integers) {
+ list.add((double) i);
+ }
+ return list;
+ }
+
+ public static List<Long> asLongs(List<Integer> integers) {
+ ArrayList<Long> list = new ArrayList<>();
+ for (Integer i : integers) {
+ list.add((long) i);
+ }
+ return list;
+ }
+
+ public static void assertCountSum(Stream<? super Integer> it, int count, int sum) {
+ assertCountSum(it.iterator(), count, sum);
+ }
+
+ public static void assertCountSum(Iterable<? super Integer> it, int count, int sum) {
+ assertCountSum(it.iterator(), count, sum);
+ }
+
+ public static void assertCountSum(Iterator<? super Integer> it, int count, int sum) {
+ int c = 0;
+ int s = 0;
+ while (it.hasNext()) {
+ int i = (Integer) it.next();
+ c++;
+ s += i;
+ }
+
+ assertEquals(c, count);
+ assertEquals(s, sum);
+ }
+
+ public static void assertConcat(Iterator<Character> it, String result) {
+ StringBuilder sb = new StringBuilder();
+ while (it.hasNext()) {
+ sb.append(it.next());
+ }
+
+ assertEquals(result, sb.toString());
+ }
+
+ public static<T extends Comparable<? super T>> void assertSorted(Iterator<T> i) {
+ i = toBoxedList(i).iterator();
+
+ if (!i.hasNext())
+ return;
+ T last = i.next();
+ while (i.hasNext()) {
+ T t = i.next();
+ assertTrue(last.compareTo(t) <= 0);
+ assertTrue(t.compareTo(last) >= 0);
+ last = t;
+ }
+ }
+
+ public static<T> void assertSorted(Iterator<T> i, Comparator<? super T> comp) {
+ if (i instanceof PrimitiveIterator.OfInt
+ || i instanceof PrimitiveIterator.OfDouble
+ || i instanceof PrimitiveIterator.OfLong) {
+ i = toBoxedList(i).iterator();
+ }
+
+ if (!i.hasNext())
+ return;
+ T last = i.next();
+ while (i.hasNext()) {
+ T t = i.next();
+ assertTrue(comp.compare(last, t) <= 0);
+ assertTrue(comp.compare(t, last) >= 0);
+ last = t;
+ }
+ }
+
+ public static<T extends Comparable<? super T>> void assertSorted(Iterable<T> iter) {
+ assertSorted(iter.iterator());
+ }
+
+ public static<T> void assertSorted(Iterable<T> iter, Comparator<? super T> comp) {
+ assertSorted(iter.iterator(), comp);
+ }
+
+ public static <T> void assertUnique(Iterable<T> iter) {
+ assertUnique(iter.iterator());
+ }
+
+ public static<T> void assertUnique(Iterator<T> iter) {
+ if (!iter.hasNext()) {
+ return;
+ }
+
+ if (iter instanceof PrimitiveIterator.OfInt
+ || iter instanceof PrimitiveIterator.OfDouble
+ || iter instanceof PrimitiveIterator.OfLong) {
+ iter = toBoxedList(iter).iterator();
+ }
+
+ Set<T> uniq = new HashSet<>();
+ while(iter.hasNext()) {
+ T each = iter.next();
+ assertTrue(!uniq.contains(each), "Not unique");
+ uniq.add(each);
+ }
+ }
+
+ public static<T> void assertContents(Iterable<T> actual, Iterable<T> expected) {
+ if (actual instanceof Collection && expected instanceof Collection) {
+ assertEquals(actual, expected);
+ } else {
+ assertContents(actual.iterator(), expected.iterator());
+ }
+ }
+
+ public static<T> void assertContents(Iterator<T> actual, Iterator<T> expected) {
+ assertEquals(toBoxedList(actual), toBoxedList(expected));
+ }
+
+ @SafeVarargs
+ @SuppressWarnings("varargs")
+ public static<T> void assertContents(Iterator<T> actual, T... expected) {
+ assertContents(actual, Arrays.asList(expected).iterator());
+ }
+
+ /**
+ * The all consuming consumer (rampant capitalist) that can accepting a reference or any primitive value.
+ */
+ private static interface OmnivorousConsumer<T>
+ extends Consumer<T>, IntConsumer, LongConsumer, DoubleConsumer { }
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ public static<T> Consumer<T> toBoxingConsumer(Consumer<? super T> c) {
+ return (Consumer<T>) new OmnivorousConsumer() {
+ @Override
+ public void accept(Object t) {
+ c.accept((T) t);
+ }
+
+ @Override
+ public void accept(int t) {
+ accept((Object) t);
+ }
+
+ @Override
+ public void accept(long t) {
+ accept((Object) t);
+ }
+
+ @Override
+ public void accept(double t) {
+ accept((Object) t);
+ }
+ };
+ }
+
+ /**
+ * Convert an iterator to a list using forEach with an implementation of
+ * {@link java.util.stream.LambdaTestHelpers.OmnivorousConsumer}.
+ *
+ * This ensures equality comparisons for test results do not trip
+ * the boxing trip-wires.
+ */
+ private static<T> List<T> toBoxedList(Iterator<T> it) {
+ List<T> l = new ArrayList<>();
+ it.forEachRemaining(toBoxingConsumer(l::add));
+ return l;
+ }
+
+ /**
+ * Convert a spliterator to a list using forEach with an implementation of
+ * {@link java.util.stream.LambdaTestHelpers.OmnivorousConsumer}.
+ *
+ * This ensures equality comparisons for test results do not trip
+ * the boxing trip-wires.
+ */
+ public static<T> List<T> toBoxedList(Spliterator<T> sp) {
+ List<T> l = new ArrayList<>();
+ sp.forEachRemaining(toBoxingConsumer(l::add));
+ return l;
+ }
+
+ /**
+ * Convert an iterator to a multi-set, represented as a Map, using forEach with an implementation of
+ * {@link java.util.stream.LambdaTestHelpers.OmnivorousConsumer}.
+ *
+ * This ensures equality comparisons for test results do not trip
+ * the boxing trip-wires.
+ */
+ @SuppressWarnings("unchecked")
+ private static<T> Map<T, Integer> toBoxedMultiset(Iterator<T> it) {
+ Map<Object, Integer> result = new HashMap<>();
+
+ it.forEachRemaining(toBoxingConsumer(o -> {
+ if (result.containsKey(o))
+ result.put(o, result.get(o) + 1);
+ else
+ result.put(o, 1);
+ }));
+
+ return (Map<T, Integer>) result;
+ }
+
+ @SuppressWarnings("unchecked")
+ public static<T> Map<T, Integer> toBoxedMultiset(Spliterator<T> it) {
+ Map<Object, Integer> result = new HashMap<>();
+
+ it.forEachRemaining(toBoxingConsumer(o -> {
+ if (result.containsKey(o))
+ result.put(o, result.get(o) + 1);
+ else
+ result.put(o, 1);
+ }));
+
+ return (Map<T, Integer>) result;
+ }
+
+ @SuppressWarnings("unchecked")
+ public static void assertContentsEqual(Object a, Object b) {
+ if (a instanceof Iterable && b instanceof Iterable)
+ assertContents((Iterable) a, (Iterable) b);
+ else
+ assertEquals(a, b);
+ }
+
+ public static<T> void assertContentsUnordered(Iterable<T> actual, Iterable<T> expected) {
+ assertContentsUnordered(actual.iterator(), expected.iterator());
+ }
+
+ public static<T> void assertContentsUnordered(Iterator<T> actual, Iterator<T> expected) {
+ assertEquals(toBoxedMultiset(actual), toBoxedMultiset(expected));
+ }
+
+ public static void launderAssertion(Runnable r, Supplier<String> additionalInfo) {
+ try {
+ r.run();
+ }
+ catch (AssertionError ae) {
+ AssertionError cloned = new AssertionError(ae.getMessage() + String.format("%n%s", additionalInfo.get()));
+ cloned.setStackTrace(ae.getStackTrace());
+ if (ae.getCause() != null)
+ cloned.initCause(ae.getCause());
+ throw cloned;
+ }
+ }
+
+ public static <T, S extends BaseStream<T, S>>
+ List<Function<S, S>> permuteStreamFunctions(List<Function<S, S>> opFunctions) {
+ List<List<Function<S, S>>> opFunctionPermutations = perm(opFunctions);
+
+ List<Function<S, S>> appliedFunctions = new ArrayList<>();
+ for (List<Function<S, S>> fs : opFunctionPermutations) {
+ Function<S, S> applied = s -> {
+ for (Function<S, S> f : fs) {
+ s = f.apply(s);
+ }
+ return s;
+ };
+ appliedFunctions.add(applied);
+ }
+
+ return appliedFunctions;
+ }
+
+ private static <T> List<T> sub(List<T> l, int index) {
+ List<T> subL = new ArrayList<>(l);
+ subL.remove(index);
+ return subL;
+ }
+
+ public static <T> List<List<T>> perm(List<T> l) {
+ List<List<T>> result = new ArrayList<>();
+ for (int i = 0; i < l.size(); i++) {
+ for (List<T> perm : perm(sub(l, i))) {
+ perm.add(0, l.get(i));
+ result.add(perm);
+ }
+ }
+ result.add(new ArrayList<T>());
+
+ return result;
+ }
+
+ public static String flagsToString(int flags) {
+ StringJoiner sj = new StringJoiner(", ", "StreamOpFlag[", "]");
+ if (StreamOpFlag.DISTINCT.isKnown(flags)) sj.add("IS_DISTINCT");
+ if (StreamOpFlag.ORDERED.isKnown(flags)) sj.add("IS_ORDERED");
+ if (StreamOpFlag.SIZED.isKnown(flags)) sj.add("IS_SIZED");
+ if (StreamOpFlag.SORTED.isKnown(flags)) sj.add("IS_SORTED");
+ if (StreamOpFlag.SHORT_CIRCUIT.isKnown(flags)) sj.add("IS_SHORT_CIRCUIT");
+ return sj.toString();
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/LambdaTestMode.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/LambdaTestMode.java
new file mode 100644
index 0000000..b598964
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/LambdaTestMode.java
@@ -0,0 +1,71 @@
+/*
+ * 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;
+
+/**
+ * Runtime modes of test execution.
+ */
+public enum LambdaTestMode {
+ /**
+ * Execution mode with no particular runtime constraints.
+ */
+ NORMAL,
+
+ /**
+ * Execution mode where tests are executed for testing lambda serialization
+ * and deserialization.
+ *
+ * <p>This mode may be queried by tests or data supplied by data
+ * providers, which cannot otherwise be assigned to the test group
+ * <em>serialization-hostile</em>, to not execute or declare
+ * serialization-hostile code or data.
+ *
+ * <p>This mode is enabled if the boolean system property
+ * {@code org.openjdk.java.util.stream.sand.mode} is declared with a
+ * {@code true} value.
+ */
+ SERIALIZATION;
+
+ /**
+ * {@code true} if tests are executed in the mode for testing lambda
+ * Serialization ANd Deserialization (SAND).
+ */
+ private static final boolean IS_LAMBDA_SERIALIZATION_MODE =
+ Boolean.getBoolean("org.openjdk.java.util.stream.sand.mode");
+
+ /**
+ *
+ * @return the mode of test execution.
+ */
+ public static LambdaTestMode getMode() {
+ return IS_LAMBDA_SERIALIZATION_MODE ? SERIALIZATION : NORMAL;
+ }
+
+ /**
+ *
+ * @return {@code true} if normal test mode.
+ */
+ public static boolean isNormalMode() {
+ return getMode() == NORMAL;
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/LoggingTestCase.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/LoggingTestCase.java
new file mode 100644
index 0000000..a0f2219
--- /dev/null
+++ b/ojluni/src/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<String, Object> context = new HashMap<>();
+
+ @BeforeMethod
+ public void before() {
+ context.clear();
+ }
+
+ @AfterMethod
+ public void after(ITestResult result) {
+ if (!result.isSuccess()) {
+ List<Object> 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/ojluni/src/test/java/util/stream/bootlib/java/util/stream/LongStreamTestDataProvider.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/LongStreamTestDataProvider.java
new file mode 100644
index 0000000..4ce7ae6
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/LongStreamTestDataProvider.java
@@ -0,0 +1,158 @@
+/*
+ * 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 org.testng.annotations.DataProvider;
+
+import java.util.*;
+import java.util.Spliterators;
+import java.util.function.Supplier;
+
+/** TestNG DataProvider for long-valued streams */
+public class LongStreamTestDataProvider {
+ private static final long[] to0 = new long[0];
+ private static final long[] to1 = new long[1];
+ private static final long[] to10 = new long[10];
+ private static final long[] to100 = new long[100];
+ private static final long[] to1000 = new long[1000];
+ private static final long[] reversed = new long[100];
+ private static final long[] ones = new long[100];
+ private static final long[] twice = new long[200];
+ private static final long[] pseudoRandom;
+
+ private static final Object[][] testData;
+ private static final Object[][] spliteratorTestData;
+
+ static {
+ long[][] arrays = {to0, to1, to10, to100, to1000};
+ for (long[] arr : arrays) {
+ for (int i = 0; i < arr.length; i++) {
+ arr[i] = i;
+ }
+ }
+ for (int i = 0; i < reversed.length; i++) {
+ reversed[i] = reversed.length - i;
+ }
+ for (int i = 0; i < ones.length; i++) {
+ ones[i] = 1;
+ }
+ System.arraycopy(to100, 0, twice, 0, to100.length);
+ System.arraycopy(to100, 0, twice, to100.length, to100.length);
+ pseudoRandom = new long[LambdaTestHelpers.LONG_STRING.length()];
+ for (int i = 0; i < LambdaTestHelpers.LONG_STRING.length(); i++) {
+ pseudoRandom[i] = (long) LambdaTestHelpers.LONG_STRING.charAt(i);
+ }
+ }
+
+ static final Object[][] arrays = {
+ {"empty", to0},
+ {"0..1", to1},
+ {"0..10", to10},
+ {"0..100", to100},
+ {"0..1000", to1000},
+ {"100x[1]", ones},
+ {"2x[0..100]", twice},
+ {"reverse 0..100", reversed},
+ {"pseudorandom", pseudoRandom}
+ };
+
+ static {
+ {
+ List<Object[]> list = new ArrayList<>();
+ for (Object[] data : arrays) {
+ final Object name = data[0];
+ final long[] longs = (long[]) data[1];
+
+ list.add(new Object[]{"array:" + name,
+ TestData.Factory.ofArray("array:" + name, longs)});
+
+ SpinedBuffer.OfLong isl = new SpinedBuffer.OfLong();
+ for (long i : longs) {
+ isl.accept(i);
+ }
+ list.add(new Object[]{"SpinedList:" + name,
+ TestData.Factory.ofSpinedBuffer("SpinedList:" + name, isl)});
+
+ list.add(streamDataDescr("LongStream.longRange(0,l): " + longs.length,
+ () -> LongStream.range(0, longs.length)));
+ list.add(streamDataDescr("LongStream.longRangeClosed(0,l): " + longs.length,
+ () -> LongStream.rangeClosed(0, longs.length)));
+ }
+ testData = list.toArray(new Object[0][]);
+ }
+
+ {
+ List<Object[]> spliterators = new ArrayList<>();
+ for (Object[] data : arrays) {
+ final Object name = data[0];
+ final long[] longs = (long[]) data[1];
+
+ SpinedBuffer.OfLong isl = new SpinedBuffer.OfLong();
+ for (long i : longs) {
+ isl.accept(i);
+ }
+
+ spliterators.add(splitDescr("Arrays.s(array):" + name,
+ () -> Arrays.spliterator(longs)));
+ spliterators.add(splitDescr("Arrays.s(array,o,l):" + name,
+ () -> Arrays.spliterator(longs, 0, longs.length / 2)));
+
+ spliterators.add(splitDescr("SpinedBuffer.s():" + name,
+ () -> isl.spliterator()));
+
+ spliterators.add(splitDescr("Primitives.s(SpinedBuffer.iterator(), size):" + name,
+ () -> Spliterators.spliterator(isl.iterator(), longs.length, 0)));
+ spliterators.add(splitDescr("Primitives.s(SpinedBuffer.iterator()):" + name,
+ () -> Spliterators.spliteratorUnknownSize(isl.iterator(), 0)));
+
+ spliterators.add(splitDescr("LongStream.longRange(0,l):" + name,
+ () -> LongStream.range(0, longs.length).spliterator()));
+ spliterators.add(splitDescr("LongStream.longRangeClosed(0,l):" + name,
+ () -> LongStream.rangeClosed(0, longs.length).spliterator()));
+ // Need more!
+ }
+ spliteratorTestData = spliterators.toArray(new Object[0][]);
+ }
+
+ }
+
+ static <T> Object[] streamDataDescr(String description, Supplier<LongStream> s) {
+ return new Object[] { description, TestData.Factory.ofLongSupplier(description, s) };
+ }
+
+ static <T> Object[] splitDescr(String description, Supplier<Spliterator.OfLong> s) {
+ return new Object[] { description, s };
+ }
+
+ // Return an array of ( String name, LongStreamTestData )
+ @DataProvider(name = "LongStreamTestData")
+ public static Object[][] makeLongStreamTestData() {
+ return testData;
+ }
+
+ // returns an array of (String name, Supplier<PrimitiveSpliterator<Long>>)
+ @DataProvider(name = "LongSpliterator")
+ public static Object[][] spliteratorProvider() {
+ return spliteratorTestData;
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java
new file mode 100644
index 0000000..6d3e104
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 2013, 2015, 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.Collections;
+import java.util.EnumSet;
+import java.util.PrimitiveIterator;
+import java.util.Set;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.LongConsumer;
+
+/**
+ * Test scenarios for long streams.
+ *
+ * Each scenario is provided with a data source, a function that maps a fresh
+ * stream (as provided by the data source) to a new stream, and a sink to
+ * receive results. Each scenario describes a different way of computing the
+ * stream contents. The test driver will ensure that all scenarios produce
+ * the same output (modulo allowable differences in ordering).
+ */
+@SuppressWarnings({"rawtypes", "unchecked"})
+public enum LongStreamTestScenario implements OpTestCase.BaseStreamTestScenario {
+
+ STREAM_FOR_EACH_WITH_CLOSE(false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, LongConsumer b, Function<S_IN, LongStream> m) {
+ LongStream s = m.apply(data.stream());
+ if (s.isParallel()) {
+ s = s.sequential();
+ }
+ s.forEach(b);
+ s.close();
+ }
+ },
+
+ STREAM_TO_ARRAY(false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, LongConsumer b, Function<S_IN, LongStream> m) {
+ for (long t : m.apply(data.stream()).toArray()) {
+ b.accept(t);
+ }
+ }
+ },
+
+ STREAM_ITERATOR(false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, LongConsumer b, Function<S_IN, LongStream> m) {
+ for (PrimitiveIterator.OfLong seqIter = m.apply(data.stream()).iterator(); seqIter.hasNext(); )
+ b.accept(seqIter.nextLong());
+ }
+ },
+
+ // Wrap as stream, and spliterate then iterate in pull mode
+ STREAM_SPLITERATOR(false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, LongConsumer b, Function<S_IN, LongStream> m) {
+ for (Spliterator.OfLong spl = m.apply(data.stream()).spliterator(); spl.tryAdvance(b); ) {
+ }
+ }
+ },
+
+ // Wrap as stream, spliterate, then split a few times mixing advances with forEach
+ STREAM_SPLITERATOR_WITH_MIXED_TRAVERSE_AND_SPLIT(false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, LongConsumer b, Function<S_IN, LongStream> m) {
+ SpliteratorTestHelper.mixedTraverseAndSplit(b, m.apply(data.stream()).spliterator());
+ }
+ },
+
+ // Wrap as stream, and spliterate then iterate in pull mode
+ STREAM_SPLITERATOR_FOREACH(false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, LongConsumer b, Function<S_IN, LongStream> m) {
+ m.apply(data.stream()).spliterator().forEachRemaining(b);
+ }
+ },
+
+ PAR_STREAM_SEQUENTIAL_FOR_EACH(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, LongConsumer b, Function<S_IN, LongStream> m) {
+ m.apply(data.parallelStream()).sequential().forEach(b);
+ }
+ },
+
+ // Wrap as parallel stream + forEachOrdered
+ PAR_STREAM_FOR_EACH_ORDERED(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, LongConsumer b, Function<S_IN, LongStream> m) {
+ // @@@ Want to explicitly select ordered equalator
+ m.apply(data.parallelStream()).forEachOrdered(b);
+ }
+ },
+
+ // Wrap as stream, and spliterate then iterate sequentially
+ PAR_STREAM_SPLITERATOR(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, LongConsumer b, Function<S_IN, LongStream> m) {
+ for (Spliterator.OfLong spl = m.apply(data.parallelStream()).spliterator(); spl.tryAdvance(b); ) {
+ }
+ }
+ },
+
+ // Wrap as stream, and spliterate then iterate sequentially
+ PAR_STREAM_SPLITERATOR_FOREACH(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, LongConsumer b, Function<S_IN, LongStream> m) {
+ m.apply(data.parallelStream()).spliterator().forEachRemaining(b);
+ }
+ },
+
+ PAR_STREAM_TO_ARRAY(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, LongConsumer b, Function<S_IN, LongStream> m) {
+ for (long t : m.apply(data.parallelStream()).toArray())
+ b.accept(t);
+ }
+ },
+
+ // Wrap as parallel stream, get the spliterator, wrap as a stream + toArray
+ PAR_STREAM_SPLITERATOR_STREAM_TO_ARRAY(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, LongConsumer b, Function<S_IN, LongStream> m) {
+ LongStream s = m.apply(data.parallelStream());
+ Spliterator.OfLong sp = s.spliterator();
+ LongStream ss = StreamSupport.longStream(() -> sp,
+ StreamOpFlag.toCharacteristics(OpTestCase.getStreamFlags(s))
+ | (sp.getExactSizeIfKnown() < 0 ? 0 : Spliterator.SIZED), true);
+ for (long t : ss.toArray())
+ b.accept(t);
+ }
+ },
+
+ PAR_STREAM_TO_ARRAY_CLEAR_SIZED(true) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, LongConsumer b, Function<S_IN, LongStream> m) {
+ S_IN pipe1 = (S_IN) OpTestCase.chain(data.parallelStream(),
+ new FlagDeclaringOp(StreamOpFlag.NOT_SIZED, data.getShape()));
+ LongStream pipe2 = m.apply(pipe1);
+
+ for (long t : pipe2.toArray())
+ b.accept(t);
+ }
+ },
+
+ // Wrap as parallel stream + forEach synchronizing
+ PAR_STREAM_FOR_EACH(true, false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, LongConsumer b, Function<S_IN, LongStream> m) {
+ m.apply(data.parallelStream()).forEach(e -> {
+ synchronized (data) {
+ b.accept(e);
+ }
+ });
+ }
+ },
+
+ // Wrap as parallel stream + forEach synchronizing and clear SIZED flag
+ PAR_STREAM_FOR_EACH_CLEAR_SIZED(true, false) {
+ <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, LongConsumer b, Function<S_IN, LongStream> m) {
+ S_IN pipe1 = (S_IN) OpTestCase.chain(data.parallelStream(),
+ new FlagDeclaringOp(StreamOpFlag.NOT_SIZED, data.getShape()));
+ m.apply(pipe1).forEach(e -> {
+ synchronized (data) {
+ b.accept(e);
+ }
+ });
+ }
+ },
+ ;
+
+ // The set of scenarios that clean the SIZED flag
+ public static final Set<LongStreamTestScenario> CLEAR_SIZED_SCENARIOS = Collections.unmodifiableSet(
+ EnumSet.of(PAR_STREAM_TO_ARRAY_CLEAR_SIZED, PAR_STREAM_FOR_EACH_CLEAR_SIZED));
+
+ private boolean isParallel;
+
+ private final boolean isOrdered;
+
+ LongStreamTestScenario(boolean isParallel) {
+ this(isParallel, true);
+ }
+
+ LongStreamTestScenario(boolean isParallel, boolean isOrdered) {
+ this.isParallel = isParallel;
+ this.isOrdered = isOrdered;
+ }
+
+ public StreamShape getShape() {
+ return StreamShape.LONG_VALUE;
+ }
+
+ public boolean isParallel() {
+ return isParallel;
+ }
+
+ public boolean isOrdered() {
+ return isOrdered;
+ }
+
+ public <T, U, S_IN extends BaseStream<T, S_IN>, S_OUT extends BaseStream<U, S_OUT>>
+ void run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, S_OUT> m) {
+ _run(data, (LongConsumer) b, (Function<S_IN, LongStream>) m);
+ }
+
+ abstract <T, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, LongConsumer b, Function<S_IN, LongStream> m);
+
+}
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/OpTestCase.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/OpTestCase.java
new file mode 100644
index 0000000..331ac0e
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/OpTestCase.java
@@ -0,0 +1,667 @@
+/*
+ * Copyright (c) 2012, 2015, 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.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.Spliterator;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+import org.testng.annotations.Test;
+
+/**
+ * Base class for streams test cases. Provides 'exercise' methods for taking
+ * lambdas that construct and modify streams, and evaluates them in different
+ * ways and asserts that they produce equivalent results.
+ */
+@Test
+public abstract class OpTestCase extends LoggingTestCase {
+
+ private final Map<StreamShape, Set<? extends BaseStreamTestScenario>> testScenarios;
+
+ protected OpTestCase() {
+ testScenarios = new EnumMap<>(StreamShape.class);
+ testScenarios.put(StreamShape.REFERENCE, Collections.unmodifiableSet(EnumSet.allOf(StreamTestScenario.class)));
+ testScenarios.put(StreamShape.INT_VALUE, Collections.unmodifiableSet(EnumSet.allOf(IntStreamTestScenario.class)));
+ testScenarios.put(StreamShape.LONG_VALUE, Collections.unmodifiableSet(EnumSet.allOf(LongStreamTestScenario.class)));
+ testScenarios.put(StreamShape.DOUBLE_VALUE, Collections.unmodifiableSet(EnumSet.allOf(DoubleStreamTestScenario.class)));
+ }
+
+ @SuppressWarnings("rawtypes")
+ public static int getStreamFlags(BaseStream s) {
+ return ((AbstractPipeline) s).getStreamFlags();
+ }
+
+ /**
+ * An asserter for results produced when exercising of stream or terminal
+ * tests.
+ *
+ * @param <R> the type of result to assert on
+ */
+ public interface ResultAsserter<R> {
+ /**
+ * Assert a result produced when exercising of stream or terminal
+ * test.
+ *
+ * @param actual the actual result
+ * @param expected the expected result
+ * @param isOrdered true if the pipeline is ordered
+ * @param isParallel true if the pipeline is parallel
+ */
+ void assertResult(R actual, R expected, boolean isOrdered, boolean isParallel);
+ }
+
+ // Exercise stream operations
+
+ public interface BaseStreamTestScenario {
+ StreamShape getShape();
+
+ boolean isParallel();
+
+ boolean isOrdered();
+
+ <T, U, S_IN extends BaseStream<T, S_IN>, S_OUT extends BaseStream<U, S_OUT>>
+ void run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, S_OUT> m);
+ }
+
+ protected <T, U, S_IN extends BaseStream<T, S_IN>, S_OUT extends BaseStream<U, S_OUT>>
+ Collection<U> exerciseOps(TestData<T, S_IN> data, Function<S_IN, S_OUT> m) {
+ return withData(data).stream(m).exercise();
+ }
+
+ // Run multiple versions of exercise(), returning the result of the first, and asserting that others return the same result
+ // If the first version is s -> s.foo(), can be used with s -> s.mapToInt(i -> i).foo().mapToObj(i -> i) to test all shape variants
+ @SafeVarargs
+ protected final<T, U, S_IN extends BaseStream<T, S_IN>, S_OUT extends BaseStream<U, S_OUT>>
+ Collection<U> exerciseOpsMulti(TestData<T, S_IN> data,
+ Function<S_IN, S_OUT>... ms) {
+ Collection<U> result = null;
+ for (Function<S_IN, S_OUT> m : ms) {
+ if (result == null)
+ result = withData(data).stream(m).exercise();
+ else {
+ Collection<U> r2 = withData(data).stream(m).exercise();
+ assertEquals(result, r2);
+ }
+ }
+ return result;
+ }
+
+ // Run multiple versions of exercise() for an Integer stream, returning the result of the first, and asserting that others return the same result
+ // Automates the conversion between Stream<Integer> and {Int,Long,Double}Stream and back, so client sites look like you are passing the same
+ // lambda four times, but in fact they are four different lambdas since they are transforming four different kinds of streams
+ protected final
+ Collection<Integer> exerciseOpsInt(TestData.OfRef<Integer> data,
+ Function<Stream<Integer>, Stream<Integer>> mRef,
+ Function<IntStream, IntStream> mInt,
+ Function<LongStream, LongStream> mLong,
+ Function<DoubleStream, DoubleStream> mDouble) {
+ @SuppressWarnings({ "rawtypes", "unchecked" })
+ Function<Stream<Integer>, Stream<Integer>>[] 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);
+ return exerciseOpsMulti(data, ms);
+ }
+
+ // Run multiple versions of exercise() with multiple terminal operations for all kinds of stream, , and asserting against the expected result
+ // If the first version is s -> s.foo(), can be used with s -> s.mapToInt(i -> i).foo().mapToObj(i -> i) to test all shape variants
+ protected final<T, U, R, S_IN extends BaseStream<T, S_IN>, S_OUT extends BaseStream<U, S_OUT>>
+ void exerciseTerminalOpsMulti(TestData<T, S_IN> data,
+ R expected,
+ Map<String, Function<S_IN, S_OUT>> streams,
+ Map<String, Function<S_OUT, R>> terminals) {
+ for (Map.Entry<String, Function<S_IN, S_OUT>> se : streams.entrySet()) {
+ setContext("Intermediate stream", se.getKey());
+ for (Map.Entry<String, Function<S_OUT, R>> te : terminals.entrySet()) {
+ setContext("Terminal stream", te.getKey());
+ withData(data)
+ .terminal(se.getValue(), te.getValue())
+ .expectedResult(expected)
+ .exercise();
+
+ }
+ }
+ }
+
+ // Run multiple versions of exercise() with multiple terminal operation for all kinds of stream, and asserting against the expected result
+ // Automates the conversion between Stream<Integer> and {Int,Long,Double}Stream and back, so client sites look like you are passing the same
+ // lambda four times, but in fact they are four different lambdas since they are transforming four different kinds of streams
+ protected final
+ void exerciseTerminalOpsInt(TestData<Integer, Stream<Integer>> data,
+ Collection<Integer> expected,
+ String desc,
+ Function<Stream<Integer>, Stream<Integer>> mRef,
+ Function<IntStream, IntStream> mInt,
+ Function<LongStream, LongStream> mLong,
+ Function<DoubleStream, DoubleStream> mDouble,
+ Map<String, Function<Stream<Integer>, Collection<Integer>>> terminals) {
+
+ Map<String, Function<Stream<Integer>, Stream<Integer>>> m = new HashMap<>();
+ m.put("Ref " + desc, mRef);
+ m.put("Int " + desc, s -> mInt.apply(s.mapToInt(e -> e)).mapToObj(e -> e));
+ m.put("Long " + desc, s -> mLong.apply(s.mapToLong(e -> e)).mapToObj(e -> (int) e));
+ m.put("Double " + desc, s -> mDouble.apply(s.mapToDouble(e -> e)).mapToObj(e -> (int) e));
+
+ exerciseTerminalOpsMulti(data, expected, m, terminals);
+ }
+
+
+ protected <T, U, S_OUT extends BaseStream<U, S_OUT>>
+ Collection<U> exerciseOps(Collection<T> data, Function<Stream<T>, S_OUT> m) {
+ TestData.OfRef<T> data1 = TestData.Factory.ofCollection("Collection of type " + data.getClass().getName(), data);
+ return withData(data1).stream(m).exercise();
+ }
+
+ protected <T, U, S_OUT extends BaseStream<U, S_OUT>, I extends Iterable<U>>
+ Collection<U> exerciseOps(Collection<T> data, Function<Stream<T>, S_OUT> m, I expected) {
+ TestData.OfRef<T> data1 = TestData.Factory.ofCollection("Collection of type " + data.getClass().getName(), data);
+ return withData(data1).stream(m).expectedResult(expected).exercise();
+ }
+
+ @SuppressWarnings("unchecked")
+ protected <U, S_OUT extends BaseStream<U, S_OUT>>
+ Collection<U> exerciseOps(int[] data, Function<IntStream, S_OUT> m) {
+ return withData(TestData.Factory.ofArray("int array", data)).stream(m).exercise();
+ }
+
+ protected Collection<Integer> exerciseOps(int[] data, Function<IntStream, IntStream> m, int[] expected) {
+ TestData.OfInt data1 = TestData.Factory.ofArray("int array", data);
+ return withData(data1).stream(m).expectedResult(expected).exercise();
+ }
+
+ protected <T, S_IN extends BaseStream<T, S_IN>> DataStreamBuilder<T, S_IN> withData(TestData<T, S_IN> data) {
+ Objects.requireNonNull(data);
+ return new DataStreamBuilder<>(data);
+ }
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ public class DataStreamBuilder<T, S_IN extends BaseStream<T, S_IN>> {
+ final TestData<T, S_IN> data;
+
+ private DataStreamBuilder(TestData<T, S_IN> data) {
+ this.data = Objects.requireNonNull(data);
+ }
+
+ public <U, S_OUT extends BaseStream<U, S_OUT>>
+ ExerciseDataStreamBuilder<T, U, S_IN, S_OUT> ops(IntermediateTestOp... ops) {
+ return new ExerciseDataStreamBuilder<>(data, (S_IN s) -> (S_OUT) chain(s, ops));
+ }
+
+ public <U, S_OUT extends BaseStream<U, S_OUT>> ExerciseDataStreamBuilder<T, U, S_IN, S_OUT>
+ stream(Function<S_IN, S_OUT> m) {
+ return new ExerciseDataStreamBuilder<>(data, m);
+ }
+
+ public <U, S_OUT extends BaseStream<U, S_OUT>> ExerciseDataStreamBuilder<T, U, S_IN, S_OUT>
+ stream(Function<S_IN, S_OUT> m, IntermediateTestOp<U, U> additionalOp) {
+ return new ExerciseDataStreamBuilder<>(data, s -> (S_OUT) chain(m.apply(s), additionalOp));
+ }
+
+ public <R> ExerciseDataTerminalBuilder<T, T, R, S_IN, S_IN>
+ terminal(Function<S_IN, R> terminalF) {
+ return new ExerciseDataTerminalBuilder<>(data, s -> s, terminalF);
+ }
+
+ public <U, R, S_OUT extends BaseStream<U, S_OUT>> ExerciseDataTerminalBuilder<T, U, R, S_IN, S_OUT>
+ terminal(Function<S_IN, S_OUT> streamF, Function<S_OUT, R> terminalF) {
+ return new ExerciseDataTerminalBuilder<>(data, streamF, terminalF);
+ }
+ }
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ public class ExerciseDataStreamBuilder<T, U, S_IN extends BaseStream<T, S_IN>, S_OUT extends BaseStream<U, S_OUT>> {
+ final TestData<T, S_IN> data;
+ final Function<S_IN, S_OUT> m;
+ final StreamShape shape;
+
+ Set<BaseStreamTestScenario> testSet = new HashSet<>();
+
+ Collection<U> refResult;
+
+ Consumer<TestData<T, S_IN>> before = LambdaTestHelpers.bEmpty;
+
+ Consumer<TestData<T, S_IN>> after = LambdaTestHelpers.bEmpty;
+
+ ResultAsserter<Iterable<U>> resultAsserter = (act, exp, ord, par) -> {
+ if (par & !ord) {
+ LambdaTestHelpers.assertContentsUnordered(act, exp);
+ }
+ else {
+ LambdaTestHelpers.assertContentsEqual(act, exp);
+ }
+ };
+
+ private ExerciseDataStreamBuilder(TestData<T, S_IN> data, Function<S_IN, S_OUT> m) {
+ this.data = data;
+
+ this.m = Objects.requireNonNull(m);
+
+ this.shape = ((AbstractPipeline<?, U, ?>) m.apply(data.stream())).getOutputShape();
+
+ // Have to initiate from the output shape of the last stream
+ // This means the stream mapper is required first rather than last
+ testSet.addAll(testScenarios.get(shape));
+ }
+
+ //
+
+ public <I extends Iterable<U>> ExerciseDataStreamBuilder<T, U, S_IN, S_OUT> expectedResult(I expectedResult) {
+ List<U> l = new ArrayList<>();
+ expectedResult.forEach(l::add);
+ refResult = l;
+ return this;
+ }
+
+ public ExerciseDataStreamBuilder<T, U, S_IN, S_OUT> expectedResult(int[] expectedResult) {
+ List l = new ArrayList();
+ for (int anExpectedResult : expectedResult) {
+ l.add(anExpectedResult);
+ }
+ refResult = l;
+ return this;
+ }
+
+ public ExerciseDataStreamBuilder<T, U, S_IN, S_OUT> expectedResult(long[] expectedResult) {
+ List l = new ArrayList();
+ for (long anExpectedResult : expectedResult) {
+ l.add(anExpectedResult);
+ }
+ refResult = l;
+ return this;
+ }
+
+ public ExerciseDataStreamBuilder<T, U, S_IN, S_OUT> expectedResult(double[] expectedResult) {
+ List l = new ArrayList();
+ for (double anExpectedResult : expectedResult) {
+ l.add(anExpectedResult);
+ }
+ refResult = l;
+ return this;
+ }
+
+ public ExerciseDataStreamBuilder<T, U, S_IN, S_OUT> before(Consumer<TestData<T, S_IN>> before) {
+ this.before = Objects.requireNonNull(before);
+ return this;
+ }
+
+ public ExerciseDataStreamBuilder<T, U, S_IN, S_OUT> after(Consumer<TestData<T, S_IN>> after) {
+ this.after = Objects.requireNonNull(after);
+ return this;
+ }
+
+ public ExerciseDataStreamBuilder<T, U, S_IN, S_OUT> without(BaseStreamTestScenario... tests) {
+ return without(Arrays.asList(tests));
+ }
+
+ public ExerciseDataStreamBuilder<T, U, S_IN, S_OUT> without(Collection<? extends BaseStreamTestScenario> tests) {
+ for (BaseStreamTestScenario ts : tests) {
+ if (ts.getShape() == shape) {
+ testSet.remove(ts);
+ }
+ }
+
+ if (testSet.isEmpty()) {
+ throw new IllegalStateException("Test scenario set is empty");
+ }
+
+ return this;
+ }
+
+ public ExerciseDataStreamBuilder<T, U, S_IN, S_OUT> with(BaseStreamTestScenario... tests) {
+ return with(Arrays.asList(tests));
+ }
+
+ public ExerciseDataStreamBuilder<T, U, S_IN, S_OUT> with(Collection<? extends BaseStreamTestScenario> tests) {
+ testSet = new HashSet<>();
+
+ for (BaseStreamTestScenario ts : tests) {
+ if (ts.getShape() == shape) {
+ testSet.add(ts);
+ }
+ }
+
+ if (testSet.isEmpty()) {
+ throw new IllegalStateException("Test scenario set is empty");
+ }
+
+ return this;
+ }
+
+ public ExerciseDataStreamBuilder<T, U, S_IN, S_OUT> resultAsserter(ResultAsserter<Iterable<U>> resultAsserter) {
+ this.resultAsserter = resultAsserter;
+ return this;
+ }
+
+ // Build method
+
+ public Collection<U> exercise() {
+ final boolean isStreamOrdered;
+ if (refResult == null) {
+ // Induce the reference result
+ before.accept(data);
+ S_OUT sOut = m.apply(data.stream());
+ isStreamOrdered = StreamOpFlag.ORDERED.isKnown(((AbstractPipeline) sOut).getStreamFlags());
+ Node<U> refNodeResult = ((AbstractPipeline<?, U, ?>) sOut).evaluateToArrayNode(size -> (U[]) new Object[size]);
+ refResult = LambdaTestHelpers.toBoxedList(refNodeResult.spliterator());
+ after.accept(data);
+ }
+ else {
+ S_OUT sOut = m.apply(data.stream());
+ isStreamOrdered = StreamOpFlag.ORDERED.isKnown(((AbstractPipeline) sOut).getStreamFlags());
+ }
+
+ List<Error> errors = new ArrayList<>();
+ for (BaseStreamTestScenario test : testSet) {
+ try {
+ before.accept(data);
+
+ List<U> result = new ArrayList<>();
+ test.run(data, LambdaTestHelpers.<U>toBoxingConsumer(result::add), m);
+
+ Runnable asserter = () -> resultAsserter.assertResult(result, refResult, isStreamOrdered && test.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 (Throwable t) {
+ errors.add(new Error(String.format("%s: %s", test, t), t));
+ }
+ }
+
+ if (!errors.isEmpty()) {
+ StringBuilder sb = new StringBuilder();
+ int i = 1;
+ for (Error t : errors) {
+ sb.append(i++).append(": ");
+ if (t instanceof AssertionError) {
+ sb.append(t).append("\n");
+ }
+ else {
+ StringWriter sw = new StringWriter();
+ PrintWriter pw = new PrintWriter(sw);
+
+ t.getCause().printStackTrace(pw);
+ pw.flush();
+ sb.append(t).append("\n").append(sw);
+ }
+ }
+ sb.append("--");
+
+ fail(String.format("%d failure(s) for test data: %s\n%s", i - 1, data.toString(), sb));
+ }
+
+ return refResult;
+ }
+ }
+
+ // Exercise terminal operations
+
+ interface BaseTerminalTestScenario<U, R, S_OUT extends BaseStream<U, S_OUT>> {
+ boolean requiresSingleStageSource();
+
+ boolean requiresParallelSource();
+
+ default R run(Function<S_OUT, R> terminalF, S_OUT source, StreamShape shape) {
+ return terminalF.apply(source);
+ }
+ }
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ enum TerminalTestScenario implements BaseTerminalTestScenario {
+ SINGLE_SEQUENTIAL(true, false),
+
+ SINGLE_SEQUENTIAL_SHORT_CIRCUIT(true, false) {
+ @Override
+ public Object run(Function terminalF, BaseStream source, StreamShape shape) {
+ source = (BaseStream) chain(source, new ShortCircuitOp(shape));
+ return terminalF.apply(source);
+ }
+ },
+
+ SINGLE_PARALLEL(true, true),
+
+ ALL_SEQUENTIAL(false, false),
+
+ ALL_SEQUENTIAL_SHORT_CIRCUIT(false, false) {
+ @Override
+ public Object run(Function terminalF, BaseStream source, StreamShape shape) {
+ source = (BaseStream) chain(source, new ShortCircuitOp(shape));
+ return terminalF.apply(source);
+ }
+ },
+
+ ALL_PARALLEL(false, true),
+
+ ALL_PARALLEL_SEQUENTIAL(false, false) {
+ @Override
+ public Object run(Function terminalF, BaseStream source, StreamShape shape) {
+ return terminalF.apply(source.sequential());
+ }
+ },
+ ;
+
+ private final boolean requiresSingleStageSource;
+ private final boolean isParallel;
+
+ TerminalTestScenario(boolean requiresSingleStageSource, boolean isParallel) {
+ this.requiresSingleStageSource = requiresSingleStageSource;
+ this.isParallel = isParallel;
+ }
+
+ @Override
+ public boolean requiresSingleStageSource() {
+ return requiresSingleStageSource;
+ }
+
+ @Override
+ public boolean requiresParallelSource() {
+ return isParallel;
+ }
+
+ }
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ public class ExerciseDataTerminalBuilder<T, U, R, S_IN extends BaseStream<T, S_IN>, S_OUT extends BaseStream<U, S_OUT>> {
+ final TestData<T, S_IN> data;
+ final Function<S_IN, S_OUT> streamF;
+ final Function<S_OUT, R> terminalF;
+
+ R refResult;
+
+ ResultAsserter<R> resultAsserter = (act, exp, ord, par) -> LambdaTestHelpers.assertContentsEqual(act, exp);
+
+ private ExerciseDataTerminalBuilder(TestData<T, S_IN> data, Function<S_IN, S_OUT> streamF, Function<S_OUT, R> terminalF) {
+ this.data = data;
+ this.streamF = Objects.requireNonNull(streamF);
+ this.terminalF = Objects.requireNonNull(terminalF);
+ }
+
+ //
+
+ public ExerciseDataTerminalBuilder<T, U, R, S_IN, S_OUT> expectedResult(R expectedResult) {
+ this.refResult = expectedResult;
+ return this;
+ }
+
+ public ExerciseDataTerminalBuilder<T, U, R, S_IN, S_OUT> equalator(BiConsumer<R, R> equalityAsserter) {
+ resultAsserter = (act, exp, ord, par) -> equalityAsserter.accept(act, exp);
+ return this;
+ }
+
+ public ExerciseDataTerminalBuilder<T, U, R, S_IN, S_OUT> resultAsserter(ResultAsserter<R> resultAsserter) {
+ this.resultAsserter = resultAsserter;
+ return this;
+ }
+
+ // Build method
+
+ public R exercise() {
+ S_OUT out = streamF.apply(data.stream()).sequential();
+ AbstractPipeline ap = (AbstractPipeline) out;
+ boolean isOrdered = StreamOpFlag.ORDERED.isKnown(ap.getStreamFlags());
+ StreamShape shape = ap.getOutputShape();
+
+ EnumSet<TerminalTestScenario> tests = EnumSet.allOf(TerminalTestScenario.class);
+ // Sequentially collect the output that will be input to the terminal op
+ Node<U> node = ap.evaluateToArrayNode(size -> (U[]) new Object[size]);
+ if (refResult == null) {
+ // Induce the reference result
+ S_OUT source = (S_OUT) createPipeline(shape, node.spliterator(),
+ StreamOpFlag.IS_ORDERED | StreamOpFlag.IS_SIZED,
+ false);
+
+ refResult = (R) TerminalTestScenario.SINGLE_SEQUENTIAL.run(terminalF, source, shape);
+ tests.remove(TerminalTestScenario.SINGLE_SEQUENTIAL);
+ }
+
+ for (BaseTerminalTestScenario test : tests) {
+ S_OUT source;
+ if (test.requiresSingleStageSource()) {
+ source = (S_OUT) createPipeline(shape, node.spliterator(),
+ StreamOpFlag.IS_ORDERED | StreamOpFlag.IS_SIZED,
+ test.requiresParallelSource());
+ }
+ else {
+ source = streamF.apply(test.requiresParallelSource()
+ ? data.parallelStream() : data.stream());
+ }
+
+ R result = (R) test.run(terminalF, source, shape);
+
+ LambdaTestHelpers.launderAssertion(
+ () -> resultAsserter.assertResult(result, refResult, isOrdered, test.requiresParallelSource()),
+ () -> String.format("%s: %s != %s", test, refResult, result));
+ }
+
+ return refResult;
+ }
+
+ AbstractPipeline createPipeline(StreamShape shape, Spliterator s, int flags, boolean parallel) {
+ switch (shape) {
+ case REFERENCE: return new ReferencePipeline.Head<>(s, flags, parallel);
+ case INT_VALUE: return new IntPipeline.Head(s, flags, parallel);
+ case LONG_VALUE: return new LongPipeline.Head(s, flags, parallel);
+ case DOUBLE_VALUE: return new DoublePipeline.Head(s, flags, parallel);
+ default: throw new IllegalStateException("Unknown shape: " + shape);
+ }
+ }
+ }
+
+ protected <T, R> R exerciseTerminalOps(Collection<T> data, Function<Stream<T>, R> m, R expected) {
+ TestData.OfRef<T> data1
+ = TestData.Factory.ofCollection("Collection of type " + data.getClass().getName(), data);
+ return withData(data1).terminal(m).expectedResult(expected).exercise();
+ }
+
+ protected <T, R, S_IN extends BaseStream<T, S_IN>> R
+ exerciseTerminalOps(TestData<T, S_IN> data,
+ Function<S_IN, R> terminalF) {
+ return withData(data).terminal(terminalF).exercise();
+ }
+
+ protected <T, U, R, S_IN extends BaseStream<T, S_IN>, S_OUT extends BaseStream<U, S_OUT>> R
+ exerciseTerminalOps(TestData<T, S_IN> data,
+ Function<S_IN, S_OUT> streamF,
+ Function<S_OUT, R> terminalF) {
+ return withData(data).terminal(streamF, terminalF).exercise();
+ }
+
+ //
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ private static <T> AbstractPipeline<?, T, ?> chain(AbstractPipeline upstream, IntermediateTestOp<?, T> op) {
+ return (AbstractPipeline<?, T, ?>) IntermediateTestOp.chain(upstream, op);
+ }
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ private static AbstractPipeline<?, ?, ?> chain(AbstractPipeline pipe, IntermediateTestOp... ops) {
+ for (IntermediateTestOp op : ops)
+ pipe = chain(pipe, op);
+ return pipe;
+ }
+
+ @SuppressWarnings("rawtypes")
+ private static <T> AbstractPipeline<?, T, ?> chain(BaseStream pipe, IntermediateTestOp<?, T> op) {
+ return chain((AbstractPipeline) pipe, op);
+ }
+
+ @SuppressWarnings("rawtypes")
+ public static AbstractPipeline<?, ?, ?> chain(BaseStream pipe, IntermediateTestOp... ops) {
+ return chain((AbstractPipeline) pipe, ops);
+ }
+
+ // Test data
+
+ static class ShortCircuitOp<T> implements StatelessTestOp<T,T> {
+ private final StreamShape shape;
+
+ ShortCircuitOp(StreamShape shape) {
+ this.shape = shape;
+ }
+
+ @Override
+ public Sink<T> opWrapSink(int flags, boolean parallel, Sink<T> sink) {
+ return sink;
+ }
+
+ @Override
+ public int opGetFlags() {
+ return StreamOpFlag.IS_SHORT_CIRCUIT;
+ }
+
+ @Override
+ public StreamShape outputShape() {
+ return shape;
+ }
+
+ @Override
+ public StreamShape inputShape() {
+ return shape;
+ }
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/SpliteratorTestHelper.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/SpliteratorTestHelper.java
new file mode 100644
index 0000000..cf9ce2a
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/SpliteratorTestHelper.java
@@ -0,0 +1,727 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.util.stream;
+
+import org.testng.annotations.Test;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Spliterator;
+import java.util.function.*;
+
+import static org.testng.Assert.*;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.fail;
+
+/**
+ * Assertion methods for spliterators, to be called from other tests
+ */
+public class SpliteratorTestHelper {
+
+ public interface ContentAsserter<T> {
+ void assertContents(Collection<T> actual, Collection<T> expected, boolean isOrdered);
+ }
+
+ private static ContentAsserter<Object> DEFAULT_CONTENT_ASSERTER
+ = SpliteratorTestHelper::assertContents;
+
+ @SuppressWarnings("unchecked")
+ private static <T> ContentAsserter<T> defaultContentAsserter() {
+ return (ContentAsserter<T>) DEFAULT_CONTENT_ASSERTER;
+ }
+
+ public static void testSpliterator(Supplier<Spliterator<Integer>> supplier) {
+ testSpliterator(supplier, defaultContentAsserter());
+ }
+
+ public static void testSpliterator(Supplier<Spliterator<Integer>> supplier,
+ ContentAsserter<Integer> asserter) {
+ testSpliterator(supplier, (Consumer<Integer> b) -> b, asserter);
+ }
+
+ public static void testIntSpliterator(Supplier<Spliterator.OfInt> supplier) {
+ testIntSpliterator(supplier, defaultContentAsserter());
+ }
+
+ public static void testIntSpliterator(Supplier<Spliterator.OfInt> supplier,
+ ContentAsserter<Integer> asserter) {
+ class BoxingAdapter implements Consumer<Integer>, IntConsumer {
+ private final Consumer<Integer> b;
+
+ BoxingAdapter(Consumer<Integer> b) {
+ this.b = b;
+ }
+
+ @Override
+ public void accept(Integer value) {
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public void accept(int value) {
+ b.accept(value);
+ }
+ }
+
+ testSpliterator(supplier, BoxingAdapter::new, asserter);
+ }
+
+ public static void testLongSpliterator(Supplier<Spliterator.OfLong> supplier) {
+ testLongSpliterator(supplier, defaultContentAsserter());
+ }
+
+ public static void testLongSpliterator(Supplier<Spliterator.OfLong> supplier,
+ ContentAsserter<Long> asserter) {
+ class BoxingAdapter implements Consumer<Long>, LongConsumer {
+ private final Consumer<Long> b;
+
+ BoxingAdapter(Consumer<Long> b) {
+ this.b = b;
+ }
+
+ @Override
+ public void accept(Long value) {
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public void accept(long value) {
+ b.accept(value);
+ }
+ }
+
+ testSpliterator(supplier, BoxingAdapter::new, asserter);
+ }
+
+ public static void testDoubleSpliterator(Supplier<Spliterator.OfDouble> supplier) {
+ testDoubleSpliterator(supplier, defaultContentAsserter());
+ }
+
+ public static void testDoubleSpliterator(Supplier<Spliterator.OfDouble> supplier,
+ ContentAsserter<Double> asserter) {
+ class BoxingAdapter implements Consumer<Double>, DoubleConsumer {
+ private final Consumer<Double> b;
+
+ BoxingAdapter(Consumer<Double> b) {
+ this.b = b;
+ }
+
+ @Override
+ public void accept(Double value) {
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public void accept(double value) {
+ b.accept(value);
+ }
+ }
+
+ testSpliterator(supplier, BoxingAdapter::new, asserter);
+ }
+
+ static <T, S extends Spliterator<T>> void testSpliterator(Supplier<S> supplier,
+ UnaryOperator<Consumer<T>> boxingAdapter,
+ ContentAsserter<T> asserter) {
+ ArrayList<T> fromForEach = new ArrayList<>();
+ Spliterator<T> spliterator = supplier.get();
+ Consumer<T> addToFromForEach = boxingAdapter.apply(fromForEach::add);
+ spliterator.forEachRemaining(addToFromForEach);
+
+ Collection<T> exp = Collections.unmodifiableList(fromForEach);
+
+ testNullPointerException(supplier);
+ testForEach(exp, supplier, boxingAdapter, asserter);
+ testTryAdvance(exp, supplier, boxingAdapter, asserter);
+ testMixedTryAdvanceForEach(exp, supplier, boxingAdapter, asserter);
+ testMixedTraverseAndSplit(exp, supplier, boxingAdapter, asserter);
+ testSplitAfterFullTraversal(supplier, boxingAdapter);
+ testSplitOnce(exp, supplier, boxingAdapter, asserter);
+ testSplitSixDeep(exp, supplier, boxingAdapter, asserter);
+ testSplitUntilNull(exp, supplier, boxingAdapter, asserter);
+ }
+
+ //
+
+ private static <T, S extends Spliterator<T>> void testNullPointerException(Supplier<S> s) {
+ S sp = s.get();
+ // Have to check instances and use casts to avoid tripwire messages and
+ // directly test the primitive methods
+ if (sp instanceof Spliterator.OfInt) {
+ Spliterator.OfInt psp = (Spliterator.OfInt) sp;
+ executeAndCatch(NullPointerException.class, () -> psp.forEachRemaining((IntConsumer) null));
+ executeAndCatch(NullPointerException.class, () -> psp.tryAdvance((IntConsumer) null));
+ }
+ else if (sp instanceof Spliterator.OfLong) {
+ Spliterator.OfLong psp = (Spliterator.OfLong) sp;
+ executeAndCatch(NullPointerException.class, () -> psp.forEachRemaining((LongConsumer) null));
+ executeAndCatch(NullPointerException.class, () -> psp.tryAdvance((LongConsumer) null));
+ }
+ else if (sp instanceof Spliterator.OfDouble) {
+ Spliterator.OfDouble psp = (Spliterator.OfDouble) sp;
+ executeAndCatch(NullPointerException.class, () -> psp.forEachRemaining((DoubleConsumer) null));
+ executeAndCatch(NullPointerException.class, () -> psp.tryAdvance((DoubleConsumer) null));
+ }
+ else {
+ executeAndCatch(NullPointerException.class, () -> sp.forEachRemaining(null));
+ executeAndCatch(NullPointerException.class, () -> sp.tryAdvance(null));
+ }
+ }
+
+ private static <T, S extends Spliterator<T>> void testForEach(
+ Collection<T> exp,
+ Supplier<S> supplier,
+ UnaryOperator<Consumer<T>> boxingAdapter,
+ ContentAsserter<T> asserter) {
+ S spliterator = supplier.get();
+ long sizeIfKnown = spliterator.getExactSizeIfKnown();
+ boolean isOrdered = spliterator.hasCharacteristics(Spliterator.ORDERED);
+
+ ArrayList<T> fromForEach = new ArrayList<>();
+ spliterator = supplier.get();
+ Consumer<T> addToFromForEach = boxingAdapter.apply(fromForEach::add);
+ spliterator.forEachRemaining(addToFromForEach);
+
+ // Assert that forEach now produces no elements
+ spliterator.forEachRemaining(boxingAdapter.apply(
+ e -> fail("Spliterator.forEach produced an element after spliterator exhausted: " + e)));
+ // Assert that tryAdvance now produce no elements
+ spliterator.tryAdvance(boxingAdapter.apply(
+ e -> fail("Spliterator.tryAdvance produced an element after spliterator exhausted: " + e)));
+
+ // assert that size, tryAdvance, and forEach are consistent
+ if (sizeIfKnown >= 0) {
+ assertEquals(sizeIfKnown, exp.size());
+ }
+ assertEquals(fromForEach.size(), exp.size());
+
+ asserter.assertContents(fromForEach, exp, isOrdered);
+ }
+
+ private static <T, S extends Spliterator<T>> void testTryAdvance(
+ Collection<T> exp,
+ Supplier<S> supplier,
+ UnaryOperator<Consumer<T>> boxingAdapter,
+ ContentAsserter<T> asserter) {
+ S spliterator = supplier.get();
+ long sizeIfKnown = spliterator.getExactSizeIfKnown();
+ boolean isOrdered = spliterator.hasCharacteristics(Spliterator.ORDERED);
+
+ spliterator = supplier.get();
+ ArrayList<T> fromTryAdvance = new ArrayList<>();
+ Consumer<T> addToFromTryAdvance = boxingAdapter.apply(fromTryAdvance::add);
+ while (spliterator.tryAdvance(addToFromTryAdvance)) { }
+
+ // Assert that forEach now produces no elements
+ spliterator.forEachRemaining(boxingAdapter.apply(
+ e -> fail("Spliterator.forEach produced an element after spliterator exhausted: " + e)));
+ // Assert that tryAdvance now produce no elements
+ spliterator.tryAdvance(boxingAdapter.apply(
+ e -> fail("Spliterator.tryAdvance produced an element after spliterator exhausted: " + e)));
+
+ // assert that size, tryAdvance, and forEach are consistent
+ if (sizeIfKnown >= 0) {
+ assertEquals(sizeIfKnown, exp.size());
+ }
+ assertEquals(fromTryAdvance.size(), exp.size());
+
+ asserter.assertContents(fromTryAdvance, exp, isOrdered);
+ }
+
+ private static <T, S extends Spliterator<T>> void testMixedTryAdvanceForEach(
+ Collection<T> exp,
+ Supplier<S> supplier,
+ UnaryOperator<Consumer<T>> boxingAdapter,
+ ContentAsserter<T> asserter) {
+ S spliterator = supplier.get();
+ long sizeIfKnown = spliterator.getExactSizeIfKnown();
+ boolean isOrdered = spliterator.hasCharacteristics(Spliterator.ORDERED);
+
+ // tryAdvance first few elements, then forEach rest
+ ArrayList<T> dest = new ArrayList<>();
+ spliterator = supplier.get();
+ Consumer<T> addToDest = boxingAdapter.apply(dest::add);
+ for (int i = 0; i < 10 && spliterator.tryAdvance(addToDest); i++) { }
+ spliterator.forEachRemaining(addToDest);
+
+ // Assert that forEach now produces no elements
+ spliterator.forEachRemaining(boxingAdapter.apply(
+ e -> fail("Spliterator.forEach produced an element after spliterator exhausted: " + e)));
+ // Assert that tryAdvance now produce no elements
+ spliterator.tryAdvance(boxingAdapter.apply(
+ e -> fail("Spliterator.tryAdvance produced an element after spliterator exhausted: " + e)));
+
+ if (sizeIfKnown >= 0) {
+ assertEquals(sizeIfKnown, dest.size());
+ }
+ assertEquals(dest.size(), exp.size());
+
+ asserter.assertContents(dest, exp, isOrdered);
+ }
+
+ private static <T, S extends Spliterator<T>> void testMixedTraverseAndSplit(
+ Collection<T> exp,
+ Supplier<S> supplier,
+ UnaryOperator<Consumer<T>> boxingAdapter,
+ ContentAsserter<T> asserter) {
+ S spliterator = supplier.get();
+ long sizeIfKnown = spliterator.getExactSizeIfKnown();
+ boolean isOrdered = spliterator.hasCharacteristics(Spliterator.ORDERED);
+
+ // tryAdvance first few elements, then forEach rest
+ ArrayList<T> dest = new ArrayList<>();
+ spliterator = supplier.get();
+ Consumer<T> b = boxingAdapter.apply(dest::add);
+
+ Spliterator<T> spl1, spl2, spl3;
+ spliterator.tryAdvance(b);
+ spl2 = spliterator.trySplit();
+ if (spl2 != null) {
+ spl2.tryAdvance(b);
+ spl1 = spl2.trySplit();
+ if (spl1 != null) {
+ spl1.tryAdvance(b);
+ spl1.forEachRemaining(b);
+ }
+ spl2.tryAdvance(b);
+ spl2.forEachRemaining(b);
+ }
+ spliterator.tryAdvance(b);
+ spl3 = spliterator.trySplit();
+ if (spl3 != null) {
+ spl3.tryAdvance(b);
+ spl3.forEachRemaining(b);
+ }
+ spliterator.tryAdvance(b);
+ spliterator.forEachRemaining(b);
+
+ if (sizeIfKnown >= 0) {
+ assertEquals(sizeIfKnown, dest.size());
+ }
+ assertEquals(dest.size(), exp.size());
+
+ asserter.assertContents(dest, exp, isOrdered);
+ }
+
+ private static <T, S extends Spliterator<T>> void testSplitAfterFullTraversal(
+ Supplier<S> supplier,
+ UnaryOperator<Consumer<T>> boxingAdapter) {
+ // Full traversal using tryAdvance
+ Spliterator<T> spliterator = supplier.get();
+ while (spliterator.tryAdvance(boxingAdapter.apply(e -> { }))) { }
+ Spliterator<T> split = spliterator.trySplit();
+ assertNull(split);
+
+ // Full traversal using forEach
+ spliterator = supplier.get();
+ spliterator.forEachRemaining(boxingAdapter.apply(e -> { }));
+ split = spliterator.trySplit();
+ assertNull(split);
+
+ // Full traversal using tryAdvance then forEach
+ spliterator = supplier.get();
+ spliterator.tryAdvance(boxingAdapter.apply(e -> { }));
+ spliterator.forEachRemaining(boxingAdapter.apply(e -> { }));
+ split = spliterator.trySplit();
+ assertNull(split);
+ }
+
+ private static <T, S extends Spliterator<T>> void testSplitOnce(
+ Collection<T> exp,
+ Supplier<S> supplier,
+ UnaryOperator<Consumer<T>> boxingAdapter,
+ ContentAsserter<T> asserter) {
+ S spliterator = supplier.get();
+ long sizeIfKnown = spliterator.getExactSizeIfKnown();
+ boolean isOrdered = spliterator.hasCharacteristics(Spliterator.ORDERED);
+
+ ArrayList<T> fromSplit = new ArrayList<>();
+ Spliterator<T> s1 = supplier.get();
+ Spliterator<T> s2 = s1.trySplit();
+ long s1Size = s1.getExactSizeIfKnown();
+ long s2Size = (s2 != null) ? s2.getExactSizeIfKnown() : 0;
+ Consumer<T> addToFromSplit = boxingAdapter.apply(fromSplit::add);
+ if (s2 != null)
+ s2.forEachRemaining(addToFromSplit);
+ s1.forEachRemaining(addToFromSplit);
+
+ if (sizeIfKnown >= 0) {
+ assertEquals(sizeIfKnown, fromSplit.size());
+ if (s1Size >= 0 && s2Size >= 0)
+ assertEquals(sizeIfKnown, s1Size + s2Size);
+ }
+
+ asserter.assertContents(fromSplit, exp, isOrdered);
+ }
+
+ private static <T, S extends Spliterator<T>> void testSplitSixDeep(
+ Collection<T> exp,
+ Supplier<S> supplier,
+ UnaryOperator<Consumer<T>> boxingAdapter,
+ ContentAsserter<T> asserter) {
+ S spliterator = supplier.get();
+ boolean isOrdered = spliterator.hasCharacteristics(Spliterator.ORDERED);
+
+ for (int depth=0; depth < 6; depth++) {
+ List<T> dest = new ArrayList<>();
+ spliterator = supplier.get();
+
+ assertSpliterator(spliterator);
+
+ // verify splitting with forEach
+ splitSixDeepVisitor(depth, 0, dest, spliterator, boxingAdapter, spliterator.characteristics(), false);
+ asserter.assertContents(dest, exp, isOrdered);
+
+ // verify splitting with tryAdvance
+ dest.clear();
+ spliterator = supplier.get();
+ splitSixDeepVisitor(depth, 0, dest, spliterator, boxingAdapter, spliterator.characteristics(), true);
+ asserter.assertContents(dest, exp, isOrdered);
+ }
+ }
+
+ static void splitSixDeepVisitorUnsafe(int depth, int curLevel, List dest,
+ Spliterator spliterator, UnaryOperator boxingAdapter,
+ int rootCharacteristics, boolean useTryAdvance) {
+ splitSixDeepVisitor(depth, curLevel, dest, spliterator, boxingAdapter, rootCharacteristics, useTryAdvance);
+ }
+
+ // Android-changed: Workaround for jack type inference bug
+ private static <T>
+ // private static <T, S extends Spliterator<T>>
+ // Android-changed: Workaround for jack type inference bug
+ void splitSixDeepVisitor(int depth, int curLevel,
+ List<T> dest, Spliterator<T> spliterator, UnaryOperator<Consumer<T>> boxingAdapter,
+ // List<T> dest, S spliterator, UnaryOperator<Consumer<T>> boxingAdapter,
+ int rootCharacteristics, boolean useTryAdvance) {
+ if (curLevel < depth) {
+ long beforeSize = spliterator.getExactSizeIfKnown();
+ Spliterator<T> split = spliterator.trySplit();
+ if (split != null) {
+ assertSpliterator(split, rootCharacteristics);
+ assertSpliterator(spliterator, rootCharacteristics);
+
+ if ((rootCharacteristics & Spliterator.SUBSIZED) != 0 &&
+ (rootCharacteristics & Spliterator.SIZED) != 0) {
+ assertEquals(beforeSize, split.estimateSize() + spliterator.estimateSize());
+ }
+ // Android-changed: Workaround for jack type inference bug
+ splitSixDeepVisitorUnsafe(depth, curLevel + 1, dest, split, boxingAdapter, rootCharacteristics, useTryAdvance);
+ // splitSixDeepVisitor(depth, curLevel + 1, dest, split, boxingAdapter, rootCharacteristics, useTryAdvance);
+ }
+ splitSixDeepVisitor(depth, curLevel + 1, dest, spliterator, boxingAdapter, rootCharacteristics, useTryAdvance);
+ }
+ else {
+ long sizeIfKnown = spliterator.getExactSizeIfKnown();
+ if (useTryAdvance) {
+ Consumer<T> addToDest = boxingAdapter.apply(dest::add);
+ int count = 0;
+ while (spliterator.tryAdvance(addToDest)) {
+ ++count;
+ }
+
+ if (sizeIfKnown >= 0)
+ assertEquals(sizeIfKnown, count);
+
+ // Assert that forEach now produces no elements
+ spliterator.forEachRemaining(boxingAdapter.apply(
+ e -> fail("Spliterator.forEach produced an element after spliterator exhausted: " + e)));
+
+ Spliterator<T> split = spliterator.trySplit();
+ assertNull(split);
+ }
+ else {
+ List<T> leafDest = new ArrayList<>();
+ Consumer<T> addToLeafDest = boxingAdapter.apply(leafDest::add);
+ spliterator.forEachRemaining(addToLeafDest);
+
+ if (sizeIfKnown >= 0)
+ assertEquals(sizeIfKnown, leafDest.size());
+
+ // Assert that forEach now produces no elements
+ spliterator.tryAdvance(boxingAdapter.apply(
+ e -> fail("Spliterator.tryAdvance produced an element after spliterator exhausted: " + e)));
+
+ Spliterator<T> split = spliterator.trySplit();
+ assertNull(split);
+
+ dest.addAll(leafDest);
+ }
+ }
+ }
+
+ private static <T, S extends Spliterator<T>> void testSplitUntilNull(
+ Collection<T> exp,
+ Supplier<S> supplier,
+ UnaryOperator<Consumer<T>> boxingAdapter,
+ ContentAsserter<T> asserter) {
+ Spliterator<T> s = supplier.get();
+ boolean isOrdered = s.hasCharacteristics(Spliterator.ORDERED);
+ assertSpliterator(s);
+
+ List<T> splits = new ArrayList<>();
+ Consumer<T> c = boxingAdapter.apply(splits::add);
+
+ testSplitUntilNull(new SplitNode<T>(c, s));
+ asserter.assertContents(splits, exp, isOrdered);
+ }
+
+ private static class SplitNode<T> {
+ // Constant for every node
+ final Consumer<T> c;
+ final int rootCharacteristics;
+
+ final Spliterator<T> s;
+
+ SplitNode(Consumer<T> c, Spliterator<T> s) {
+ this(c, s.characteristics(), s);
+ }
+
+ private SplitNode(Consumer<T> c, int rootCharacteristics, Spliterator<T> s) {
+ this.c = c;
+ this.rootCharacteristics = rootCharacteristics;
+ this.s = s;
+ }
+
+ SplitNode<T> fromSplit(Spliterator<T> split) {
+ return new SplitNode<>(c, rootCharacteristics, split);
+ }
+ }
+
+ /**
+ * Set the maximum stack capacity to 0.25MB. This should be more than enough to detect a bad spliterator
+ * while not unduly disrupting test infrastructure given the test data sizes that are used are small.
+ * Note that j.u.c.ForkJoinPool sets the max queue size to 64M (1 << 26).
+ */
+ private static final int MAXIMUM_STACK_CAPACITY = 1 << 18; // 0.25MB
+
+ private static <T> void testSplitUntilNull(SplitNode<T> e) {
+ // Use an explicit stack to avoid a StackOverflowException when testing a Spliterator
+ // that when repeatedly split produces a right-balanced (and maybe degenerate) tree, or
+ // for a spliterator that is badly behaved.
+ Deque<SplitNode<T>> stack = new ArrayDeque<>();
+ stack.push(e);
+
+ int iteration = 0;
+ while (!stack.isEmpty()) {
+ assertTrue(iteration++ < MAXIMUM_STACK_CAPACITY, "Exceeded maximum stack modification count of 1 << 18");
+
+ e = stack.pop();
+ Spliterator<T> parentAndRightSplit = e.s;
+
+ long parentEstimateSize = parentAndRightSplit.estimateSize();
+ assertTrue(parentEstimateSize >= 0,
+ String.format("Split size estimate %d < 0", parentEstimateSize));
+
+ long parentSize = parentAndRightSplit.getExactSizeIfKnown();
+ Spliterator<T> leftSplit = parentAndRightSplit.trySplit();
+ if (leftSplit == null) {
+ parentAndRightSplit.forEachRemaining(e.c);
+ continue;
+ }
+
+ assertSpliterator(leftSplit, e.rootCharacteristics);
+ assertSpliterator(parentAndRightSplit, e.rootCharacteristics);
+
+ if (parentEstimateSize != Long.MAX_VALUE && leftSplit.estimateSize() > 0
+ && parentAndRightSplit.estimateSize() > 0) {
+ assertTrue(leftSplit.estimateSize() < parentEstimateSize,
+ String.format("Left split size estimate %d >= parent split size estimate %d",
+ leftSplit.estimateSize(), parentEstimateSize));
+ assertTrue(parentAndRightSplit.estimateSize() < parentEstimateSize,
+ String.format("Right split size estimate %d >= parent split size estimate %d",
+ leftSplit.estimateSize(), parentEstimateSize));
+ }
+ else {
+ assertTrue(leftSplit.estimateSize() <= parentEstimateSize,
+ String.format("Left split size estimate %d > parent split size estimate %d",
+ leftSplit.estimateSize(), parentEstimateSize));
+ assertTrue(parentAndRightSplit.estimateSize() <= parentEstimateSize,
+ String.format("Right split size estimate %d > parent split size estimate %d",
+ leftSplit.estimateSize(), parentEstimateSize));
+ }
+
+ long leftSize = leftSplit.getExactSizeIfKnown();
+ long rightSize = parentAndRightSplit.getExactSizeIfKnown();
+ if (parentSize >= 0 && leftSize >= 0 && rightSize >= 0)
+ assertEquals(parentSize, leftSize + rightSize,
+ String.format("exact left split size %d + exact right split size %d != parent exact split size %d",
+ leftSize, rightSize, parentSize));
+
+ // Add right side to stack first so left side is popped off first
+ stack.push(e.fromSplit(parentAndRightSplit));
+ stack.push(e.fromSplit(leftSplit));
+ }
+ }
+
+ private static void assertSpliterator(Spliterator<?> s, int rootCharacteristics) {
+ if ((rootCharacteristics & Spliterator.SUBSIZED) != 0) {
+ assertTrue(s.hasCharacteristics(Spliterator.SUBSIZED),
+ "Child split is not SUBSIZED when root split is SUBSIZED");
+ }
+ assertSpliterator(s);
+ }
+
+ private static void assertSpliterator(Spliterator<?> s) {
+ if (s.hasCharacteristics(Spliterator.SUBSIZED)) {
+ assertTrue(s.hasCharacteristics(Spliterator.SIZED));
+ }
+ if (s.hasCharacteristics(Spliterator.SIZED)) {
+ assertTrue(s.estimateSize() != Long.MAX_VALUE);
+ assertTrue(s.getExactSizeIfKnown() >= 0);
+ }
+ try {
+ s.getComparator();
+ assertTrue(s.hasCharacteristics(Spliterator.SORTED));
+ } catch (IllegalStateException e) {
+ assertFalse(s.hasCharacteristics(Spliterator.SORTED));
+ }
+ }
+
+ private static<T> void assertContents(Collection<T> actual, Collection<T> expected, boolean isOrdered) {
+ if (isOrdered) {
+ assertEquals(actual, expected);
+ }
+ else {
+ LambdaTestHelpers.assertContentsUnordered(actual, expected);
+ }
+ }
+
+ private static void executeAndCatch(Class<? extends Exception> expected, Runnable r) {
+ Exception caught = null;
+ try {
+ r.run();
+ }
+ catch (Exception e) {
+ caught = e;
+ }
+
+ assertNotNull(caught,
+ String.format("No Exception was thrown, expected an Exception of %s to be thrown",
+ expected.getName()));
+ assertTrue(expected.isInstance(caught),
+ String.format("Exception thrown %s not an instance of %s",
+ caught.getClass().getName(), expected.getName()));
+ }
+
+ static<U> void mixedTraverseAndSplit(Consumer<U> b, Spliterator<U> splTop) {
+ Spliterator<U> spl1, spl2, spl3;
+ splTop.tryAdvance(b);
+ spl2 = splTop.trySplit();
+ if (spl2 != null) {
+ spl2.tryAdvance(b);
+ spl1 = spl2.trySplit();
+ if (spl1 != null) {
+ spl1.tryAdvance(b);
+ spl1.forEachRemaining(b);
+ }
+ spl2.tryAdvance(b);
+ spl2.forEachRemaining(b);
+ }
+ splTop.tryAdvance(b);
+ spl3 = splTop.trySplit();
+ if (spl3 != null) {
+ spl3.tryAdvance(b);
+ spl3.forEachRemaining(b);
+ }
+ splTop.tryAdvance(b);
+ splTop.forEachRemaining(b);
+ }
+
+ static void mixedTraverseAndSplit(IntConsumer b, Spliterator.OfInt splTop) {
+ Spliterator.OfInt spl1, spl2, spl3;
+ splTop.tryAdvance(b);
+ spl2 = splTop.trySplit();
+ if (spl2 != null) {
+ spl2.tryAdvance(b);
+ spl1 = spl2.trySplit();
+ if (spl1 != null) {
+ spl1.tryAdvance(b);
+ spl1.forEachRemaining(b);
+ }
+ spl2.tryAdvance(b);
+ spl2.forEachRemaining(b);
+ }
+ splTop.tryAdvance(b);
+ spl3 = splTop.trySplit();
+ if (spl3 != null) {
+ spl3.tryAdvance(b);
+ spl3.forEachRemaining(b);
+ }
+ splTop.tryAdvance(b);
+ splTop.forEachRemaining(b);
+ }
+ static void mixedTraverseAndSplit(LongConsumer b, Spliterator.OfLong splTop) {
+ Spliterator.OfLong spl1, spl2, spl3;
+ splTop.tryAdvance(b);
+ spl2 = splTop.trySplit();
+ if (spl2 != null) {
+ spl2.tryAdvance(b);
+ spl1 = spl2.trySplit();
+ if (spl1 != null) {
+ spl1.tryAdvance(b);
+ spl1.forEachRemaining(b);
+ }
+ spl2.tryAdvance(b);
+ spl2.forEachRemaining(b);
+ }
+ splTop.tryAdvance(b);
+ spl3 = splTop.trySplit();
+ if (spl3 != null) {
+ spl3.tryAdvance(b);
+ spl3.forEachRemaining(b);
+ }
+ splTop.tryAdvance(b);
+ splTop.forEachRemaining(b);
+ }
+
+ static void mixedTraverseAndSplit(DoubleConsumer b, Spliterator.OfDouble splTop) {
+ Spliterator.OfDouble spl1, spl2, spl3;
+ splTop.tryAdvance(b);
+ spl2 = splTop.trySplit();
+ if (spl2 != null) {
+ spl2.tryAdvance(b);
+ spl1 = spl2.trySplit();
+ if (spl1 != null) {
+ spl1.tryAdvance(b);
+ spl1.forEachRemaining(b);
+ }
+ spl2.tryAdvance(b);
+ spl2.forEachRemaining(b);
+ }
+ splTop.tryAdvance(b);
+ spl3 = splTop.trySplit();
+ if (spl3 != null) {
+ spl3.tryAdvance(b);
+ spl3.forEachRemaining(b);
+ }
+ splTop.tryAdvance(b);
+ splTop.forEachRemaining(b);
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StatefulTestOp.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StatefulTestOp.java
new file mode 100644
index 0000000..5414cfd
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StatefulTestOp.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.util.stream;
+
+import java.util.Spliterator;
+import java.util.function.IntFunction;
+
+/**
+ * The base type for a stateful test operation.
+ */
+interface StatefulTestOp<E> extends IntermediateTestOp<E, E> {
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ public static<T> AbstractPipeline chain(AbstractPipeline upstream,
+ StatefulTestOp op) {
+ switch (op.outputShape()) {
+ case REFERENCE:
+ return new ReferencePipeline.StatefulOp<Object, T>(upstream, op.inputShape(), op.opGetFlags()) {
+ @Override
+ Sink opWrapSink(int flags, Sink sink) {
+ return op.opWrapSink(flags, isParallel(), sink);
+ }
+
+ @Override
+ <P_IN> Spliterator<T> opEvaluateParallelLazy(PipelineHelper<T> helper,
+ Spliterator<P_IN> spliterator) {
+ return op.opEvaluateParallelLazy(helper, spliterator);
+ }
+
+ @Override
+ <P_IN> Node<T> opEvaluateParallel(PipelineHelper<T> helper,
+ Spliterator<P_IN> spliterator,
+ IntFunction<T[]> generator) {
+ return op.opEvaluateParallel(helper, spliterator, generator);
+ }
+ };
+ case INT_VALUE:
+ return new IntPipeline.StatefulOp<Object>(upstream, op.inputShape(), op.opGetFlags()) {
+ @Override
+ Sink opWrapSink(int flags, Sink sink) {
+ return op.opWrapSink(flags, isParallel(), sink);
+ }
+
+ @Override
+ <P_IN> Spliterator<Integer> opEvaluateParallelLazy(PipelineHelper<Integer> helper,
+ Spliterator<P_IN> spliterator) {
+ return op.opEvaluateParallelLazy(helper, spliterator);
+ }
+
+ @Override
+ <P_IN> Node<Integer> opEvaluateParallel(PipelineHelper<Integer> helper,
+ Spliterator<P_IN> spliterator,
+ IntFunction<Integer[]> generator) {
+ return (Node<Integer>) op.opEvaluateParallel(helper, spliterator, generator);
+ }
+ };
+ case LONG_VALUE:
+ return new LongPipeline.StatefulOp<Object>(upstream, op.inputShape(), op.opGetFlags()) {
+ @Override
+ Sink opWrapSink(int flags, Sink sink) {
+ return op.opWrapSink(flags, isParallel(), sink);
+ }
+
+ @Override
+ <P_IN> Spliterator<Long> opEvaluateParallelLazy(PipelineHelper<Long> helper,
+ Spliterator<P_IN> spliterator) {
+ return op.opEvaluateParallelLazy(helper, spliterator);
+ }
+
+ @Override
+ <P_IN> Node<Long> opEvaluateParallel(PipelineHelper<Long> helper,
+ Spliterator<P_IN> spliterator,
+ IntFunction<Long[]> generator) {
+ return (Node<Long>) op.opEvaluateParallel(helper, spliterator, generator);
+ }
+ };
+ case DOUBLE_VALUE:
+ return new DoublePipeline.StatefulOp<Object>(upstream, op.inputShape(), op.opGetFlags()) {
+ @Override
+ Sink opWrapSink(int flags, Sink sink) {
+ return op.opWrapSink(flags, isParallel(), sink);
+ }
+
+ @Override
+ <P_IN> Spliterator<Double> opEvaluateParallelLazy(PipelineHelper<Double> helper,
+ Spliterator<P_IN> spliterator) {
+ return op.opEvaluateParallelLazy(helper, spliterator);
+ }
+
+ @Override
+ <P_IN> Node<Double> opEvaluateParallel(PipelineHelper<Double> helper,
+ Spliterator<P_IN> spliterator,
+ IntFunction<Double[]> generator) {
+ return (Node<Double>) op.opEvaluateParallel(helper, spliterator, generator);
+ }
+ };
+ default: throw new IllegalStateException(op.outputShape().toString());
+ }
+ }
+
+ default StreamShape inputShape() { return StreamShape.REFERENCE; }
+
+ default StreamShape outputShape() { return StreamShape.REFERENCE; }
+
+ default int opGetFlags() { return 0; }
+
+ Sink<E> opWrapSink(int flags, boolean parallel, Sink<E> sink);
+
+ @SuppressWarnings("unchecked")
+ default <P_IN> Spliterator<E> opEvaluateParallelLazy(PipelineHelper<E> helper,
+ Spliterator<P_IN> spliterator) {
+ return opEvaluateParallel(helper, spliterator, i -> (E[]) new Object[i]).spliterator();
+ }
+
+ <P_IN> Node<E> opEvaluateParallel(PipelineHelper<E> helper,
+ Spliterator<P_IN> spliterator,
+ IntFunction<E[]> generator);
+}
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StatelessTestOp.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StatelessTestOp.java
new file mode 100644
index 0000000..77460b7
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StatelessTestOp.java
@@ -0,0 +1,73 @@
+/*
+ * 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;
+
+/**
+ * The base type of a stateless test operation
+ */
+interface StatelessTestOp<E_IN, E_OUT> extends IntermediateTestOp<E_IN, E_OUT> {
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ public static<T> AbstractPipeline chain(AbstractPipeline upstream,
+ StatelessTestOp<?, T> op) {
+ int flags = op.opGetFlags();
+ switch (op.outputShape()) {
+ case REFERENCE:
+ return new ReferencePipeline.StatelessOp<Object, T>(upstream, op.inputShape(), flags) {
+ public Sink opWrapSink(int flags, Sink<T> sink) {
+ return op.opWrapSink(flags, isParallel(), sink);
+ }
+ };
+ case INT_VALUE:
+ return new IntPipeline.StatelessOp<Object>(upstream, op.inputShape(), flags) {
+ public Sink opWrapSink(int flags, Sink sink) {
+ return op.opWrapSink(flags, isParallel(), sink);
+ }
+ };
+ case LONG_VALUE:
+ return new LongPipeline.StatelessOp<Object>(upstream, op.inputShape(), flags) {
+ @Override
+ Sink opWrapSink(int flags, Sink sink) {
+ return op.opWrapSink(flags, isParallel(), sink);
+ }
+ };
+ case DOUBLE_VALUE:
+ return new DoublePipeline.StatelessOp<Object>(upstream, op.inputShape(), flags) {
+ @Override
+ Sink opWrapSink(int flags, Sink sink) {
+ return op.opWrapSink(flags, isParallel(), sink);
+ }
+ };
+ default: throw new IllegalStateException(op.outputShape().toString());
+ }
+ }
+
+ default StreamShape inputShape() { return StreamShape.REFERENCE; }
+
+ default StreamShape outputShape() { return StreamShape.REFERENCE; }
+
+ default int opGetFlags() { return 0; }
+
+ Sink<E_IN> opWrapSink(int flags, boolean parallel, Sink<E_OUT> sink);
+}
+
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StreamOpFlagTestHelper.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StreamOpFlagTestHelper.java
new file mode 100644
index 0000000..11ed0f1
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StreamOpFlagTestHelper.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.util.stream;
+
+import java.util.EnumSet;
+
+public class StreamOpFlagTestHelper {
+
+ /** EnumSet containing stream flags */
+ private static final EnumSet<StreamOpFlag> allStreamFlags;
+
+ static {
+ allStreamFlags = EnumSet.allOf(StreamOpFlag.class);
+ for (StreamOpFlag f : EnumSet.allOf(StreamOpFlag.class))
+ if (!f.isStreamFlag())
+ allStreamFlags.remove(f);
+ }
+
+
+ static EnumSet<StreamOpFlag> allStreamFlags() {
+ // EnumSet is mutable
+ return allStreamFlags.clone();
+ }
+
+ public static boolean isStreamOrdered(Stream<?> s) {
+ return StreamOpFlag.ORDERED.isKnown(OpTestCase.getStreamFlags(s));
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StreamTestDataProvider.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StreamTestDataProvider.java
new file mode 100644
index 0000000..cc98529
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StreamTestDataProvider.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.util.stream;
+
+import org.testng.annotations.DataProvider;
+
+import java.util.*;
+import java.util.Spliterators;
+import java.util.function.Supplier;
+
+/**
+ * StreamTestDataProvider
+ *
+ * @author Brian Goetz
+ */
+/** TestNG DataProvider for ref-valued streams */
+public class StreamTestDataProvider {
+ private static final Integer[] to0 = new Integer[0];
+ private static final Integer[] to1 = new Integer[1];
+ private static final Integer[] to10 = new Integer[10];
+ private static final Integer[] to100 = new Integer[100];
+ private static final Integer[] to1000 = new Integer[1000];
+ private static final Integer[] reversed = new Integer[100];
+ private static final Integer[] ones = new Integer[100];
+ private static final Integer[] twice = new Integer[200];
+ private static final Integer[] pseudoRandom;
+
+ private static final Object[][] testData;
+ private static final Object[][] withNullTestData;
+ private static final Object[][] spliteratorTestData;
+
+ static {
+ Integer[][] arrays = {to0, to1, to10, to100, to1000};
+ for (Integer[] arr : arrays) {
+ for (int i = 0; i < arr.length; i++) {
+ arr[i] = i;
+ }
+ }
+ for (int i = 0; i < reversed.length; i++) {
+ reversed[i] = reversed.length - i;
+ }
+ for (int i = 0; i < ones.length; i++) {
+ ones[i] = 1;
+ }
+ System.arraycopy(to100, 0, twice, 0, to100.length);
+ System.arraycopy(to100, 0, twice, to100.length, to100.length);
+ pseudoRandom = new Integer[LambdaTestHelpers.LONG_STRING.length()];
+ for (int i = 0; i < LambdaTestHelpers.LONG_STRING.length(); i++) {
+ pseudoRandom[i] = (int) LambdaTestHelpers.LONG_STRING.charAt(i);
+ }
+ }
+
+ static final Object[][] arrays = {
+ {"empty", to0},
+ {"0..1", to1},
+ {"0..10", to10},
+ {"0..100", to100},
+ {"0..1000", to1000},
+ {"100x[1]", ones},
+ {"2x[0..100]", twice},
+ {"reverse 0..100", reversed},
+ {"pseudorandom", pseudoRandom}
+ };
+
+ static {
+ {
+ List<Object[]> list = new ArrayList<>();
+ for (Object[] data : arrays) {
+ final Object name = data[0];
+ final Integer[] ints = (Integer[])data[1];
+ final List<Integer> intsAsList = Arrays.asList(ints);
+
+ list.add(arrayDataDescr("array:" + name, ints));
+ list.add(collectionDataDescr("ArrayList.asList:" + name, intsAsList));
+ list.add(collectionDataDescr("ArrayList:" + name, new ArrayList<>(intsAsList)));
+ list.add(streamDataDescr("DelegatingStream(ArrayList):" + name,
+ () -> new ArrayList<>(intsAsList).stream()));
+ List<Integer> aList = new ArrayList<>(intsAsList);
+ if (LambdaTestMode.isNormalMode()) {
+ // Only include sub-lists for normal test execution mode
+ // This data is serialization-hostile since the state of the
+ // deserialized sub-list will be out of sync with the
+ // enclosing list.
+ list.add(collectionDataDescr("ArrayList.Sublist:" + name,
+ (ints.length) <= 1 ? aList.subList(0, 0) : aList.subList(1, ints.length / 2)));
+ }
+ list.add(collectionDataDescr("LinkedList:" + name, new LinkedList<>(intsAsList)));
+ list.add(collectionDataDescr("HashSet:" + name, new HashSet<>(intsAsList)));
+ list.add(collectionDataDescr("LinkedHashSet:" + name, new LinkedHashSet<>(intsAsList)));
+ list.add(collectionDataDescr("TreeSet:" + name, new TreeSet<>(intsAsList)));
+ SpinedBuffer<Integer> spinedBuffer = new SpinedBuffer<>();
+ intsAsList.forEach(spinedBuffer);
+ list.add(sbDataDescr("SpinedBuffer:" + name, spinedBuffer));
+
+ // @@@ Add more
+ }
+ testData = list.toArray(new Object[0][]);
+ }
+
+ // Simple combination of numbers and null values, probably excessive but may catch
+ // errors for initialization/termination/sequence
+ // @@@ This is separate from the other data for now until nulls are consitently supported by
+ // all operations
+ {
+ List<Object[]> list = new ArrayList<>();
+ int size = 5;
+ for (int i = 0; i < (1 << size) - 2; i++) {
+ Integer[] content = new Integer[size];
+ for (int e = 0; e < size; e++) {
+ content[e] = (i & (1 << e)) > 0 ? e + 1 : null;
+ }
+
+ // ORDERED
+ list.add(arrayDataDescr("array:" + i, content));
+ // not ORDERED, DISTINCT
+ list.add(collectionDataDescr("HashSet:" + i, new HashSet<>(Arrays.asList(content))));
+ }
+
+ withNullTestData = list.toArray(new Object[0][]);
+ }
+
+ {
+ List<Object[]> spliterators = new ArrayList<>();
+ for (Object[] data : arrays) {
+ final Object name = data[0];
+ final Integer[] ints = (Integer[])data[1];
+
+ spliterators.add(splitDescr("Arrays.s(array):" + name,
+ () -> Arrays.spliterator(ints)));
+ spliterators.add(splitDescr("arrays.s(array,o,l):" + name,
+ () -> Arrays.spliterator(ints, 0, ints.length/2)));
+ spliterators.add(splitDescr("SpinedBuffer.s():" + name,
+ () -> {
+ SpinedBuffer<Integer> sb = new SpinedBuffer<>();
+ for (Integer i : ints)
+ sb.accept(i);
+ return sb.spliterator();
+ }));
+ spliterators.add(splitDescr("Iterators.s(Arrays.s(array).iterator(), size):" + name,
+ () -> Spliterators.spliterator(Arrays.asList(ints).iterator(), ints.length, 0)));
+ spliterators.add(splitDescr("Iterators.s(Arrays.s(array).iterator()):" + name,
+ () -> Spliterators.spliteratorUnknownSize(Arrays.asList(ints).iterator(), 0)));
+ // @@@ Add map and collection spliterators when spliterator() is exposed on Collection or Iterable
+ }
+ spliteratorTestData = spliterators.toArray(new Object[0][]);
+ }
+ }
+
+ static <T> Object[] arrayDataDescr(String description, T[] data) {
+ return new Object[] { description, TestData.Factory.ofArray(description, data)};
+ }
+
+ static <T> Object[] streamDataDescr(String description, Supplier<Stream<T>> supplier) {
+ return new Object[] { description, TestData.Factory.ofSupplier(description, supplier)};
+ }
+
+ static <T> Object[] collectionDataDescr(String description, Collection<T> data) {
+ return new Object[] { description, TestData.Factory.ofCollection(description, data)};
+ }
+
+ static <T> Object[] sbDataDescr(String description, SpinedBuffer<T> data) {
+ return new Object[] { description, TestData.Factory.ofSpinedBuffer(description, data)};
+ }
+
+ static <T> Object[] splitDescr(String description, Supplier<Spliterator<T>> ss) {
+ return new Object[] { description, ss };
+ }
+
+ // Return an array of ( String name, StreamTestData<Integer> )
+ @DataProvider(name = "StreamTestData<Integer>")
+ public static Object[][] makeStreamTestData() {
+ return testData;
+ }
+
+ @DataProvider(name = "withNull:StreamTestData<Integer>")
+ public static Object[][] makeStreamWithNullTestData() {
+ return withNullTestData;
+ }
+
+ // returns an array of (String name, Supplier<Spliterator<Integer>>)
+ @DataProvider(name = "Spliterator<Integer>")
+ public static Object[][] spliteratorProvider() {
+ return spliteratorTestData;
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java
new file mode 100644
index 0000000..d19c416
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java
@@ -0,0 +1,270 @@
+/*
+ * Copyright (c) 2012, 2015, 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.Collections;
+import java.util.EnumSet;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+/**
+ * Test scenarios for reference streams.
+ *
+ * Each scenario is provided with a data source, a function that maps a fresh
+ * stream (as provided by the data source) to a new stream, and a sink to
+ * receive results. Each scenario describes a different way of computing the
+ * stream contents. The test driver will ensure that all scenarios produce
+ * the same output (modulo allowable differences in ordering).
+ */
+@SuppressWarnings({"rawtypes", "unchecked"})
+public enum StreamTestScenario implements OpTestCase.BaseStreamTestScenario {
+
+ STREAM_FOR_EACH_WITH_CLOSE(false) {
+ <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
+ Stream<U> s = m.apply(data.stream());
+ if (s.isParallel()) {
+ s = s.sequential();
+ }
+ s.forEach(b);
+ s.close();
+ }
+ },
+
+ // Collec to list
+ STREAM_COLLECT(false) {
+ <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
+ for (U t : m.apply(data.stream()).collect(Collectors.toList())) {
+ b.accept(t);
+ }
+ }
+ },
+
+ // To array
+ STREAM_TO_ARRAY(false) {
+ <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
+ for (Object t : m.apply(data.stream()).toArray()) {
+ b.accept((U) t);
+ }
+ }
+ },
+
+ // Wrap as stream, and iterate in pull mode
+ STREAM_ITERATOR(false) {
+ <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
+ for (Iterator<U> seqIter = m.apply(data.stream()).iterator(); seqIter.hasNext(); )
+ b.accept(seqIter.next());
+ }
+ },
+
+ // Wrap as stream, and spliterate then iterate in pull mode
+ STREAM_SPLITERATOR(false) {
+ <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
+ for (Spliterator<U> spl = m.apply(data.stream()).spliterator(); spl.tryAdvance(b); ) { }
+ }
+ },
+
+ // Wrap as stream, spliterate, then split a few times mixing advances with forEach
+ STREAM_SPLITERATOR_WITH_MIXED_TRAVERSE_AND_SPLIT(false) {
+ <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
+ SpliteratorTestHelper.mixedTraverseAndSplit(b, m.apply(data.stream()).spliterator());
+ }
+ },
+
+ // Wrap as stream, and spliterate then iterate in pull mode
+ STREAM_SPLITERATOR_FOREACH(false) {
+ <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
+ m.apply(data.stream()).spliterator().forEachRemaining(b);
+ }
+ },
+
+ // Wrap as parallel stream + sequential
+ PAR_STREAM_SEQUENTIAL_FOR_EACH(true) {
+ <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
+ m.apply(data.parallelStream()).sequential().forEach(b);
+ }
+ },
+
+ // Wrap as parallel stream + forEachOrdered
+ PAR_STREAM_FOR_EACH_ORDERED(true) {
+ <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
+ // @@@ Want to explicitly select ordered equalator
+ m.apply(data.parallelStream()).forEachOrdered(b);
+ }
+ },
+
+ // Wrap as stream, and spliterate then iterate sequentially
+ PAR_STREAM_SPLITERATOR(true) {
+ <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
+ for (Spliterator<U> spl = m.apply(data.parallelStream()).spliterator(); spl.tryAdvance(b); ) { }
+ }
+ },
+
+ // Wrap as stream, and spliterate then iterate sequentially
+ PAR_STREAM_SPLITERATOR_FOREACH(true) {
+ <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
+ m.apply(data.parallelStream()).spliterator().forEachRemaining(b);
+ }
+ },
+
+ // Wrap as parallel stream + toArray
+ PAR_STREAM_TO_ARRAY(true) {
+ <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
+ for (Object t : m.apply(data.parallelStream()).toArray())
+ b.accept((U) t);
+ }
+ },
+
+ // Wrap as parallel stream, get the spliterator, wrap as a stream + toArray
+ PAR_STREAM_SPLITERATOR_STREAM_TO_ARRAY(true) {
+ <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
+ Stream<U> s = m.apply(data.parallelStream());
+ Spliterator<U> sp = s.spliterator();
+ Stream<U> ss = StreamSupport.stream(() -> sp,
+ StreamOpFlag.toCharacteristics(OpTestCase.getStreamFlags(s))
+ | (sp.getExactSizeIfKnown() < 0 ? 0 : Spliterator.SIZED), true);
+ for (Object t : ss.toArray())
+ b.accept((U) t);
+ }
+ },
+
+ // Wrap as parallel stream + toArray and clear SIZED flag
+ PAR_STREAM_TO_ARRAY_CLEAR_SIZED(true) {
+ <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
+ S_IN pipe1 = (S_IN) OpTestCase.chain(data.parallelStream(),
+ new FlagDeclaringOp(StreamOpFlag.NOT_SIZED, data.getShape()));
+ Stream<U> pipe2 = m.apply(pipe1);
+
+ for (Object t : pipe2.toArray())
+ b.accept((U) t);
+ }
+ },
+
+ // Wrap as parallel + collect to list
+ PAR_STREAM_COLLECT_TO_LIST(true) {
+ <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
+ for (U u : m.apply(data.parallelStream()).collect(Collectors.toList()))
+ b.accept(u);
+ }
+ },
+
+ // Wrap sequential as parallel, + collect to list
+ STREAM_TO_PAR_STREAM_COLLECT_TO_LIST(true) {
+ <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
+ for (U u : m.apply(data.stream().parallel()).collect(Collectors.toList()))
+ b.accept(u);
+ }
+ },
+
+ // Wrap parallel as sequential,, + collect
+ PAR_STREAM_TO_STREAM_COLLECT_TO_LIST(true) {
+ <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
+ for (U u : m.apply(data.parallelStream().sequential()).collect(Collectors.toList()))
+ b.accept(u);
+ }
+ },
+
+ // Wrap as parallel stream + forEach synchronizing
+ PAR_STREAM_FOR_EACH(true, false) {
+ <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
+ m.apply(data.parallelStream()).forEach(e -> {
+ synchronized (data) {
+ b.accept(e);
+ }
+ });
+ }
+ },
+
+ // Wrap as parallel stream + forEach synchronizing and clear SIZED flag
+ PAR_STREAM_FOR_EACH_CLEAR_SIZED(true, false) {
+ <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m) {
+ S_IN pipe1 = (S_IN) OpTestCase.chain(data.parallelStream(),
+ new FlagDeclaringOp(StreamOpFlag.NOT_SIZED, data.getShape()));
+ m.apply(pipe1).forEach(e -> {
+ synchronized (data) {
+ b.accept(e);
+ }
+ });
+ }
+ },
+ ;
+
+ // The set of scenarios that clean the SIZED flag
+ public static final Set<StreamTestScenario> CLEAR_SIZED_SCENARIOS = Collections.unmodifiableSet(
+ EnumSet.of(PAR_STREAM_TO_ARRAY_CLEAR_SIZED, PAR_STREAM_FOR_EACH_CLEAR_SIZED));
+
+ private final boolean isParallel;
+
+ private final boolean isOrdered;
+
+ StreamTestScenario(boolean isParallel) {
+ this(isParallel, true);
+ }
+
+ StreamTestScenario(boolean isParallel, boolean isOrdered) {
+ this.isParallel = isParallel;
+ this.isOrdered = isOrdered;
+ }
+
+ public StreamShape getShape() {
+ return StreamShape.REFERENCE;
+ }
+
+ public boolean isParallel() {
+ return isParallel;
+ }
+
+ public boolean isOrdered() {
+ return isOrdered;
+ }
+
+ public <T, U, S_IN extends BaseStream<T, S_IN>, S_OUT extends BaseStream<U, S_OUT>>
+ void run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, S_OUT> m) {
+ _run(data, b, (Function<S_IN, Stream<U>>) m);
+ }
+
+ abstract <T, U, S_IN extends BaseStream<T, S_IN>>
+ void _run(TestData<T, S_IN> data, Consumer<U> b, Function<S_IN, Stream<U>> m);
+
+}
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/TestData.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/TestData.java
new file mode 100644
index 0000000..c763e84
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/TestData.java
@@ -0,0 +1,355 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.util.stream;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.PrimitiveIterator;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.function.DoubleConsumer;
+import java.util.function.Function;
+import java.util.function.IntConsumer;
+import java.util.function.LongConsumer;
+import java.util.function.Supplier;
+import java.util.function.ToIntFunction;
+
+/** Describes a test data set for use in stream tests */
+public interface TestData<T, S extends BaseStream<T, S>>
+ extends Iterable<T> {
+
+ default int size() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ default Iterator<T> iterator() {
+ return Spliterators.iterator(spliterator());
+ }
+
+ Spliterator<T> spliterator();
+
+ default boolean isOrdered() {
+ return spliterator().hasCharacteristics(Spliterator.ORDERED);
+ }
+
+ StreamShape getShape();
+
+ default <A extends Collection<? super T>> A into(A target) {
+ spliterator().forEachRemaining(target::add);
+ return target;
+ }
+
+ S stream();
+
+ S parallelStream();
+
+ public interface OfRef<T> extends TestData<T, Stream<T>> { }
+
+ public interface OfInt extends TestData<Integer, IntStream> { }
+
+ public interface OfLong extends TestData<Long, LongStream> { }
+
+ public interface OfDouble extends TestData<Double, DoubleStream> { }
+
+ // @@@ Temporary garbage class to avoid triggering bugs with lambdas in static methods in interfaces
+ public static class Factory {
+ public static <T> OfRef<T> ofArray(String name, T[] array) {
+ return new AbstractTestData.RefTestData<>(name, array, Arrays::stream, a -> Arrays.stream(a).parallel(),
+ Arrays::spliterator, a -> a.length);
+ }
+
+ public static <T> OfRef<T> ofCollection(String name, Collection<T> collection) {
+ return new AbstractTestData.RefTestData<>(name, collection, Collection::stream, Collection::parallelStream,
+ Collection::spliterator, Collection::size);
+ }
+
+ public static <T> OfRef<T> ofSpinedBuffer(String name, SpinedBuffer<T> buffer) {
+ return new AbstractTestData.RefTestData<>(name, buffer,
+ b -> StreamSupport.stream(b.spliterator(), false),
+ b -> StreamSupport.stream(b.spliterator(), true),
+ SpinedBuffer::spliterator,
+ b -> (int) b.count());
+ }
+
+ public static <T> OfRef<T> ofSupplier(String name, Supplier<Stream<T>> supplier) {
+ return new AbstractTestData.RefTestData<>(name, supplier,
+ Supplier::get,
+ s -> s.get().parallel(),
+ s -> s.get().spliterator(),
+ s -> (int) s.get().spliterator().getExactSizeIfKnown());
+ }
+
+ public static <T> OfRef<T> ofRefNode(String name, Node<T> node) {
+ return new AbstractTestData.RefTestData<>(name, node,
+ n -> StreamSupport.stream(n::spliterator, Spliterator.SIZED | Spliterator.ORDERED, false),
+ n -> StreamSupport.stream(n::spliterator, Spliterator.SIZED | Spliterator.ORDERED, true),
+ Node::spliterator,
+ n -> (int) n.count());
+ }
+
+ // int factories
+ public static <T> OfInt ofArray(String name, int[] array) {
+ return new AbstractTestData.IntTestData<>(name, array, Arrays::stream, a -> Arrays.stream(a).parallel(),
+ Arrays::spliterator, a -> a.length);
+ }
+
+ public static OfInt ofSpinedBuffer(String name, SpinedBuffer.OfInt buffer) {
+ return new AbstractTestData.IntTestData<>(name, buffer,
+ b -> StreamSupport.intStream(b.spliterator(), false),
+ b -> StreamSupport.intStream(b.spliterator(), true),
+ SpinedBuffer.OfInt::spliterator,
+ b -> (int) b.count());
+ }
+
+ public static OfInt ofIntSupplier(String name, Supplier<IntStream> supplier) {
+ return new AbstractTestData.IntTestData<>(name, supplier,
+ Supplier::get,
+ s -> s.get().parallel(),
+ s -> s.get().spliterator(),
+ s -> (int) s.get().spliterator().getExactSizeIfKnown());
+ }
+
+ public static OfInt ofNode(String name, Node.OfInt node) {
+ int characteristics = Spliterator.SIZED | Spliterator.ORDERED;
+ return new AbstractTestData.IntTestData<>(name, node,
+ n -> StreamSupport.intStream(n::spliterator, characteristics, false),
+ n -> StreamSupport.intStream(n::spliterator, characteristics, true),
+ Node.OfInt::spliterator,
+ n -> (int) n.count());
+ }
+
+ // long factories
+ public static <T> OfLong ofArray(String name, long[] array) {
+ return new AbstractTestData.LongTestData<>(name, array, Arrays::stream, a -> Arrays.stream(a).parallel(),
+ Arrays::spliterator, a -> a.length);
+ }
+
+ public static OfLong ofSpinedBuffer(String name, SpinedBuffer.OfLong buffer) {
+ return new AbstractTestData.LongTestData<>(name, buffer,
+ b -> StreamSupport.longStream(b.spliterator(), false),
+ b -> StreamSupport.longStream(b.spliterator(), true),
+ SpinedBuffer.OfLong::spliterator,
+ b -> (int) b.count());
+ }
+
+ public static OfLong ofLongSupplier(String name, Supplier<LongStream> supplier) {
+ return new AbstractTestData.LongTestData<>(name, supplier,
+ Supplier::get,
+ s -> s.get().parallel(),
+ s -> s.get().spliterator(),
+ s -> (int) s.get().spliterator().getExactSizeIfKnown());
+ }
+
+ public static OfLong ofNode(String name, Node.OfLong node) {
+ int characteristics = Spliterator.SIZED | Spliterator.ORDERED;
+ return new AbstractTestData.LongTestData<>(name, node,
+ n -> StreamSupport.longStream(n::spliterator, characteristics, false),
+ n -> StreamSupport.longStream(n::spliterator, characteristics, true),
+ Node.OfLong::spliterator,
+ n -> (int) n.count());
+ }
+
+ // double factories
+ public static <T> OfDouble ofArray(String name, double[] array) {
+ return new AbstractTestData.DoubleTestData<>(name, array, Arrays::stream, a -> Arrays.stream(a).parallel(),
+ Arrays::spliterator, a -> a.length);
+ }
+
+ public static OfDouble ofSpinedBuffer(String name, SpinedBuffer.OfDouble buffer) {
+ return new AbstractTestData.DoubleTestData<>(name, buffer,
+ b -> StreamSupport.doubleStream(b.spliterator(), false),
+ b -> StreamSupport.doubleStream(b.spliterator(), true),
+ SpinedBuffer.OfDouble::spliterator,
+ b -> (int) b.count());
+ }
+
+ public static OfDouble ofDoubleSupplier(String name, Supplier<DoubleStream> supplier) {
+ return new AbstractTestData.DoubleTestData<>(name, supplier,
+ Supplier::get,
+ s -> s.get().parallel(),
+ s -> s.get().spliterator(),
+ s -> (int) s.get().spliterator().getExactSizeIfKnown());
+ }
+
+ public static OfDouble ofNode(String name, Node.OfDouble node) {
+ int characteristics = Spliterator.SIZED | Spliterator.ORDERED;
+ return new AbstractTestData.DoubleTestData<>(name, node,
+ n -> StreamSupport.doubleStream(n::spliterator, characteristics, false),
+ n -> StreamSupport.doubleStream(n::spliterator, characteristics, true),
+ Node.OfDouble::spliterator,
+ n -> (int) n.count());
+ }
+ }
+
+
+ abstract class AbstractTestData<T, S extends BaseStream<T, S>,
+ T_STATE,
+ T_SPLITR extends Spliterator<T>>
+ implements TestData<T, S> {
+ private final String name;
+ private final StreamShape shape;
+ protected final T_STATE state;
+ private final ToIntFunction<T_STATE> sizeFn;
+ private final Function<T_STATE, S> streamFn;
+ private final Function<T_STATE, S> parStreamFn;
+ private final Function<T_STATE, T_SPLITR> splitrFn;
+
+ AbstractTestData(String name,
+ StreamShape shape,
+ T_STATE state,
+ Function<T_STATE, S> streamFn,
+ Function<T_STATE, S> parStreamFn,
+ Function<T_STATE, T_SPLITR> splitrFn,
+ ToIntFunction<T_STATE> sizeFn) {
+ this.name = name;
+ this.shape = shape;
+ this.state = state;
+ this.streamFn = streamFn;
+ this.parStreamFn = parStreamFn;
+ this.splitrFn = splitrFn;
+ this.sizeFn = sizeFn;
+ }
+
+ @Override
+ public StreamShape getShape() {
+ return shape;
+ }
+
+ @Override
+ public String toString() {
+ return getClass().getSimpleName() + "[" + name + "]";
+ }
+
+ @Override
+ public int size() {
+ return sizeFn.applyAsInt(state);
+ }
+
+ @Override
+ public T_SPLITR spliterator() {
+ return splitrFn.apply(state);
+ }
+
+ @Override
+ public S stream() {
+ return streamFn.apply(state);
+ }
+
+ @Override
+ public S parallelStream() {
+ return parStreamFn.apply(state);
+ }
+
+ public static class RefTestData<T, I>
+ extends AbstractTestData<T, Stream<T>, I, Spliterator<T>>
+ implements TestData.OfRef<T> {
+
+ protected RefTestData(String name,
+ I state,
+ Function<I, Stream<T>> streamFn,
+ Function<I, Stream<T>> parStreamFn,
+ Function<I, Spliterator<T>> splitrFn,
+ ToIntFunction<I> sizeFn) {
+ super(name, StreamShape.REFERENCE, state, streamFn, parStreamFn, splitrFn, sizeFn);
+ }
+
+ }
+
+ static class IntTestData<I>
+ extends AbstractTestData<Integer, IntStream, I, Spliterator.OfInt>
+ implements TestData.OfInt {
+
+ protected IntTestData(String name,
+ I state,
+ Function<I, IntStream> streamFn,
+ Function<I, IntStream> parStreamFn,
+ Function<I, Spliterator.OfInt> splitrFn,
+ ToIntFunction<I> sizeFn) {
+ super(name, StreamShape.INT_VALUE, state, streamFn, parStreamFn, splitrFn, sizeFn);
+ }
+
+ @Override
+ public PrimitiveIterator.OfInt iterator() {
+ return Spliterators.iterator(spliterator());
+ }
+
+ @Override
+ public <A extends Collection<? super Integer>> A into(A target) {
+ spliterator().forEachRemaining((IntConsumer) target::add);
+ return target;
+ }
+ }
+
+ static class LongTestData<I>
+ extends AbstractTestData<Long, LongStream, I, Spliterator.OfLong>
+ implements TestData.OfLong {
+
+ protected LongTestData(String name,
+ I state,
+ Function<I, LongStream> streamFn,
+ Function<I, LongStream> parStreamFn,
+ Function<I, Spliterator.OfLong> splitrFn,
+ ToIntFunction<I> sizeFn) {
+ super(name, StreamShape.LONG_VALUE, state, streamFn, parStreamFn, splitrFn, sizeFn);
+ }
+
+ @Override
+ public PrimitiveIterator.OfLong iterator() {
+ return Spliterators.iterator(spliterator());
+ }
+
+ @Override
+ public <A extends Collection<? super Long>> A into(A target) {
+ spliterator().forEachRemaining((LongConsumer) target::add);
+ return target;
+ }
+ }
+
+ static class DoubleTestData<I>
+ extends AbstractTestData<Double, DoubleStream, I, Spliterator.OfDouble>
+ implements OfDouble {
+
+ protected DoubleTestData(String name,
+ I state,
+ Function<I, DoubleStream> streamFn,
+ Function<I, DoubleStream> parStreamFn,
+ Function<I, Spliterator.OfDouble> splitrFn,
+ ToIntFunction<I> sizeFn) {
+ super(name, StreamShape.DOUBLE_VALUE, state, streamFn, parStreamFn, splitrFn, sizeFn);
+ }
+
+ @Override
+ public PrimitiveIterator.OfDouble iterator() {
+ return Spliterators.iterator(spliterator());
+ }
+
+ @Override
+ public <A extends Collection<? super Double>> A into(A target) {
+ spliterator().forEachRemaining((DoubleConsumer) target::add);
+ return target;
+ }
+ }
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/TestFlagExpectedOp.java b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/TestFlagExpectedOp.java
new file mode 100644
index 0000000..c59a185
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/bootlib/java/util/stream/TestFlagExpectedOp.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.util.stream;
+
+import org.testng.Assert;
+
+import java.util.EnumSet;
+
+class TestFlagExpectedOp<T> extends FlagDeclaringOp<T> {
+
+ static class Builder<T> {
+ final int flags;
+ StreamShape shape = StreamShape.REFERENCE;
+
+ EnumSet<StreamOpFlag> known = EnumSet.noneOf(StreamOpFlag.class);
+ EnumSet<StreamOpFlag> preserve = EnumSet.noneOf(StreamOpFlag.class);
+ EnumSet<StreamOpFlag> notKnown = EnumSet.noneOf(StreamOpFlag.class);
+
+ Builder(int flags) {
+ this.flags = flags;
+ }
+
+ Builder<T> known(EnumSet<StreamOpFlag> known) {
+ this.known = known;
+ return this;
+ }
+
+ Builder<T> preserve(EnumSet<StreamOpFlag> preserve) {
+ this.preserve = preserve;
+ return this;
+ }
+
+ Builder<T> notKnown(EnumSet<StreamOpFlag> notKnown) {
+ this.notKnown = notKnown;
+ return this;
+ }
+
+ Builder<T> shape(StreamShape shape) {
+ this.shape = shape;
+ return this;
+ }
+
+ TestFlagExpectedOp<T> build() {
+ return new TestFlagExpectedOp<>(flags, known, preserve, notKnown, shape);
+ }
+ }
+
+ final EnumSet<StreamOpFlag> known;
+ final EnumSet<StreamOpFlag> preserve;
+ final EnumSet<StreamOpFlag> notKnown;
+ final StreamShape shape;
+
+ TestFlagExpectedOp(int flags,
+ EnumSet<StreamOpFlag> known,
+ EnumSet<StreamOpFlag> preserve,
+ EnumSet<StreamOpFlag> notKnown) {
+ this(flags, known, preserve, notKnown, StreamShape.REFERENCE);
+ }
+
+ TestFlagExpectedOp(int flags,
+ EnumSet<StreamOpFlag> known,
+ EnumSet<StreamOpFlag> preserve,
+ EnumSet<StreamOpFlag> notKnown,
+ StreamShape shape) {
+ super(flags);
+ this.known = known;
+ this.preserve = preserve;
+ this.notKnown = notKnown;
+ this.shape = shape;
+ }
+
+ @Override
+ public StreamShape outputShape() {
+ return shape;
+ }
+
+ @Override
+ public StreamShape inputShape() {
+ return shape;
+ }
+
+ @Override
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ public Sink<T> opWrapSink(int flags, boolean parallel, Sink upstream) {
+ assertFlags(flags);
+ return upstream;
+ }
+
+ private void assertFlags(int flags) {
+ for (StreamOpFlag f : known) {
+ Assert.assertTrue(f.isKnown(flags),
+ String.format("Flag %s is not known, but should be known.", f.toString()));
+ }
+
+ for (StreamOpFlag f : preserve) {
+ Assert.assertTrue(f.isPreserved(flags),
+ String.format("Flag %s is not preserved, but should be preserved.", f.toString()));
+ }
+
+ for (StreamOpFlag f : notKnown) {
+ Assert.assertFalse(f.isKnown(flags),
+ String.format("Flag %s is known, but should be not known.", f.toString()));
+ }
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/boottest/TEST.properties b/ojluni/src/test/java/util/stream/boottest/TEST.properties
new file mode 100644
index 0000000..d51ddf7
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/boottest/TEST.properties
@@ -0,0 +1,5 @@
+# This file identifies root(s) of the test-ng hierarchy.
+
+TestNG.dirs = .
+bootclasspath.dirs = .
+lib.dirs = /java/util/stream/bootlib
diff --git a/ojluni/src/test/java/util/stream/boottest/java/util/stream/DoubleNodeTest.java b/ojluni/src/test/java/util/stream/boottest/java/util/stream/DoubleNodeTest.java
new file mode 100644
index 0000000..c1e8a30
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/boottest/java/util/stream/DoubleNodeTest.java
@@ -0,0 +1,179 @@
+/*
+ * 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.Arrays;
+import java.util.List;
+import java.util.PrimitiveIterator;
+import java.util.Spliterators;
+import java.util.function.Function;
+
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+@Test
+public class DoubleNodeTest extends OpTestCase {
+
+ @DataProvider(name = "nodes")
+ public Object[][] createSizes() {
+ List<Object[]> params = new ArrayList<>();
+
+ for (int size : Arrays.asList(0, 1, 4, 15, 16, 17, 127, 128, 129, 1000)) {
+ double[] array = new double[size];
+ for (int i = 0; i < array.length; i++) {
+ array[i] = i;
+ }
+
+ List<Node<Double>> nodes = new ArrayList<>();
+
+ nodes.add(Nodes.node(array));
+ nodes.add(degenerateTree(Spliterators.iterator(Arrays.spliterator(array))));
+ nodes.add(tree(toList(array), l -> Nodes.node(toDoubleArray(l))));
+ nodes.add(fill(array, Nodes.doubleBuilder(array.length)));
+ nodes.add(fill(array, Nodes.doubleBuilder()));
+
+ for (Node<Double> node : nodes) {
+ params.add(new Object[]{array, node});
+ }
+
+ }
+
+ return params.toArray(new Object[0][]);
+ }
+
+ private static void assertEqualsListDoubleArray(List<Double> list, double[] array) {
+ assertEquals(list.size(), array.length);
+ for (int i = 0; i < array.length; i++)
+ assertEquals(array[i], list.get(i));
+ }
+
+ private List<Double> toList(double[] a) {
+ List<Double> l = new ArrayList<>();
+ for (double i : a) {
+ l.add(i);
+ }
+
+ return l;
+ }
+
+ private double[] toDoubleArray(List<Double> l) {
+ double[] a = new double[l.size()];
+
+ int i = 0;
+ for (Double e : l) {
+ a[i++] = e;
+ }
+ return a;
+ }
+
+ private Node.OfDouble fill(double[] array, Node.Builder.OfDouble nb) {
+ nb.begin(array.length);
+ for (double i : array)
+ nb.accept(i);
+ nb.end();
+ return nb.build();
+ }
+
+ private Node.OfDouble degenerateTree(PrimitiveIterator.OfDouble it) {
+ if (!it.hasNext()) {
+ return Nodes.node(new double[0]);
+ }
+
+ double i = it.nextDouble();
+ if (it.hasNext()) {
+ return new Nodes.ConcNode.OfDouble(Nodes.node(new double[] {i}), degenerateTree(it));
+ }
+ else {
+ return Nodes.node(new double[] {i});
+ }
+ }
+
+ private Node.OfDouble tree(List<Double> l, Function<List<Double>, Node.OfDouble> m) {
+ if (l.size() < 3) {
+ return m.apply(l);
+ }
+ else {
+ return new Nodes.ConcNode.OfDouble(
+ tree(l.subList(0, l.size() / 2), m),
+ tree(l.subList(l.size() / 2, l.size()), m));
+ }
+ }
+
+ @Test(dataProvider = "nodes")
+ public void testAsArray(double[] array, Node.OfDouble n) {
+ assertEquals(n.asPrimitiveArray(), array);
+ }
+
+ @Test(dataProvider = "nodes")
+ public void testFlattenAsArray(double[] array, Node.OfDouble n) {
+ assertEquals(Nodes.flattenDouble(n).asPrimitiveArray(), array);
+ }
+
+ @Test(dataProvider = "nodes")
+ public void testCopyTo(double[] array, Node.OfDouble n) {
+ double[] copy = new double[(int) n.count()];
+ n.copyInto(copy, 0);
+
+ assertEquals(copy, array);
+ }
+
+ @Test(dataProvider = "nodes", groups = { "serialization-hostile" })
+ public void testForEach(double[] array, Node.OfDouble n) {
+ List<Double> l = new ArrayList<>((int) n.count());
+ n.forEach((double e) -> {
+ l.add(e);
+ });
+
+ assertEqualsListDoubleArray(l, array);
+ }
+
+ @Test(dataProvider = "nodes")
+ public void testStreams(double[] array, Node.OfDouble n) {
+ TestData.OfDouble data = TestData.Factory.ofNode("Node", n);
+
+ exerciseOps(data, s -> s);
+
+ exerciseTerminalOps(data, s -> s.toArray());
+ }
+
+ @Test(dataProvider = "nodes", groups={ "serialization-hostile" })
+ // throws SOE on serialization of DoubleConcNode[size=1000]
+ 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/ojluni/src/test/java/util/stream/boottest/java/util/stream/FlagOpTest.java b/ojluni/src/test/java/util/stream/boottest/java/util/stream/FlagOpTest.java
new file mode 100644
index 0000000..1543108
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/boottest/java/util/stream/FlagOpTest.java
@@ -0,0 +1,283 @@
+/*
+ * Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.util.stream;
+
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.function.Supplier;
+
+import static java.util.stream.LambdaTestHelpers.countTo;
+
+@Test
+public class FlagOpTest extends OpTestCase {
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testFlagsPassThrough(String name, TestData<Integer, Stream<Integer>> data) {
+
+ @SuppressWarnings({"unchecked", "rawtypes"})
+ TestFlagPassThroughOp<Integer>[] ops = new TestFlagPassThroughOp[3];
+ ops[0] = new TestFlagPassThroughOp<>();
+ ops[1] = new TestFlagPassThroughOp<>();
+ ops[2] = new TestFlagPassThroughOp<>();
+
+ ops[0].set(null, ops[1]);
+ ops[1].set(ops[0], ops[2]);
+ ops[2].set(ops[1], null);
+
+ withData(data).ops(ops).exercise();
+ }
+
+ static class TestFlagPassThroughOp<T> extends FlagDeclaringOp<T> {
+ TestFlagPassThroughOp<T> upstream;
+ TestFlagPassThroughOp<T> downstream;
+
+ TestFlagPassThroughOp() {
+ super(0);
+ }
+
+ void set(TestFlagPassThroughOp<T> upstream, TestFlagPassThroughOp<T> downstream) {
+ this.upstream = upstream;
+ this.downstream = downstream;
+ }
+
+ int wrapFlags;
+
+ @Override
+ @SuppressWarnings({"unchecked", "rawtypes"})
+ public Sink<T> opWrapSink(int flags, boolean parallel, Sink sink) {
+ this.wrapFlags = flags;
+
+ if (downstream != null) {
+ assertTrue(flags == downstream.wrapFlags);
+ }
+
+ return sink;
+ }
+ }
+
+ public void testFlagsClearAllSet() {
+ int clearAllFlags = 0;
+ for (StreamOpFlag f : EnumSet.allOf(StreamOpFlag.class)) {
+ if (f.isStreamFlag()) {
+ clearAllFlags |= f.clear();
+ }
+ }
+
+ EnumSet<StreamOpFlag> known = EnumSet.noneOf(StreamOpFlag.class);
+ EnumSet<StreamOpFlag> notKnown = StreamOpFlagTestHelper.allStreamFlags();
+
+ List<FlagDeclaringOp<Integer>> ops = new ArrayList<>();
+ ops.add(new FlagDeclaringOp<>(clearAllFlags));
+ for (StreamOpFlag f : StreamOpFlagTestHelper.allStreamFlags()) {
+ if (f.canSet(StreamOpFlag.Type.OP)) {
+ ops.add(new TestFlagExpectedOp<>(f.set(),
+ known.clone(),
+ EnumSet.noneOf(StreamOpFlag.class),
+ notKnown.clone()));
+ known.add(f);
+ notKnown.remove(f);
+ }
+ }
+ ops.add(new TestFlagExpectedOp<>(0,
+ known.clone(),
+ EnumSet.noneOf(StreamOpFlag.class),
+ notKnown.clone()));
+
+ TestData<Integer, Stream<Integer>> data = TestData.Factory.ofArray("Array", countTo(10).toArray(new Integer[0]));
+ @SuppressWarnings("rawtypes")
+ FlagDeclaringOp[] opsArray = ops.toArray(new FlagDeclaringOp[ops.size()]);
+
+ withData(data).ops(opsArray).
+ without(StreamTestScenario.CLEAR_SIZED_SCENARIOS).
+ exercise();
+ }
+
+ public void testFlagsSetAllClear() {
+ EnumSet<StreamOpFlag> known = StreamOpFlagTestHelper.allStreamFlags();
+ int setAllFlags = 0;
+ for (StreamOpFlag f : EnumSet.allOf(StreamOpFlag.class)) {
+ if (f.isStreamFlag()) {
+ if (f.canSet(StreamOpFlag.Type.OP)) {
+ setAllFlags |= f.set();
+ } else {
+ known.remove(f);
+ }
+ }
+ }
+
+ EnumSet<StreamOpFlag> notKnown = EnumSet.noneOf(StreamOpFlag.class);
+
+ List<FlagDeclaringOp<Integer>> ops = new ArrayList<>();
+ ops.add(new FlagDeclaringOp<>(setAllFlags));
+ for (StreamOpFlag f : StreamOpFlagTestHelper.allStreamFlags()) {
+ ops.add(new TestFlagExpectedOp<>(f.clear(),
+ known.clone(),
+ EnumSet.noneOf(StreamOpFlag.class),
+ notKnown.clone()));
+ known.remove(f);
+ notKnown.add(f);
+ }
+ ops.add(new TestFlagExpectedOp<>(0,
+ known.clone(),
+ EnumSet.noneOf(StreamOpFlag.class),
+ notKnown.clone()));
+
+ TestData<Integer, Stream<Integer>> data = TestData.Factory.ofArray("Array", countTo(10).toArray(new Integer[0]));
+ @SuppressWarnings("rawtypes")
+ FlagDeclaringOp[] opsArray = ops.toArray(new FlagDeclaringOp[ops.size()]);
+
+
+ withData(data).ops(opsArray).
+ without(StreamTestScenario.CLEAR_SIZED_SCENARIOS).
+ exercise();
+ }
+
+ public void testFlagsParallelCollect() {
+ testFlagsSetSequence(CollectorOps::collector);
+ }
+
+ private void testFlagsSetSequence(Supplier<StatefulTestOp<Integer>> cf) {
+ EnumSet<StreamOpFlag> known = EnumSet.of(StreamOpFlag.ORDERED, StreamOpFlag.SIZED);
+ EnumSet<StreamOpFlag> preserve = EnumSet.of(StreamOpFlag.DISTINCT, StreamOpFlag.SORTED);
+
+ List<IntermediateTestOp<Integer, Integer>> ops = new ArrayList<>();
+ for (StreamOpFlag f : EnumSet.of(StreamOpFlag.DISTINCT, StreamOpFlag.SORTED)) {
+ ops.add(cf.get());
+ ops.add(new TestFlagExpectedOp<>(f.set(),
+ known.clone(),
+ preserve.clone(),
+ EnumSet.noneOf(StreamOpFlag.class)));
+ known.add(f);
+ preserve.remove(f);
+ }
+ ops.add(cf.get());
+ ops.add(new TestFlagExpectedOp<>(0,
+ known.clone(),
+ preserve.clone(),
+ EnumSet.noneOf(StreamOpFlag.class)));
+
+ TestData<Integer, Stream<Integer>> data = TestData.Factory.ofArray("Array", countTo(10).toArray(new Integer[0]));
+ @SuppressWarnings("rawtypes")
+ IntermediateTestOp[] opsArray = ops.toArray(new IntermediateTestOp[ops.size()]);
+
+ withData(data).ops(opsArray).
+ without(StreamTestScenario.CLEAR_SIZED_SCENARIOS).
+ exercise();
+ }
+
+
+ public void testFlagsClearParallelCollect() {
+ testFlagsClearSequence(CollectorOps::collector);
+ }
+
+ protected void testFlagsClearSequence(Supplier<StatefulTestOp<Integer>> cf) {
+ EnumSet<StreamOpFlag> known = EnumSet.of(StreamOpFlag.ORDERED, StreamOpFlag.SIZED);
+ EnumSet<StreamOpFlag> preserve = EnumSet.of(StreamOpFlag.DISTINCT, StreamOpFlag.SORTED);
+ EnumSet<StreamOpFlag> notKnown = EnumSet.noneOf(StreamOpFlag.class);
+
+ List<IntermediateTestOp<Integer, Integer>> ops = new ArrayList<>();
+ for (StreamOpFlag f : EnumSet.of(StreamOpFlag.ORDERED, StreamOpFlag.DISTINCT, StreamOpFlag.SORTED)) {
+ ops.add(cf.get());
+ ops.add(new TestFlagExpectedOp<>(f.clear(),
+ known.clone(),
+ preserve.clone(),
+ notKnown.clone()));
+ known.remove(f);
+ preserve.remove(f);
+ notKnown.add(f);
+ }
+ ops.add(cf.get());
+ ops.add(new TestFlagExpectedOp<>(0,
+ known.clone(),
+ preserve.clone(),
+ notKnown.clone()));
+
+ TestData<Integer, Stream<Integer>> data = TestData.Factory.ofArray("Array", countTo(10).toArray(new Integer[0]));
+ @SuppressWarnings("rawtypes")
+ IntermediateTestOp[] opsArray = ops.toArray(new IntermediateTestOp[ops.size()]);
+
+ withData(data).ops(opsArray).
+ without(StreamTestScenario.CLEAR_SIZED_SCENARIOS).
+ exercise();
+ }
+
+ public void testFlagsSizedOrderedParallelCollect() {
+ EnumSet<StreamOpFlag> parKnown = EnumSet.of(StreamOpFlag.SIZED);
+ EnumSet<StreamOpFlag> serKnown = parKnown.clone();
+
+ List<IntermediateTestOp<Integer, Integer>> ops = new ArrayList<>();
+ for (StreamOpFlag f : parKnown) {
+ ops.add(CollectorOps.collector());
+ ops.add(new ParSerTestFlagExpectedOp<>(f.clear(),
+ parKnown,
+ serKnown));
+ serKnown.remove(f);
+ }
+ ops.add(CollectorOps.collector());
+ ops.add(new ParSerTestFlagExpectedOp<>(0,
+ parKnown,
+ EnumSet.noneOf(StreamOpFlag.class)));
+
+ TestData<Integer, Stream<Integer>> data = TestData.Factory.ofArray("Array", countTo(10).toArray(new Integer[0]));
+ @SuppressWarnings("rawtypes")
+ IntermediateTestOp[] opsArray = ops.toArray(new IntermediateTestOp[ops.size()]);
+
+ withData(data).ops(opsArray).exercise();
+ }
+
+ static class ParSerTestFlagExpectedOp<T> extends FlagDeclaringOp<T> {
+ final EnumSet<StreamOpFlag> parKnown;
+ final EnumSet<StreamOpFlag> serKnown;
+
+ ParSerTestFlagExpectedOp(int flags, EnumSet<StreamOpFlag> known, EnumSet<StreamOpFlag> serKnown) {
+ super(flags);
+ this.parKnown = known;
+ this.serKnown = serKnown;
+ }
+
+ @Override
+ @SuppressWarnings({"unchecked", "rawtypes"})
+ public Sink<T> opWrapSink(int flags, boolean parallel, Sink upstream) {
+ assertFlags(flags, parallel);
+ return upstream;
+ }
+
+ protected void assertFlags(int flags, boolean parallel) {
+ if (parallel) {
+ for (StreamOpFlag f : parKnown) {
+ Assert.assertTrue(f.isKnown(flags), String.format("Flag %s is not known, but should be known.", f.toString()));
+ }
+
+ } else {
+ for (StreamOpFlag f : serKnown) {
+ Assert.assertTrue(f.isKnown(flags), String.format("Flag %s is not known, but should be known.", f.toString()));
+ }
+
+ }
+ }
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/boottest/java/util/stream/IntNodeTest.java b/ojluni/src/test/java/util/stream/boottest/java/util/stream/IntNodeTest.java
new file mode 100644
index 0000000..e050e63d
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/boottest/java/util/stream/IntNodeTest.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.util.stream;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.PrimitiveIterator;
+import java.util.Spliterators;
+import java.util.function.Function;
+
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+@Test
+public class IntNodeTest extends OpTestCase {
+
+ @DataProvider(name = "nodes")
+ public Object[][] createSizes() {
+ List<Object[]> params = new ArrayList<>();
+
+ for (int size : Arrays.asList(0, 1, 4, 15, 16, 17, 127, 128, 129, 1000)) {
+ int[] array = new int[size];
+ for (int i = 0; i < array.length; i++) {
+ array[i] = i;
+ }
+
+ List<Node<Integer>> nodes = new ArrayList<>();
+
+ nodes.add(Nodes.node(array));
+ nodes.add(degenerateTree(Spliterators.iterator(Arrays.spliterator(array))));
+ nodes.add(tree(toList(array), l -> Nodes.node(toIntArray(l))));
+ nodes.add(fill(array, Nodes.intBuilder(array.length)));
+ nodes.add(fill(array, Nodes.intBuilder()));
+
+ for (Node<Integer> node : nodes) {
+ params.add(new Object[]{array, node});
+ }
+
+ }
+
+ return params.toArray(new Object[0][]);
+ }
+
+ private static void assertEqualsListIntArray(List<Integer> list, int[] array) {
+ assertEquals(list.size(), array.length);
+ for (int i = 0; i < array.length; i++)
+ assertEquals(array[i], (int) list.get(i));
+ }
+
+ private List<Integer> toList(int[] a) {
+ List<Integer> l = new ArrayList<>();
+ for (int i : a) {
+ l.add(i);
+ }
+
+ return l;
+ }
+
+ private int[] toIntArray(List<Integer> l) {
+ int[] a = new int[l.size()];
+
+ int i = 0;
+ for (Integer e : l) {
+ a[i++] = e;
+ }
+ return a;
+ }
+
+ private Node.OfInt fill(int[] array, Node.Builder.OfInt nb) {
+ nb.begin(array.length);
+ for (int i : array)
+ nb.accept(i);
+ nb.end();
+ return nb.build();
+ }
+
+ private Node.OfInt degenerateTree(PrimitiveIterator.OfInt it) {
+ if (!it.hasNext()) {
+ return Nodes.node(new int[0]);
+ }
+
+ int i = it.nextInt();
+ if (it.hasNext()) {
+ return new Nodes.ConcNode.OfInt(Nodes.node(new int[] {i}), degenerateTree(it));
+ }
+ else {
+ return Nodes.node(new int[] {i});
+ }
+ }
+
+ private Node.OfInt tree(List<Integer> l, Function<List<Integer>, Node.OfInt> m) {
+ if (l.size() < 3) {
+ return m.apply(l);
+ }
+ else {
+ return new Nodes.ConcNode.OfInt(
+ tree(l.subList(0, l.size() / 2), m),
+ tree(l.subList(l.size() / 2, l.size()), m));
+ }
+ }
+
+ @Test(dataProvider = "nodes")
+ public void testAsArray(int[] array, Node.OfInt n) {
+ assertEquals(n.asPrimitiveArray(), array);
+ }
+
+ @Test(dataProvider = "nodes")
+ public void testFlattenAsArray(int[] array, Node.OfInt n) {
+ assertEquals(Nodes.flattenInt(n).asPrimitiveArray(), array);
+ }
+
+ @Test(dataProvider = "nodes")
+ public void testCopyTo(int[] array, Node.OfInt n) {
+ int[] copy = new int[(int) n.count()];
+ n.copyInto(copy, 0);
+
+ assertEquals(copy, array);
+ }
+
+ @Test(dataProvider = "nodes", groups = { "serialization-hostile" })
+ public void testForEach(int[] array, Node.OfInt n) {
+ List<Integer> l = new ArrayList<>((int) n.count());
+ n.forEach((int e) -> {
+ l.add(e);
+ });
+
+ assertEqualsListIntArray(l, array);
+ }
+
+ @Test(dataProvider = "nodes")
+ public void testStreams(int[] array, Node.OfInt n) {
+ TestData.OfInt data = TestData.Factory.ofNode("Node", n);
+
+ exerciseOps(data, s -> s);
+ exerciseTerminalOps(data, s -> s.toArray());
+ }
+
+ @Test(dataProvider = "nodes")
+ 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/ojluni/src/test/java/util/stream/boottest/java/util/stream/LongNodeTest.java b/ojluni/src/test/java/util/stream/boottest/java/util/stream/LongNodeTest.java
new file mode 100644
index 0000000..d266fd7
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/boottest/java/util/stream/LongNodeTest.java
@@ -0,0 +1,178 @@
+/*
+ * 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.Arrays;
+import java.util.List;
+import java.util.PrimitiveIterator;
+import java.util.Spliterators;
+import java.util.function.Function;
+
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+@Test
+public class LongNodeTest extends OpTestCase {
+
+ @DataProvider(name = "nodes")
+ public Object[][] createSizes() {
+ List<Object[]> params = new ArrayList<>();
+
+ for (int size : Arrays.asList(0, 1, 4, 15, 16, 17, 127, 128, 129, 1000)) {
+ long[] array = new long[size];
+ for (int i = 0; i < array.length; i++) {
+ array[i] = i;
+ }
+
+ List<Node<Long>> nodes = new ArrayList<>();
+
+ nodes.add(Nodes.node(array));
+ nodes.add(degenerateTree(Spliterators.iterator(Arrays.spliterator(array))));
+ nodes.add(tree(toList(array), l -> Nodes.node(toLongArray(l))));
+ nodes.add(fill(array, Nodes.longBuilder(array.length)));
+ nodes.add(fill(array, Nodes.longBuilder()));
+
+ for (Node<Long> node : nodes) {
+ params.add(new Object[]{array, node});
+ }
+
+ }
+
+ return params.toArray(new Object[0][]);
+ }
+
+ private static void assertEqualsListLongArray(List<Long> list, long[] array) {
+ assertEquals(list.size(), array.length);
+ for (int i = 0; i < array.length; i++)
+ assertEquals(array[i], (long) list.get(i));
+ }
+
+ private List<Long> toList(long[] a) {
+ List<Long> l = new ArrayList<>();
+ for (long i : a) {
+ l.add(i);
+ }
+
+ return l;
+ }
+
+ private long[] toLongArray(List<Long> l) {
+ long[] a = new long[l.size()];
+
+ int i = 0;
+ for (Long e : l) {
+ a[i++] = e;
+ }
+ return a;
+ }
+
+ private Node.OfLong fill(long[] array, Node.Builder.OfLong nb) {
+ nb.begin(array.length);
+ for (long i : array)
+ nb.accept(i);
+ nb.end();
+ return nb.build();
+ }
+
+ private Node.OfLong degenerateTree(PrimitiveIterator.OfLong it) {
+ if (!it.hasNext()) {
+ return Nodes.node(new long[0]);
+ }
+
+ long i = it.nextLong();
+ if (it.hasNext()) {
+ return new Nodes.ConcNode.OfLong(Nodes.node(new long[] {i}), degenerateTree(it));
+ }
+ else {
+ return Nodes.node(new long[] {i});
+ }
+ }
+
+ private Node.OfLong tree(List<Long> l, Function<List<Long>, Node.OfLong> m) {
+ if (l.size() < 3) {
+ return m.apply(l);
+ }
+ else {
+ return new Nodes.ConcNode.OfLong(
+ tree(l.subList(0, l.size() / 2), m),
+ tree(l.subList(l.size() / 2, l.size()), m));
+ }
+ }
+
+ @Test(dataProvider = "nodes")
+ public void testAsArray(long[] array, Node.OfLong n) {
+ assertEquals(n.asPrimitiveArray(), array);
+ }
+
+ @Test(dataProvider = "nodes")
+ public void testFlattenAsArray(long[] array, Node.OfLong n) {
+ assertEquals(Nodes.flattenLong(n).asPrimitiveArray(), array);
+ }
+
+ @Test(dataProvider = "nodes")
+ public void testCopyTo(long[] array, Node.OfLong n) {
+ long[] copy = new long[(int) n.count()];
+ n.copyInto(copy, 0);
+
+ assertEquals(copy, array);
+ }
+
+ @Test(dataProvider = "nodes", groups = { "serialization-hostile" })
+ public void testForEach(long[] array, Node.OfLong n) {
+ List<Long> l = new ArrayList<>((int) n.count());
+ n.forEach((long e) -> {
+ l.add(e);
+ });
+
+ assertEqualsListLongArray(l, array);
+ }
+
+ @Test(dataProvider = "nodes")
+ public void testStreams(long[] array, Node.OfLong n) {
+ TestData.OfLong data = TestData.Factory.ofNode("Node", n);
+
+ exerciseOps(data, s -> s);
+
+ exerciseTerminalOps(data, s -> s.toArray());
+ }
+
+ @Test(dataProvider = "nodes")
+ 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/ojluni/src/test/java/util/stream/boottest/java/util/stream/NodeBuilderTest.java b/ojluni/src/test/java/util/stream/boottest/java/util/stream/NodeBuilderTest.java
new file mode 100644
index 0000000..11fe86f
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/boottest/java/util/stream/NodeBuilderTest.java
@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.util.stream;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.DoubleConsumer;
+import java.util.function.Function;
+import java.util.function.IntConsumer;
+import java.util.function.LongConsumer;
+
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import static java.util.stream.LambdaTestHelpers.assertContents;
+import static java.util.stream.LambdaTestHelpers.countTo;
+import static org.testng.Assert.assertEquals;
+
+@Test
+public class NodeBuilderTest {
+
+ List<Integer> sizes = Arrays.asList(0, 1, 4, 16, 256,
+ 1023, 1024, 1025,
+ 2047, 2048, 2049,
+ 1024 * 32 - 1, 1024 * 32, 1024 * 32 + 1);
+
+ @DataProvider(name = "Node.Builder")
+ public Object[][] createNodeBuilders() {
+ List<List<Integer>> ls = new ArrayList<>();
+ for (int size : sizes) {
+ ls.add(countTo(size));
+ }
+
+ List<Function<Integer, Node.Builder<Integer>>> ms = Arrays.asList(
+ s -> Nodes.builder(),
+ s -> Nodes.builder(s, LambdaTestHelpers.integerArrayGenerator)
+ );
+
+ Object[][] params = new Object[ls.size() * ms.size()][];
+ int i = 0;
+ for (List<Integer> l : ls) {
+ for (Function<Integer, Node.Builder<Integer>> m : ms) {
+ params[i++] = new Object[]{l, m};
+ }
+ }
+
+ return params;
+ }
+
+ @Test(dataProvider = "Node.Builder", groups = { "serialization-hostile" })
+ public void testIteration(List<Integer> l, Function<Integer, Node.Builder<Integer>> m) {
+ Node.Builder<Integer> nb = m.apply(l.size());
+ nb.begin(l.size());
+ for (Integer i : l) {
+ nb.accept(i);
+ }
+ nb.end();
+
+ Node<Integer> n = nb.build();
+ assertEquals(n.count(), l.size());
+
+ {
+ List<Integer> _l = new ArrayList<>();
+ n.forEach(_l::add);
+
+ assertContents(_l, l);
+ }
+ }
+
+ // Node.Builder.OfInt
+
+ @DataProvider(name = "Node.Builder<Integer>")
+ public Object[][] createIntNodeBuilders() {
+ List<List<Integer>> ls = new ArrayList<>();
+ for (int size : sizes) {
+ ls.add(countTo(size));
+ }
+
+ List<Function<Integer, Node.Builder<Integer>>> ms = Arrays.asList(
+ s -> Nodes.intBuilder(),
+ s -> Nodes.intBuilder(s)
+ );
+
+ Object[][] params = new Object[ls.size() * ms.size()][];
+ int i = 0;
+ for (List<Integer> l : ls) {
+ for (Function<Integer, Node.Builder<Integer>> m : ms) {
+ params[i++] = new Object[]{l, m};
+ }
+ }
+
+ return params;
+ }
+
+ @Test(dataProvider = "Node.Builder<Integer>", groups = { "serialization-hostile" })
+ public void testIntIteration(List<Integer> l, Function<Integer, Node.Builder.OfInt> m) {
+ Node.Builder.OfInt nb = m.apply(l.size());
+ nb.begin(l.size());
+ for (Integer i : l) {
+ nb.accept((int) i);
+ }
+ nb.end();
+
+ Node.OfInt n = nb.build();
+ assertEquals(n.count(), l.size());
+
+ {
+ List<Integer> _l = new ArrayList<>();
+ n.forEach((IntConsumer) _l::add);
+
+ assertContents(_l, l);
+ }
+
+ }
+
+ // Node.Builder.OfLong
+
+ @DataProvider(name = "Node.Builder<Long>")
+ public Object[][] createLongNodeBuilders() {
+ List<List<Long>> ls = new ArrayList<>();
+ for (int size : sizes) {
+ List<Long> l = new ArrayList<>();
+ for (long i = 0; i < size; i++) {
+ l.add(i);
+ }
+ ls.add(l);
+ }
+
+ List<Function<Integer, Node.Builder<Long>>> ms = Arrays.asList(
+ s -> Nodes.longBuilder(),
+ s -> Nodes.longBuilder(s)
+ );
+
+ Object[][] params = new Object[ls.size() * ms.size()][];
+ int i = 0;
+ for (List<Long> l : ls) {
+ for (Function<Integer, Node.Builder<Long>> m : ms) {
+ params[i++] = new Object[]{l, m};
+ }
+ }
+
+ return params;
+ }
+
+ @Test(dataProvider = "Node.Builder<Long>")
+ public void testLongIteration(List<Long> l, Function<Integer, Node.Builder.OfLong> m) {
+ Node.Builder.OfLong nb = m.apply(l.size());
+ nb.begin(l.size());
+ for (Long i : l) {
+ nb.accept((long) i);
+ }
+ nb.end();
+
+ Node.OfLong n = nb.build();
+ assertEquals(n.count(), l.size());
+
+ {
+ List<Long> _l = new ArrayList<>();
+ n.forEach((LongConsumer) _l::add);
+
+ assertContents(_l, l);
+ }
+
+ }
+
+ // Node.Builder.OfDouble
+
+ @DataProvider(name = "Node.Builder<Double>")
+ public Object[][] createDoubleNodeBuilders() {
+ List<List<Double>> ls = new ArrayList<>();
+ for (int size : sizes) {
+ List<Double> l = new ArrayList<>();
+ for (long i = 0; i < size; i++) {
+ l.add((double) i);
+ }
+ ls.add(l);
+ }
+
+ List<Function<Integer, Node.Builder<Double>>> ms = Arrays.asList(
+ s -> Nodes.doubleBuilder(),
+ s -> Nodes.doubleBuilder(s)
+ );
+
+ Object[][] params = new Object[ls.size() * ms.size()][];
+ int i = 0;
+ for (List<Double> l : ls) {
+ for (Function<Integer, Node.Builder<Double>> m : ms) {
+ params[i++] = new Object[]{l, m};
+ }
+ }
+
+ return params;
+ }
+
+ @Test(dataProvider = "Node.Builder<Double>")
+ public void testDoubleIteration(List<Double> l, Function<Integer, Node.Builder.OfDouble> m) {
+ Node.Builder.OfDouble nb = m.apply(l.size());
+ nb.begin(l.size());
+ for (Double i : l) {
+ nb.accept((double) i);
+ }
+ nb.end();
+
+ Node.OfDouble n = nb.build();
+ assertEquals(n.count(), l.size());
+
+ {
+ List<Double> _l = new ArrayList<>();
+ n.forEach((DoubleConsumer) _l::add);
+
+ assertContents(_l, l);
+ }
+
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/boottest/java/util/stream/NodeTest.java b/ojluni/src/test/java/util/stream/boottest/java/util/stream/NodeTest.java
new file mode 100644
index 0000000..da71003
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/boottest/java/util/stream/NodeTest.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.util.stream;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Function;
+
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+@Test
+public class NodeTest extends OpTestCase {
+
+ @DataProvider(name = "nodes")
+ public Object[][] createSizes() {
+ List<Object[]> params = new ArrayList<>();
+
+ for (int size : Arrays.asList(0, 1, 4, 15, 16, 17, 127, 128, 129, 1000)) {
+ Integer[] array = new Integer[size];
+ for (int i = 0; i < array.length; i++) {
+ array[i] = i;
+ }
+
+ List<Node<Integer>> nodes = new ArrayList<>();
+ nodes.add(Nodes.node(array));
+ nodes.add(Nodes.node(Arrays.asList(array)));
+ nodes.add(degenerateTree(Arrays.asList(array).iterator()));
+ nodes.add(tree(Arrays.asList(array), l -> Nodes.node(l.toArray(new Integer[l.size()]))));
+ nodes.add(tree(Arrays.asList(array), l -> Nodes.node(l)));
+ nodes.add(fill(array, Nodes.builder(array.length, LambdaTestHelpers.integerArrayGenerator)));
+ nodes.add(fill(array, Nodes.builder()));
+
+ for (int i = 0; i < nodes.size(); i++) {
+ params.add(new Object[]{array, nodes.get(i)});
+ }
+
+ }
+
+ return params.toArray(new Object[0][]);
+ }
+
+ Node<Integer> fill(Integer[] array, Node.Builder<Integer> nb) {
+ nb.begin(array.length);
+ for (Integer i : array) {
+ nb.accept(i);
+ }
+ nb.end();
+ return nb.build();
+ }
+
+ Node<Integer> degenerateTree(Iterator<Integer> it) {
+ if (!it.hasNext()) {
+ return Nodes.node(Collections.emptyList());
+ }
+
+ Integer i = it.next();
+ if (it.hasNext()) {
+ return new Nodes.ConcNode<Integer>(Nodes.node(new Integer[] {i}), degenerateTree(it));
+ }
+ else {
+ return Nodes.node(new Integer[]{i});
+ }
+ }
+
+ Node<Integer> tree(List<Integer> l, Function<List<Integer>, Node<Integer>> m) {
+ if (l.size() < 3) {
+ return m.apply(l);
+ }
+ else {
+ return new Nodes.ConcNode<>(
+ tree(l.subList(0, l.size() / 2), m),
+ tree(l.subList(l.size() / 2, l.size()), m ));
+ }
+ }
+
+ @Test(dataProvider = "nodes")
+ public void testAsArray(Integer[] array, Node<Integer> n) {
+ assertEquals(n.asArray(LambdaTestHelpers.integerArrayGenerator), array);
+ }
+
+ @Test(dataProvider = "nodes")
+ public void testFlattenAsArray(Integer[] array, Node<Integer> n) {
+ assertEquals(Nodes.flatten(n, LambdaTestHelpers.integerArrayGenerator)
+ .asArray(LambdaTestHelpers.integerArrayGenerator), array);
+ }
+
+ @Test(dataProvider = "nodes")
+ public void testCopyTo(Integer[] array, Node<Integer> n) {
+ Integer[] copy = new Integer[(int) n.count()];
+ n.copyInto(copy, 0);
+
+ assertEquals(copy, array);
+ }
+
+ @Test(dataProvider = "nodes", groups = { "serialization-hostile" })
+ public void testForEach(Integer[] array, Node<Integer> n) {
+ List<Integer> l = new ArrayList<>((int) n.count());
+ n.forEach(e -> l.add(e));
+
+ assertEquals(l.toArray(), array);
+ }
+
+ @Test(dataProvider = "nodes")
+ public void testStreams(Integer[] array, Node<Integer> n) {
+ TestData<Integer, Stream<Integer>> data = TestData.Factory.ofRefNode("Node", n);
+
+ exerciseOps(data, s -> s);
+
+ exerciseTerminalOps(data, s -> s.toArray());
+ }
+
+ @Test(dataProvider = "nodes")
+ public void testSpliterator(Integer[] array, Node<Integer> n) {
+ SpliteratorTestHelper.testSpliterator(n::spliterator);
+ }
+
+ @Test(dataProvider = "nodes")
+ public void testTruncate(Integer[] array, Node<Integer> 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<Integer> 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/ojluni/src/test/java/util/stream/boottest/java/util/stream/SliceSpliteratorTest.java b/ojluni/src/test/java/util/stream/boottest/java/util/stream/SliceSpliteratorTest.java
new file mode 100644
index 0000000..7aa27bf
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/boottest/java/util/stream/SliceSpliteratorTest.java
@@ -0,0 +1,201 @@
+/*
+ * 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 org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Spliterator;
+
+import static java.util.stream.Collectors.toList;
+import static org.testng.Assert.assertEquals;
+
+/**
+ * @bug 8012987
+ */
+@Test
+public class SliceSpliteratorTest extends LoggingTestCase {
+
+ static class UnorderedContentAsserter<T> implements SpliteratorTestHelper.ContentAsserter<T> {
+ Collection<T> source;
+
+ UnorderedContentAsserter(Collection<T> source) {
+ this.source = source;
+ }
+
+ @Override
+ public void assertContents(Collection<T> actual, Collection<T> expected, boolean isOrdered) {
+ if (isOrdered) {
+ assertEquals(actual, expected);
+ }
+ else {
+ assertEquals(actual.size(), expected.size());
+ assertTrue(source.containsAll(actual));
+ }
+ }
+ }
+
+ interface SliceTester {
+ void test(int size, int skip, int limit);
+ }
+
+ @DataProvider(name = "sliceSpliteratorDataProvider")
+ public static Object[][] sliceSpliteratorDataProvider() {
+ List<Object[]> data = new ArrayList<>();
+
+ // SIZED/SUBSIZED slice spliterator
+
+ {
+ SliceTester r = (size, skip, limit) -> {
+ final Collection<Integer> source = IntStream.range(0, size).boxed().collect(toList());
+
+ SpliteratorTestHelper.testSpliterator(() -> {
+ Spliterator<Integer> s = Arrays.spliterator(source.stream().toArray(Integer[]::new));
+
+ return new StreamSpliterators.SliceSpliterator.OfRef<>(s, skip, limit);
+ });
+ };
+ data.add(new Object[]{"StreamSpliterators.SliceSpliterator.OfRef", r});
+ }
+
+ {
+ SliceTester r = (size, skip, limit) -> {
+ final Collection<Integer> source = IntStream.range(0, size).boxed().collect(toList());
+
+ SpliteratorTestHelper.testIntSpliterator(() -> {
+ Spliterator.OfInt s = Arrays.spliterator(source.stream().mapToInt(i->i).toArray());
+
+ return new StreamSpliterators.SliceSpliterator.OfInt(s, skip, limit);
+ });
+ };
+ data.add(new Object[]{"StreamSpliterators.SliceSpliterator.OfInt", r});
+ }
+
+ {
+ SliceTester r = (size, skip, limit) -> {
+ final Collection<Long> source = LongStream.range(0, size).boxed().collect(toList());
+
+ SpliteratorTestHelper.testLongSpliterator(() -> {
+ Spliterator.OfLong s = Arrays.spliterator(source.stream().mapToLong(i->i).toArray());
+
+ return new StreamSpliterators.SliceSpliterator.OfLong(s, skip, limit);
+ });
+ };
+ data.add(new Object[]{"StreamSpliterators.SliceSpliterator.OfLong", r});
+ }
+
+ {
+ SliceTester r = (size, skip, limit) -> {
+ final Collection<Double> source = LongStream.range(0, size).asDoubleStream().boxed().collect(toList());
+
+ SpliteratorTestHelper.testDoubleSpliterator(() -> {
+ Spliterator.OfDouble s = Arrays.spliterator(source.stream().mapToDouble(i->i).toArray());
+
+ return new StreamSpliterators.SliceSpliterator.OfDouble(s, skip, limit);
+ });
+ };
+ data.add(new Object[]{"StreamSpliterators.SliceSpliterator.OfLong", r});
+ }
+
+
+ // Unordered slice spliterator
+
+ {
+ SliceTester r = (size, skip, limit) -> {
+ final Collection<Integer> source = IntStream.range(0, size).boxed().collect(toList());
+ final UnorderedContentAsserter<Integer> uca = new UnorderedContentAsserter<>(source);
+
+ SpliteratorTestHelper.testSpliterator(() -> {
+ Spliterator<Integer> s = Arrays.spliterator(source.stream().toArray(Integer[]::new));
+
+ return new StreamSpliterators.UnorderedSliceSpliterator.OfRef<>(s, skip, limit);
+ }, uca);
+ };
+ data.add(new Object[]{"StreamSpliterators.UnorderedSliceSpliterator.OfRef", r});
+ }
+
+ {
+ SliceTester r = (size, skip, limit) -> {
+ final Collection<Integer> source = IntStream.range(0, size).boxed().collect(toList());
+ final UnorderedContentAsserter<Integer> uca = new UnorderedContentAsserter<>(source);
+
+ SpliteratorTestHelper.testIntSpliterator(() -> {
+ Spliterator.OfInt s = Arrays.spliterator(source.stream().mapToInt(i->i).toArray());
+
+ return new StreamSpliterators.UnorderedSliceSpliterator.OfInt(s, skip, limit);
+ }, uca);
+ };
+ data.add(new Object[]{"StreamSpliterators.UnorderedSliceSpliterator.OfInt", r});
+ }
+
+ {
+ SliceTester r = (size, skip, limit) -> {
+ final Collection<Long> source = LongStream.range(0, size).boxed().collect(toList());
+ final UnorderedContentAsserter<Long> uca = new UnorderedContentAsserter<>(source);
+
+ SpliteratorTestHelper.testLongSpliterator(() -> {
+ Spliterator.OfLong s = Arrays.spliterator(source.stream().mapToLong(i->i).toArray());
+
+ return new StreamSpliterators.UnorderedSliceSpliterator.OfLong(s, skip, limit);
+ }, uca);
+ };
+ data.add(new Object[]{"StreamSpliterators.UnorderedSliceSpliterator.OfLong", r});
+ }
+
+ {
+ SliceTester r = (size, skip, limit) -> {
+ final Collection<Double> source = LongStream.range(0, size).asDoubleStream().boxed().collect(toList());
+ final UnorderedContentAsserter<Double> uca = new UnorderedContentAsserter<>(source);
+
+ SpliteratorTestHelper.testDoubleSpliterator(() -> {
+ Spliterator.OfDouble s = Arrays.spliterator(LongStream.range(0, SIZE).asDoubleStream().toArray());
+
+ return new StreamSpliterators.UnorderedSliceSpliterator.OfDouble(s, skip, limit);
+ }, uca);
+ };
+ data.add(new Object[]{"StreamSpliterators.UnorderedSliceSpliterator.OfLong", r});
+ }
+
+ return data.toArray(new Object[0][]);
+ }
+
+ static final int SIZE = 256;
+
+ static final int STEP = 32;
+
+ @Test(dataProvider = "sliceSpliteratorDataProvider")
+ public void testSliceSpliterator(String description, SliceTester r) {
+ setContext("size", SIZE);
+ for (int skip = 0; skip < SIZE; skip += STEP) {
+ setContext("skip", skip);
+ for (int limit = 0; limit < SIZE; limit += STEP) {
+ setContext("limit", skip);
+ r.test(SIZE, skip, limit);
+ }
+ }
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java b/ojluni/src/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java
new file mode 100644
index 0000000..26a62ca
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java
@@ -0,0 +1,370 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.util.stream;
+
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.util.*;
+import java.util.function.DoubleConsumer;
+import java.util.function.IntConsumer;
+import java.util.function.LongConsumer;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertFalse;
+
+@Test
+public class SpinedBufferTest {
+
+ // Create sizes around the boundary of spines
+ static List<Integer> sizes;
+ static {
+ try {
+ sizes = IntStream.range(0, 15)
+ .map(i -> 1 << i)
+ .flatMap(i -> Arrays.stream(new int[] { i-2, i-1, i, i+1, i+2 }))
+ .filter(i -> i >= 0)
+ .boxed()
+ .distinct()
+ .collect(Collectors.toList());
+ }
+ catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ private static final int TEST_SIZE = 5000;
+
+ // SpinedBuffer
+
+ @DataProvider(name = "SpinedBuffer")
+ public Object[][] createSpinedBuffer() {
+ List<Object[]> params = new ArrayList<>();
+
+ for (int size : sizes) {
+ int[] array = IntStream.range(0, size).toArray();
+
+ SpinedBuffer<Integer> sb = new SpinedBuffer<>();
+ Arrays.stream(array).boxed().forEach(sb);
+ params.add(new Object[]{array, sb});
+
+ sb = new SpinedBuffer<>(size / 2);
+ Arrays.stream(array).boxed().forEach(sb);
+ params.add(new Object[]{array, sb});
+
+ sb = new SpinedBuffer<>(size);
+ Arrays.stream(array).boxed().forEach(sb);
+ params.add(new Object[]{array, sb});
+
+ sb = new SpinedBuffer<>(size * 2);
+ Arrays.stream(array).boxed().forEach(sb);
+ params.add(new Object[]{array, sb});
+ }
+
+ return params.toArray(new Object[0][]);
+ }
+
+ @Test(dataProvider = "SpinedBuffer")
+ public void testSpliterator(int[] array, SpinedBuffer<Integer> sb) {
+ assertEquals(sb.count(), array.length);
+ assertEquals(sb.count(), sb.spliterator().getExactSizeIfKnown());
+
+ SpliteratorTestHelper.testSpliterator(sb::spliterator);
+ }
+
+ @Test(dataProvider = "SpinedBuffer", groups = { "serialization-hostile" })
+ public void testLastSplit(int[] array, SpinedBuffer<Integer> sb) {
+ Spliterator<Integer> spliterator = sb.spliterator();
+ Spliterator<Integer> split = spliterator.trySplit();
+ long splitSizes = (split == null) ? 0 : split.getExactSizeIfKnown();
+ long lastSplitSize = spliterator.getExactSizeIfKnown();
+ splitSizes += lastSplitSize;
+
+ assertEquals(splitSizes, array.length);
+
+ List<Integer> contentOfLastSplit = new ArrayList<>();
+ spliterator.forEachRemaining(contentOfLastSplit::add);
+
+ assertEquals(contentOfLastSplit.size(), lastSplitSize);
+
+ List<Integer> end = Arrays.stream(array)
+ .boxed()
+ .skip(array.length - lastSplitSize)
+ .collect(Collectors.toList());
+ assertEquals(contentOfLastSplit, end);
+ }
+
+ @Test(groups = { "serialization-hostile" })
+ public void testSpinedBuffer() {
+ List<Integer> list1 = new ArrayList<>();
+ List<Integer> list2 = new ArrayList<>();
+ SpinedBuffer<Integer> sb = new SpinedBuffer<>();
+ for (int i = 0; i < TEST_SIZE; i++) {
+ list1.add(i);
+ sb.accept(i);
+ }
+ Iterator<Integer> it = sb.iterator();
+ for (int i = 0; i < TEST_SIZE; i++)
+ list2.add(it.next());
+ assertFalse(it.hasNext());
+ assertEquals(list1, list2);
+
+ for (int i = 0; i < TEST_SIZE; i++)
+ assertEquals(sb.get(i), (Integer) i, Integer.toString(i));
+
+ list2.clear();
+ sb.forEach(list2::add);
+ assertEquals(list1, list2);
+ Integer[] array = sb.asArray(LambdaTestHelpers.integerArrayGenerator);
+ list2.clear();
+ for (Integer i : array)
+ list2.add(i);
+ assertEquals(list1, list2);
+ }
+
+ // IntSpinedBuffer
+
+ @DataProvider(name = "IntSpinedBuffer")
+ public Object[][] createIntSpinedBuffer() {
+ List<Object[]> params = new ArrayList<>();
+
+ for (int size : sizes) {
+ int[] array = IntStream.range(0, size).toArray();
+ SpinedBuffer.OfInt sb = new SpinedBuffer.OfInt();
+ Arrays.stream(array).forEach(sb);
+
+ params.add(new Object[]{array, sb});
+ }
+
+ return params.toArray(new Object[0][]);
+ }
+
+ @Test(dataProvider = "IntSpinedBuffer")
+ public void testIntSpliterator(int[] array, SpinedBuffer.OfInt sb) {
+ assertEquals(sb.count(), array.length);
+ assertEquals(sb.count(), sb.spliterator().getExactSizeIfKnown());
+
+ SpliteratorTestHelper.testIntSpliterator(sb::spliterator);
+ }
+
+ @Test(dataProvider = "IntSpinedBuffer", groups = { "serialization-hostile" })
+ public void testIntLastSplit(int[] array, SpinedBuffer.OfInt sb) {
+ Spliterator.OfInt spliterator = sb.spliterator();
+ Spliterator.OfInt split = spliterator.trySplit();
+ long splitSizes = (split == null) ? 0 : split.getExactSizeIfKnown();
+ long lastSplitSize = spliterator.getExactSizeIfKnown();
+ splitSizes += lastSplitSize;
+
+ assertEquals(splitSizes, array.length);
+
+ List<Integer> contentOfLastSplit = new ArrayList<>();
+ spliterator.forEachRemaining((IntConsumer) contentOfLastSplit::add);
+
+ assertEquals(contentOfLastSplit.size(), lastSplitSize);
+
+ List<Integer> end = Arrays.stream(array)
+ .boxed()
+ .skip(array.length - lastSplitSize)
+ .collect(Collectors.toList());
+ assertEquals(contentOfLastSplit, end);
+ }
+
+ @Test(groups = { "serialization-hostile" })
+ public void testIntSpinedBuffer() {
+ List<Integer> list1 = new ArrayList<>();
+ List<Integer> list2 = new ArrayList<>();
+ SpinedBuffer.OfInt sb = new SpinedBuffer.OfInt();
+ for (int i = 0; i < TEST_SIZE; i++) {
+ list1.add(i);
+ sb.accept(i);
+ }
+ PrimitiveIterator.OfInt it = sb.iterator();
+ for (int i = 0; i < TEST_SIZE; i++)
+ list2.add(it.nextInt());
+ assertFalse(it.hasNext());
+ assertEquals(list1, list2);
+
+ for (int i = 0; i < TEST_SIZE; i++)
+ assertEquals(sb.get(i), i, Integer.toString(i));
+
+ list2.clear();
+ sb.forEach((int i) -> list2.add(i));
+ assertEquals(list1, list2);
+ int[] array = sb.asPrimitiveArray();
+ list2.clear();
+ for (int i : array)
+ list2.add(i);
+ assertEquals(list1, list2);
+ }
+
+ // LongSpinedBuffer
+
+ @DataProvider(name = "LongSpinedBuffer")
+ public Object[][] createLongSpinedBuffer() {
+ List<Object[]> params = new ArrayList<>();
+
+ for (int size : sizes) {
+ long[] array = LongStream.range(0, size).toArray();
+ SpinedBuffer.OfLong sb = new SpinedBuffer.OfLong();
+ Arrays.stream(array).forEach(sb);
+
+ params.add(new Object[]{array, sb});
+ }
+
+ return params.toArray(new Object[0][]);
+ }
+
+ @Test(dataProvider = "LongSpinedBuffer")
+ public void testLongSpliterator(long[] array, SpinedBuffer.OfLong sb) {
+ assertEquals(sb.count(), array.length);
+ assertEquals(sb.count(), sb.spliterator().getExactSizeIfKnown());
+
+ SpliteratorTestHelper.testLongSpliterator(sb::spliterator);
+ }
+
+ @Test(dataProvider = "LongSpinedBuffer", groups = { "serialization-hostile" })
+ public void testLongLastSplit(long[] array, SpinedBuffer.OfLong sb) {
+ Spliterator.OfLong spliterator = sb.spliterator();
+ Spliterator.OfLong split = spliterator.trySplit();
+ long splitSizes = (split == null) ? 0 : split.getExactSizeIfKnown();
+ long lastSplitSize = spliterator.getExactSizeIfKnown();
+ splitSizes += lastSplitSize;
+
+ assertEquals(splitSizes, array.length);
+
+ List<Long> contentOfLastSplit = new ArrayList<>();
+ spliterator.forEachRemaining((LongConsumer) contentOfLastSplit::add);
+
+ assertEquals(contentOfLastSplit.size(), lastSplitSize);
+
+ List<Long> end = Arrays.stream(array)
+ .boxed()
+ .skip(array.length - lastSplitSize)
+ .collect(Collectors.toList());
+ assertEquals(contentOfLastSplit, end);
+ }
+
+ @Test(groups = { "serialization-hostile" })
+ public void testLongSpinedBuffer() {
+ List<Long> list1 = new ArrayList<>();
+ List<Long> list2 = new ArrayList<>();
+ SpinedBuffer.OfLong sb = new SpinedBuffer.OfLong();
+ for (long i = 0; i < TEST_SIZE; i++) {
+ list1.add(i);
+ sb.accept(i);
+ }
+ PrimitiveIterator.OfLong it = sb.iterator();
+ for (int i = 0; i < TEST_SIZE; i++)
+ list2.add(it.nextLong());
+ assertFalse(it.hasNext());
+ assertEquals(list1, list2);
+
+ for (int i = 0; i < TEST_SIZE; i++)
+ assertEquals(sb.get(i), i, Long.toString(i));
+
+ list2.clear();
+ sb.forEach((long i) -> list2.add(i));
+ assertEquals(list1, list2);
+ long[] array = sb.asPrimitiveArray();
+ list2.clear();
+ for (long i : array)
+ list2.add(i);
+ assertEquals(list1, list2);
+ }
+
+ // DoubleSpinedBuffer
+
+ @DataProvider(name = "DoubleSpinedBuffer")
+ public Object[][] createDoubleSpinedBuffer() {
+ List<Object[]> params = new ArrayList<>();
+
+ for (int size : sizes) {
+ // @@@ replace with double range when implemented
+ double[] array = LongStream.range(0, size).asDoubleStream().toArray();
+ SpinedBuffer.OfDouble sb = new SpinedBuffer.OfDouble();
+ Arrays.stream(array).forEach(sb);
+
+ params.add(new Object[]{array, sb});
+ }
+
+ return params.toArray(new Object[0][]);
+ }
+
+ @Test(dataProvider = "DoubleSpinedBuffer")
+ public void testDoubleSpliterator(double[] array, SpinedBuffer.OfDouble sb) {
+ assertEquals(sb.count(), array.length);
+ assertEquals(sb.count(), sb.spliterator().getExactSizeIfKnown());
+
+ SpliteratorTestHelper.testDoubleSpliterator(sb::spliterator);
+ }
+
+ @Test(dataProvider = "DoubleSpinedBuffer", groups = { "serialization-hostile" })
+ public void testLongLastSplit(double[] array, SpinedBuffer.OfDouble sb) {
+ Spliterator.OfDouble spliterator = sb.spliterator();
+ Spliterator.OfDouble split = spliterator.trySplit();
+ long splitSizes = (split == null) ? 0 : split.getExactSizeIfKnown();
+ long lastSplitSize = spliterator.getExactSizeIfKnown();
+ splitSizes += lastSplitSize;
+
+ assertEquals(splitSizes, array.length);
+
+ List<Double> contentOfLastSplit = new ArrayList<>();
+ spliterator.forEachRemaining((DoubleConsumer) contentOfLastSplit::add);
+
+ assertEquals(contentOfLastSplit.size(), lastSplitSize);
+
+ List<Double> end = Arrays.stream(array)
+ .boxed()
+ .skip(array.length - lastSplitSize)
+ .collect(Collectors.toList());
+ assertEquals(contentOfLastSplit, end);
+ }
+
+ @Test(groups = { "serialization-hostile" })
+ public void testDoubleSpinedBuffer() {
+ List<Double> list1 = new ArrayList<>();
+ List<Double> list2 = new ArrayList<>();
+ SpinedBuffer.OfDouble sb = new SpinedBuffer.OfDouble();
+ for (long i = 0; i < TEST_SIZE; i++) {
+ list1.add((double) i);
+ sb.accept((double) i);
+ }
+ PrimitiveIterator.OfDouble it = sb.iterator();
+ for (int i = 0; i < TEST_SIZE; i++)
+ list2.add(it.nextDouble());
+ assertFalse(it.hasNext());
+ assertEquals(list1, list2);
+
+ for (int i = 0; i < TEST_SIZE; i++)
+ assertEquals(sb.get(i), (double) i, Double.toString(i));
+
+ list2.clear();
+ sb.forEach((double i) -> list2.add(i));
+ assertEquals(list1, list2);
+ double[] array = sb.asPrimitiveArray();
+ list2.clear();
+ for (double i : array)
+ list2.add(i);
+ assertEquals(list1, list2);
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/boottest/java/util/stream/StreamFlagsTest.java b/ojluni/src/test/java/util/stream/boottest/java/util/stream/StreamFlagsTest.java
new file mode 100644
index 0000000..29243cf
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/boottest/java/util/stream/StreamFlagsTest.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.util.stream;
+
+import org.testng.annotations.Test;
+
+import java.util.*;
+import java.util.stream.Stream;
+import java.util.stream.StreamOpFlag;
+import java.util.stream.Streams;
+
+import static java.util.stream.StreamOpFlag.*;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertTrue;
+
+/**
+ * StreamFlagsTest
+ *
+ * @author Brian Goetz
+ */
+@Test
+public class StreamFlagsTest {
+ Stream<String> arrayList = new ArrayList<String>().stream();
+ Stream<String> linkedList = new LinkedList<String>().stream();
+ Stream<String> hashSet = new HashSet<String>().stream();
+ Stream<String> treeSet = new TreeSet<String>().stream();
+ Stream<String> linkedHashSet = new LinkedHashSet<String>().stream();
+ Stream<String> repeat = Stream.generate(() -> "");
+
+ Stream<?>[] streams = { arrayList, linkedList, hashSet, treeSet, linkedHashSet, repeat };
+
+ private void assertFlags(int value, EnumSet<StreamOpFlag> setFlags, EnumSet<StreamOpFlag> clearFlags) {
+ for (StreamOpFlag flag : setFlags)
+ assertTrue(flag.isKnown(value));
+ for (StreamOpFlag flag : clearFlags)
+ assertTrue(!flag.isKnown(value));
+ }
+
+ public void testBaseStreams() {
+ Stream<String> arrayList = new ArrayList<String>().stream();
+ Stream<String> linkedList = new LinkedList<String>().stream();
+ Stream<String> hashSet = new HashSet<String>().stream();
+ Stream<String> treeSet = new TreeSet<String>().stream();
+ Stream<String> linkedHashSet = new LinkedHashSet<String>().stream();
+ Stream<String> repeat = Stream.generate(() -> "");
+
+ assertFlags(OpTestCase.getStreamFlags(arrayList),
+ EnumSet.of(ORDERED, SIZED),
+ EnumSet.of(DISTINCT, SORTED, SHORT_CIRCUIT));
+ assertFlags(OpTestCase.getStreamFlags(linkedList),
+ EnumSet.of(ORDERED, SIZED),
+ EnumSet.of(DISTINCT, SORTED, SHORT_CIRCUIT));
+ assertFlags(OpTestCase.getStreamFlags(hashSet),
+ EnumSet.of(SIZED, DISTINCT),
+ EnumSet.of(ORDERED, SORTED, SHORT_CIRCUIT));
+ assertFlags(OpTestCase.getStreamFlags(treeSet),
+ EnumSet.of(ORDERED, SIZED, DISTINCT, SORTED),
+ EnumSet.of(SHORT_CIRCUIT));
+ assertFlags(OpTestCase.getStreamFlags(linkedHashSet),
+ EnumSet.of(ORDERED, DISTINCT, SIZED),
+ EnumSet.of(SORTED, SHORT_CIRCUIT));
+ assertFlags(OpTestCase.getStreamFlags(repeat),
+ EnumSet.noneOf(StreamOpFlag.class),
+ EnumSet.of(DISTINCT, SORTED, SHORT_CIRCUIT));
+ }
+
+ public void testFilter() {
+ for (Stream<?> s : streams) {
+ int baseFlags = OpTestCase.getStreamFlags(s);
+ int filteredFlags = OpTestCase.getStreamFlags(s.filter((Object e) -> true));
+ int expectedFlags = baseFlags & ~SIZED.set();
+
+ assertEquals(filteredFlags, expectedFlags);
+ }
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/boottest/java/util/stream/StreamOpFlagsTest.java b/ojluni/src/test/java/util/stream/boottest/java/util/stream/StreamOpFlagsTest.java
new file mode 100644
index 0000000..aa47aa2
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/boottest/java/util/stream/StreamOpFlagsTest.java
@@ -0,0 +1,381 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.util.stream;
+
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.ToDoubleFunction;
+import java.util.function.ToIntFunction;
+import java.util.function.ToLongFunction;
+
+import static java.util.stream.Collectors.toList;
+import static java.util.stream.StreamOpFlag.*;
+import static org.testng.Assert.*;
+import static org.testng.Assert.assertEquals;
+
+@Test
+public class StreamOpFlagsTest {
+
+ public void testNullCombine() {
+ int sourceFlags = StreamOpFlag.IS_SIZED;
+
+ assertEquals(sourceFlags, toStreamFlags(combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE)));
+ }
+
+ public void testInitialOpFlagsFromSourceFlags() {
+ List<StreamOpFlag> flags = new ArrayList<>(StreamOpFlagTestHelper.allStreamFlags());
+ for (int i = 0; i < (1 << flags.size()); i++) {
+ int sourceFlags = 0;
+ for (int f = 0; f < flags.size(); f++) {
+ if ((i & (1 << f)) != 0) {
+ sourceFlags |= flags.get(f).set();
+ }
+ }
+
+ int opsFlags = combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE);
+ assertEquals(opsFlags, (~(sourceFlags << 1)) & StreamOpFlag.INITIAL_OPS_VALUE);
+ }
+ }
+
+ public void testSameCombine() {
+ for (StreamOpFlag f : StreamOpFlagTestHelper.allStreamFlags()) {
+ int sourceFlags = f.set();
+ int opsFlags;
+
+ opsFlags = combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE);
+ opsFlags = combineOpFlags(f.set(), opsFlags);
+ assertEquals(sourceFlags, toStreamFlags(opsFlags));
+ }
+ }
+
+ public void testOpClear() {
+ for (StreamOpFlag f : StreamOpFlagTestHelper.allStreamFlags()) {
+ // Clear when source not set
+ int sourceFlags = 0;
+ int opsFlags;
+
+ opsFlags = combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE);
+ opsFlags = combineOpFlags(f.clear(), opsFlags);
+ assertEquals(sourceFlags, toStreamFlags(opsFlags));
+
+ // Clear when source set
+ sourceFlags = f.set();
+
+ opsFlags = combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE);
+ opsFlags = combineOpFlags(f.clear(), opsFlags);
+ assertEquals(0, toStreamFlags(opsFlags));
+ }
+ }
+
+ public void testOpInject() {
+ for (StreamOpFlag f : StreamOpFlagTestHelper.allStreamFlags()) {
+ // Set when source not set
+ int sourceFlags = 0;
+ int opsFlags;
+
+ opsFlags = combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE);
+ opsFlags = combineOpFlags(f.set(), opsFlags);
+ assertEquals(f.set(), toStreamFlags(opsFlags));
+
+ // Set when source set
+ sourceFlags = f.set();
+
+ opsFlags = combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE);
+ opsFlags = combineOpFlags(f.set(), opsFlags);
+ assertEquals(sourceFlags, toStreamFlags(opsFlags));
+ }
+ }
+
+ public void testPairSet() {
+ List<Integer> sourceFlagsList
+ = StreamOpFlagTestHelper.allStreamFlags().stream().map(StreamOpFlag::set).collect(toList());
+ sourceFlagsList.add(0, 0);
+
+ for (int sourceFlags : sourceFlagsList) {
+ for (StreamOpFlag f1 : StreamOpFlagTestHelper.allStreamFlags()) {
+ for (StreamOpFlag f2 : StreamOpFlagTestHelper.allStreamFlags()) {
+ int opsFlags;
+
+ opsFlags = combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE);
+ opsFlags = combineOpFlags(f1.set(), opsFlags);
+ opsFlags = combineOpFlags(f2.set(), opsFlags);
+ assertEquals(sourceFlags | f1.set() | f2.set(), toStreamFlags(opsFlags));
+ }
+ }
+ }
+ }
+
+ public void testPairSetAndClear() {
+ List<Integer> sourceFlagsList
+ = StreamOpFlagTestHelper.allStreamFlags().stream().map(StreamOpFlag::set).collect(toList());
+ sourceFlagsList.add(0, 0);
+
+ for (int sourceFlags : sourceFlagsList) {
+ for (StreamOpFlag f1 : StreamOpFlagTestHelper.allStreamFlags()) {
+ for (StreamOpFlag f2 : StreamOpFlagTestHelper.allStreamFlags()) {
+ int opsFlags;
+
+ opsFlags = combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE);
+ opsFlags = combineOpFlags(f1.set(), opsFlags);
+ opsFlags = combineOpFlags(f2.clear(), opsFlags);
+ if (f1 == f2)
+ assertEquals((f2.set() == sourceFlags) ? 0 : sourceFlags, toStreamFlags(opsFlags));
+ else
+ assertEquals((f2.set() == sourceFlags) ? f1.set() : sourceFlags | f1.set(), toStreamFlags(opsFlags));
+ }
+ }
+ }
+ }
+
+ public void testShortCircuit() {
+ int opsFlags = combineOpFlags(0, StreamOpFlag.INITIAL_OPS_VALUE);
+ assertFalse(StreamOpFlag.SHORT_CIRCUIT.isKnown(opsFlags));
+
+ opsFlags = combineOpFlags(StreamOpFlag.IS_SHORT_CIRCUIT, opsFlags);
+ assertTrue(StreamOpFlag.SHORT_CIRCUIT.isKnown(opsFlags));
+
+ opsFlags = combineOpFlags(0, opsFlags);
+ assertTrue(StreamOpFlag.SHORT_CIRCUIT.isKnown(opsFlags));
+ }
+
+ public void testApplySourceFlags() {
+ int sourceFlags = StreamOpFlag.IS_SIZED | StreamOpFlag.IS_DISTINCT;
+
+ List<Integer> ops = Arrays.asList(StreamOpFlag.NOT_SIZED, StreamOpFlag.IS_ORDERED | StreamOpFlag.IS_SORTED);
+
+ int opsFlags = StreamOpFlag.combineOpFlags(sourceFlags, StreamOpFlag.INITIAL_OPS_VALUE);
+ for (int opFlags : ops) {
+ opsFlags = combineOpFlags(opFlags, opsFlags);
+ }
+ assertFalse(StreamOpFlag.SIZED.isKnown(opsFlags));
+ assertTrue(StreamOpFlag.SIZED.isCleared(opsFlags));
+ assertFalse(StreamOpFlag.SIZED.isPreserved(opsFlags));
+ assertTrue(StreamOpFlag.DISTINCT.isKnown(opsFlags));
+ assertFalse(StreamOpFlag.DISTINCT.isCleared(opsFlags));
+ assertFalse(StreamOpFlag.DISTINCT.isPreserved(opsFlags));
+ assertTrue(StreamOpFlag.SORTED.isKnown(opsFlags));
+ assertFalse(StreamOpFlag.SORTED.isCleared(opsFlags));
+ assertFalse(StreamOpFlag.SORTED.isPreserved(opsFlags));
+ assertTrue(StreamOpFlag.ORDERED.isKnown(opsFlags));
+ assertFalse(StreamOpFlag.ORDERED.isCleared(opsFlags));
+ assertFalse(StreamOpFlag.ORDERED.isPreserved(opsFlags));
+
+ int streamFlags = toStreamFlags(opsFlags);
+ assertFalse(StreamOpFlag.SIZED.isKnown(streamFlags));
+ assertTrue(StreamOpFlag.DISTINCT.isKnown(streamFlags));
+ assertTrue(StreamOpFlag.SORTED.isKnown(streamFlags));
+ assertTrue(StreamOpFlag.ORDERED.isKnown(streamFlags));
+ }
+
+ public void testSpliteratorMask() {
+ assertSpliteratorMask(StreamOpFlag.DISTINCT.set(), StreamOpFlag.IS_DISTINCT);
+ assertSpliteratorMask(StreamOpFlag.DISTINCT.clear(), 0);
+
+ assertSpliteratorMask(StreamOpFlag.SORTED.set(), StreamOpFlag.IS_SORTED);
+ assertSpliteratorMask(StreamOpFlag.SORTED.clear(), 0);
+
+ assertSpliteratorMask(StreamOpFlag.ORDERED.set(), StreamOpFlag.IS_ORDERED);
+ assertSpliteratorMask(StreamOpFlag.ORDERED.clear(), 0);
+
+ assertSpliteratorMask(StreamOpFlag.SIZED.set(), StreamOpFlag.IS_SIZED);
+ assertSpliteratorMask(StreamOpFlag.SIZED.clear(), 0);
+
+ assertSpliteratorMask(StreamOpFlag.SHORT_CIRCUIT.set(), 0);
+ assertSpliteratorMask(StreamOpFlag.SHORT_CIRCUIT.clear(), 0);
+ }
+
+ private void assertSpliteratorMask(int actual, int expected) {
+ assertEquals(actual & StreamOpFlag.SPLITERATOR_CHARACTERISTICS_MASK, expected);
+ }
+
+ public void testStreamMask() {
+ assertStreamMask(StreamOpFlag.DISTINCT.set(), StreamOpFlag.IS_DISTINCT);
+ assertStreamMask(StreamOpFlag.DISTINCT.clear(), 0);
+
+ assertStreamMask(StreamOpFlag.SORTED.set(), StreamOpFlag.IS_SORTED);
+ assertStreamMask(StreamOpFlag.SORTED.clear(), 0);
+
+ assertStreamMask(StreamOpFlag.ORDERED.set(), StreamOpFlag.IS_ORDERED);
+ assertStreamMask(StreamOpFlag.ORDERED.clear(), 0);
+
+ assertStreamMask(StreamOpFlag.SIZED.set(), StreamOpFlag.IS_SIZED);
+ assertStreamMask(StreamOpFlag.SIZED.clear(), 0);
+
+ assertStreamMask(StreamOpFlag.SHORT_CIRCUIT.set(), 0);
+ assertStreamMask(StreamOpFlag.SHORT_CIRCUIT.clear(), 0);
+ }
+
+ private void assertStreamMask(int actual, int expected) {
+ assertEquals(actual & StreamOpFlag.STREAM_MASK, expected);
+ }
+
+ public void testOpMask() {
+ assertOpMask(StreamOpFlag.DISTINCT.set(), StreamOpFlag.IS_DISTINCT);
+ assertOpMask(StreamOpFlag.DISTINCT.clear(), StreamOpFlag.NOT_DISTINCT);
+
+ assertOpMask(StreamOpFlag.SORTED.set(), StreamOpFlag.IS_SORTED);
+ assertOpMask(StreamOpFlag.SORTED.clear(), StreamOpFlag.NOT_SORTED);
+
+ assertOpMask(StreamOpFlag.ORDERED.set(), StreamOpFlag.IS_ORDERED);
+ assertOpMask(StreamOpFlag.ORDERED.clear(), StreamOpFlag.NOT_ORDERED);
+
+ assertOpMask(StreamOpFlag.SIZED.set(), 0);
+ assertOpMask(StreamOpFlag.SIZED.clear(), StreamOpFlag.NOT_SIZED);
+
+ assertOpMask(StreamOpFlag.SHORT_CIRCUIT.set(), StreamOpFlag.IS_SHORT_CIRCUIT);
+ assertOpMask(StreamOpFlag.SHORT_CIRCUIT.clear(), 0);
+ }
+
+ private void assertOpMask(int actual, int expected) {
+ assertEquals(actual & StreamOpFlag.OP_MASK, expected);
+ }
+
+ public void testTerminalOpMask() {
+ assertTerminalOpMask(StreamOpFlag.DISTINCT.set(), 0);
+ assertTerminalOpMask(StreamOpFlag.DISTINCT.clear(), 0);
+
+ assertTerminalOpMask(StreamOpFlag.SORTED.set(), 0);
+ assertTerminalOpMask(StreamOpFlag.SORTED.clear(), 0);
+
+ assertTerminalOpMask(StreamOpFlag.ORDERED.set(), 0);
+ assertTerminalOpMask(StreamOpFlag.ORDERED.clear(), StreamOpFlag.NOT_ORDERED);
+
+ assertTerminalOpMask(StreamOpFlag.SIZED.set(), 0);
+ assertTerminalOpMask(StreamOpFlag.SIZED.clear(), 0);
+
+ assertTerminalOpMask(StreamOpFlag.SHORT_CIRCUIT.set(), StreamOpFlag.IS_SHORT_CIRCUIT);
+ assertTerminalOpMask(StreamOpFlag.SHORT_CIRCUIT.clear(), 0);
+ }
+
+ private void assertTerminalOpMask(int actual, int expected) {
+ assertEquals(actual & StreamOpFlag.TERMINAL_OP_MASK, expected);
+ }
+
+ public void testUpstreamTerminalOpMask() {
+ assertUpstreamTerminalOpMask(StreamOpFlag.DISTINCT.set(), 0);
+ assertUpstreamTerminalOpMask(StreamOpFlag.DISTINCT.clear(), 0);
+
+ assertUpstreamTerminalOpMask(StreamOpFlag.SORTED.set(), 0);
+ assertUpstreamTerminalOpMask(StreamOpFlag.SORTED.clear(), 0);
+
+ assertUpstreamTerminalOpMask(StreamOpFlag.ORDERED.set(), 0);
+ assertUpstreamTerminalOpMask(StreamOpFlag.ORDERED.clear(), StreamOpFlag.NOT_ORDERED);
+
+ assertUpstreamTerminalOpMask(StreamOpFlag.SIZED.set(), 0);
+ assertUpstreamTerminalOpMask(StreamOpFlag.SIZED.clear(), 0);
+
+ assertUpstreamTerminalOpMask(StreamOpFlag.SHORT_CIRCUIT.set(), 0);
+ assertUpstreamTerminalOpMask(StreamOpFlag.SHORT_CIRCUIT.clear(), 0);
+ }
+
+ private void assertUpstreamTerminalOpMask(int actual, int expected) {
+ assertEquals(actual & StreamOpFlag.UPSTREAM_TERMINAL_OP_MASK, expected);
+ }
+
+ public void testSpliteratorCharacteristics() {
+ assertEquals(Spliterator.DISTINCT, StreamOpFlag.IS_DISTINCT);
+ assertEquals(Spliterator.SORTED, StreamOpFlag.IS_SORTED);
+ assertEquals(Spliterator.ORDERED, StreamOpFlag.IS_ORDERED);
+ assertEquals(Spliterator.SIZED, StreamOpFlag.IS_SIZED);
+
+ List<Integer> others = Arrays.asList(Spliterator.NONNULL, Spliterator.IMMUTABLE,
+ Spliterator.CONCURRENT, Spliterator.SUBSIZED);
+ for (int c : others) {
+ assertNotEquals(c, StreamOpFlag.IS_SHORT_CIRCUIT);
+ }
+ }
+
+ public void testSpliteratorCharacteristicsMask() {
+ assertSpliteratorCharacteristicsMask(StreamOpFlag.DISTINCT.set(), StreamOpFlag.IS_DISTINCT);
+ assertSpliteratorCharacteristicsMask(StreamOpFlag.DISTINCT.clear(), 0);
+
+ assertSpliteratorCharacteristicsMask(StreamOpFlag.SORTED.set(), StreamOpFlag.IS_SORTED);
+ assertSpliteratorCharacteristicsMask(StreamOpFlag.SORTED.clear(), 0);
+
+ assertSpliteratorCharacteristicsMask(StreamOpFlag.ORDERED.set(), StreamOpFlag.IS_ORDERED);
+ assertSpliteratorCharacteristicsMask(StreamOpFlag.ORDERED.clear(), 0);
+
+ assertSpliteratorCharacteristicsMask(StreamOpFlag.SIZED.set(), StreamOpFlag.IS_SIZED);
+ assertSpliteratorCharacteristicsMask(StreamOpFlag.SIZED.clear(), 0);
+
+ assertSpliteratorCharacteristicsMask(StreamOpFlag.SHORT_CIRCUIT.set(), 0);
+ assertSpliteratorCharacteristicsMask(StreamOpFlag.SHORT_CIRCUIT.clear(), 0);
+ }
+
+ private void assertSpliteratorCharacteristicsMask(int actual, int expected) {
+ assertEquals(StreamOpFlag.fromCharacteristics(actual), expected);
+ }
+
+ public void testSpliteratorSorted() {
+ class SortedEmptySpliterator implements Spliterator<Object> {
+ final Comparator<Object> c;
+
+ SortedEmptySpliterator(Comparator<Object> c) {
+ this.c = c;
+ }
+
+ @Override
+ public Spliterator<Object> trySplit() {
+ return null;
+ }
+
+ @Override
+ public boolean tryAdvance(Consumer<? super Object> action) {
+ return false;
+ }
+
+ @Override
+ public long estimateSize() {
+ return Long.MAX_VALUE;
+ }
+
+ @Override
+ public int characteristics() {
+ return Spliterator.SORTED;
+ }
+
+ @Override
+ public Comparator<? super Object> getComparator() {
+ return c;
+ }
+ };
+
+ {
+ int flags = StreamOpFlag.fromCharacteristics(new SortedEmptySpliterator(null));
+ assertEquals(flags, StreamOpFlag.IS_SORTED);
+ }
+
+ {
+ int flags = StreamOpFlag.fromCharacteristics(new SortedEmptySpliterator((a, b) -> 0));
+ assertEquals(flags, 0);
+ }
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/boottest/java/util/stream/StreamReuseTest.java b/ojluni/src/test/java/util/stream/boottest/java/util/stream/StreamReuseTest.java
new file mode 100644
index 0000000..0ac9d68
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/boottest/java/util/stream/StreamReuseTest.java
@@ -0,0 +1,441 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.util.stream;
+
+import org.testng.annotations.Test;
+
+import java.util.function.Function;
+
+import static org.testng.Assert.fail;
+
+/**
+ * StreamReuseTest
+ *
+ * @author Brian Goetz
+ */
+@Test
+public class StreamReuseTest {
+
+ private <T, U, E, S extends BaseStream<E, S>, D extends TestData<E, S>> void assertSecondFails(
+ D data,
+ Function<S, T> first,
+ Function<S, U> second,
+ Class<? extends Throwable> exception,
+ String text) {
+ S stream = data.stream();
+ T fr = first.apply(stream);
+ try {
+ U sr = second.apply(stream);
+ fail(text + " (seq)");
+ }
+ catch (Throwable e) {
+ if (exception.isAssignableFrom(e.getClass())) {
+ // Expected
+ }
+ else if (e instanceof Error)
+ throw (Error) e;
+ else if (e instanceof RuntimeException)
+ throw (RuntimeException) e;
+ else
+ throw new AssertionError("Unexpected exception " + e.getClass(), e);
+ }
+
+ stream = data.parallelStream();
+ fr = first.apply(stream);
+ try {
+ U sr = second.apply(stream);
+ fail(text + " (par)");
+ }
+ catch (Throwable e) {
+ if (exception.isAssignableFrom(e.getClass())) {
+ // Expected
+ }
+ else if (e instanceof Error)
+ throw (Error) e;
+ else if (e instanceof RuntimeException)
+ throw (RuntimeException) e;
+ else
+ throw new AssertionError("Unexpected exception " + e.getClass(), e);
+ }
+ }
+
+ // Stream
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testTwoStreams(String name, TestData<Integer, Stream<Integer>> data) {
+ assertSecondFails(data,
+ (Stream<Integer> s) -> s.map(i -> i), (Stream<Integer> s) -> s.map(i -> i),
+ IllegalStateException.class,
+ "Stream map / map succeeded erroneously");
+ assertSecondFails(data,
+ Stream::distinct, (Stream<Integer> s) -> s.map(i -> i),
+ IllegalStateException.class,
+ "Stream distinct / map succeeded erroneously");
+ assertSecondFails(data,
+ (Stream<Integer> s) -> s.map(i -> i), Stream::distinct,
+ IllegalStateException.class,
+ "Stream map / distinct succeeded erroneously");
+ assertSecondFails(data,
+ Stream::distinct, Stream::distinct,
+ IllegalStateException.class,
+ "Stream distinct / distinct succeeded erroneously");
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testTwoTerminals(String name, TestData<Integer, Stream<Integer>> data) {
+ assertSecondFails(data,
+ Stream::findFirst, Stream::findFirst,
+ IllegalStateException.class,
+ "Stream findFirst / findFirst succeeded erroneously");
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testTerminalStream(String name, TestData<Integer, Stream<Integer>> data) {
+ assertSecondFails(data,
+ Stream::findFirst, (Stream<Integer> s) -> s.map(i -> i),
+ IllegalStateException.class,
+ "Stream findFirst / map succeeded erroneously");
+ assertSecondFails(data,
+ (Stream<Integer> s) -> s.map(i -> i), Stream::findFirst,
+ IllegalStateException.class,
+ "Stream map / findFirst succeeded erroneously");
+ assertSecondFails(data,
+ Stream::findFirst, Stream::distinct,
+ IllegalStateException.class,
+ "Stream findFirst / distinct succeeded erroneously");
+ assertSecondFails(data,
+ Stream::distinct, Stream::findFirst,
+ IllegalStateException.class,
+ "Stream distinct / findFirst succeeded erroneously");
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testTwoIterators(String name, TestData<Integer, Stream<Integer>> data) {
+ assertSecondFails(data,
+ Stream::iterator, Stream::iterator,
+ IllegalStateException.class,
+ "Stream iterator / iterator succeeded erroneously");
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testTerminalIterator(String name, TestData<Integer, Stream<Integer>> data) {
+ assertSecondFails(data,
+ Stream::iterator, Stream::findFirst,
+ IllegalStateException.class,
+ "Stream iterator / findFirst succeeded erroneously");
+ assertSecondFails(data,
+ Stream::findFirst, Stream::iterator,
+ IllegalStateException.class,
+ "Stream findFirst / iterator succeeded erroneously");
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testStreamIterator(String name, TestData<Integer, Stream<Integer>> data) {
+ assertSecondFails(data,
+ Stream::iterator, (Stream<Integer> s) -> s.map(i -> i),
+ IllegalStateException.class,
+ "Stream iterator / map succeeded erroneously");
+ assertSecondFails(data,
+ (Stream<Integer> s) -> s.map(i -> i), Stream::iterator,
+ IllegalStateException.class,
+ "Stream map / iterator succeeded erroneously");
+ assertSecondFails(data,
+ Stream::iterator, Stream::distinct,
+ IllegalStateException.class,
+ "Stream iterator / distinct succeeded erroneously");
+ assertSecondFails(data,
+ Stream::distinct, Stream::iterator,
+ IllegalStateException.class,
+ "Stream distinct / iterator succeeded erroneously");
+ }
+
+ // IntStream
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testTwoStreams(String name, TestData.OfInt data) {
+ assertSecondFails(data,
+ (IntStream s) -> s.mapToObj(i -> i), (IntStream s) -> s.mapToObj(i -> i),
+ IllegalStateException.class,
+ "IntStream map / map succeeded erroneously");
+ assertSecondFails(data,
+ IntStream::distinct, (IntStream s) -> s.mapToObj(i -> i),
+ IllegalStateException.class,
+ "IntStream distinct / map succeeded erroneously");
+ assertSecondFails(data,
+ (IntStream s) -> s.mapToObj(i -> i), IntStream::distinct,
+ IllegalStateException.class,
+ "IntStream map / distinct succeeded erroneously");
+ assertSecondFails(data,
+ IntStream::distinct, IntStream::distinct,
+ IllegalStateException.class,
+ "IntStream distinct / distinct succeeded erroneously");
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testTwoTerminals(String name, TestData.OfInt data) {
+ assertSecondFails(data,
+ IntStream::sum, IntStream::sum,
+ IllegalStateException.class,
+ "IntStream sum / sum succeeded erroneously");
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testTerminalStream(String name, TestData.OfInt data) {
+ assertSecondFails(data,
+ IntStream::sum, (IntStream s) -> s.mapToObj(i -> i),
+ IllegalStateException.class,
+ "IntStream sum / map succeeded erroneously");
+ assertSecondFails(data,
+ (IntStream s) -> s.mapToObj(i -> i), IntStream::sum,
+ IllegalStateException.class,
+ "IntStream map / sum succeeded erroneously");
+ assertSecondFails(data,
+ IntStream::sum, IntStream::distinct,
+ IllegalStateException.class,
+ "IntStream sum / distinct succeeded erroneously");
+ assertSecondFails(data,
+ IntStream::distinct, IntStream::sum,
+ IllegalStateException.class,
+ "IntStream distinct / sum succeeded erroneously");
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testTwoIterators(String name, TestData.OfInt data) {
+ assertSecondFails(data,
+ IntStream::iterator, IntStream::iterator,
+ IllegalStateException.class,
+ "IntStream iterator / iterator succeeded erroneously");
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testTerminalIterator(String name, TestData.OfInt data) {
+ assertSecondFails(data,
+ IntStream::iterator, IntStream::sum,
+ IllegalStateException.class,
+ "IntStream iterator / sum succeeded erroneously");
+ assertSecondFails(data,
+ IntStream::sum, IntStream::iterator,
+ IllegalStateException.class,
+ "Stream sum / iterator succeeded erroneously");
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testStreamIterator(String name, TestData.OfInt data) {
+ assertSecondFails(data,
+ IntStream::iterator, (IntStream s) -> s.mapToObj(i -> i),
+ IllegalStateException.class,
+ "IntStream iterator / map succeeded erroneously");
+ assertSecondFails(data,
+ (IntStream s) -> s.mapToObj(i -> i), IntStream::iterator,
+ IllegalStateException.class,
+ "IntStream map / iterator succeeded erroneously");
+ assertSecondFails(data,
+ IntStream::iterator, IntStream::distinct,
+ IllegalStateException.class,
+ "IntStream iterator / distinct succeeded erroneously");
+ assertSecondFails(data,
+ IntStream::distinct, IntStream::iterator,
+ IllegalStateException.class,
+ "IntStream distinct / iterator succeeded erroneously");
+ }
+
+ // LongStream
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testTwoStreams(String name, TestData.OfLong data) {
+ assertSecondFails(data,
+ (LongStream s) -> s.mapToObj(i -> i), (LongStream s) -> s.mapToObj(i -> i),
+ IllegalStateException.class,
+ "LongStream map / map succeeded erroneously");
+ assertSecondFails(data,
+ LongStream::distinct, (LongStream s) -> s.mapToObj(i -> i),
+ IllegalStateException.class,
+ "LongStream distinct / map succeeded erroneously");
+ assertSecondFails(data,
+ (LongStream s) -> s.mapToObj(i -> i), LongStream::distinct,
+ IllegalStateException.class,
+ "LongStream map / distinct succeeded erroneously");
+ assertSecondFails(data,
+ LongStream::distinct, LongStream::distinct,
+ IllegalStateException.class,
+ "LongStream distinct / distinct succeeded erroneously");
+ }
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testTwoTerminals(String name, TestData.OfLong data) {
+ assertSecondFails(data,
+ LongStream::sum, LongStream::sum,
+ IllegalStateException.class,
+ "LongStream sum / sum succeeded erroneously");
+ }
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testTerminalStream(String name, TestData.OfLong data) {
+ assertSecondFails(data,
+ LongStream::sum, (LongStream s) -> s.mapToObj(i -> i),
+ IllegalStateException.class,
+ "LongStream sum / map succeeded erroneously");
+ assertSecondFails(data,
+ (LongStream s) -> s.mapToObj(i -> i), LongStream::sum,
+ IllegalStateException.class,
+ "LongStream map / sum succeeded erroneously");
+ assertSecondFails(data,
+ LongStream::sum, LongStream::distinct,
+ IllegalStateException.class,
+ "LongStream sum / distinct succeeded erroneously");
+ assertSecondFails(data,
+ LongStream::distinct, LongStream::sum,
+ IllegalStateException.class,
+ "LongStream distinct / sum succeeded erroneously");
+ }
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testTwoIterators(String name, TestData.OfLong data) {
+ assertSecondFails(data,
+ LongStream::iterator, LongStream::iterator,
+ IllegalStateException.class,
+ "LongStream iterator / iterator succeeded erroneously");
+ }
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testTerminalIterator(String name, TestData.OfLong data) {
+ assertSecondFails(data,
+ LongStream::iterator, LongStream::sum,
+ IllegalStateException.class,
+ "LongStream iterator / sum succeeded erroneously");
+ assertSecondFails(data,
+ LongStream::sum, LongStream::iterator,
+ IllegalStateException.class,
+ "Stream sum / iterator succeeded erroneously");
+ }
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testStreamIterator(String name, TestData.OfLong data) {
+ assertSecondFails(data,
+ LongStream::iterator, (LongStream s) -> s.mapToObj(i -> i),
+ IllegalStateException.class,
+ "LongStream iterator / map succeeded erroneously");
+ assertSecondFails(data,
+ (LongStream s) -> s.mapToObj(i -> i), LongStream::iterator,
+ IllegalStateException.class,
+ "LongStream map / iterator succeeded erroneously");
+ assertSecondFails(data,
+ LongStream::iterator, LongStream::distinct,
+ IllegalStateException.class,
+ "LongStream iterator / distinct succeeded erroneously");
+ assertSecondFails(data,
+ LongStream::distinct, LongStream::iterator,
+ IllegalStateException.class,
+ "LongStream distinct / iterator succeeded erroneously");
+ }
+
+ // DoubleStream
+
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testTwoStreams(String name, TestData.OfDouble data) {
+ assertSecondFails(data,
+ (DoubleStream s) -> s.mapToObj(i -> i), (DoubleStream s) -> s.mapToObj(i -> i),
+ IllegalStateException.class,
+ "DoubleStream map / map succeeded erroneously");
+ assertSecondFails(data,
+ DoubleStream::distinct, (DoubleStream s) -> s.mapToObj(i -> i),
+ IllegalStateException.class,
+ "DoubleStream distinct / map succeeded erroneously");
+ assertSecondFails(data,
+ (DoubleStream s) -> s.mapToObj(i -> i), DoubleStream::distinct,
+ IllegalStateException.class,
+ "DoubleStream map / distinct succeeded erroneously");
+ assertSecondFails(data,
+ DoubleStream::distinct, DoubleStream::distinct,
+ IllegalStateException.class,
+ "DoubleStream distinct / distinct succeeded erroneously");
+ }
+
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testTwoTerminals(String name, TestData.OfDouble data) {
+ assertSecondFails(data,
+ DoubleStream::sum, DoubleStream::sum,
+ IllegalStateException.class,
+ "DoubleStream sum / sum succeeded erroneously");
+ }
+
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testTerminalStream(String name, TestData.OfDouble data) {
+ assertSecondFails(data,
+ DoubleStream::sum, (DoubleStream s) -> s.mapToObj(i -> i),
+ IllegalStateException.class,
+ "DoubleStream sum / map succeeded erroneously");
+ assertSecondFails(data,
+ (DoubleStream s) -> s.mapToObj(i -> i), DoubleStream::sum,
+ IllegalStateException.class,
+ "DoubleStream map / sum succeeded erroneously");
+ assertSecondFails(data,
+ DoubleStream::sum, DoubleStream::distinct,
+ IllegalStateException.class,
+ "DoubleStream sum / distinct succeeded erroneously");
+ assertSecondFails(data,
+ DoubleStream::distinct, DoubleStream::sum,
+ IllegalStateException.class,
+ "DoubleStream distinct / sum succeeded erroneously");
+ }
+
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testTwoIterators(String name, TestData.OfDouble data) {
+ assertSecondFails(data,
+ DoubleStream::iterator, DoubleStream::iterator,
+ IllegalStateException.class,
+ "DoubleStream iterator / iterator succeeded erroneously");
+ }
+
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testTerminalIterator(String name, TestData.OfDouble data) {
+ assertSecondFails(data,
+ DoubleStream::iterator, DoubleStream::sum,
+ IllegalStateException.class,
+ "DoubleStream iterator / sum succeeded erroneously");
+ assertSecondFails(data,
+ DoubleStream::sum, DoubleStream::iterator,
+ IllegalStateException.class,
+ "Stream sum / iterator succeeded erroneously");
+ }
+
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testStreamIterator(String name, TestData.OfDouble data) {
+ assertSecondFails(data,
+ DoubleStream::iterator, (DoubleStream s) -> s.mapToObj(i -> i),
+ IllegalStateException.class,
+ "DoubleStream iterator / map succeeded erroneously");
+ assertSecondFails(data,
+ (DoubleStream s) -> s.mapToObj(i -> i), DoubleStream::iterator,
+ IllegalStateException.class,
+ "DoubleStream map / iterator succeeded erroneously");
+ assertSecondFails(data,
+ DoubleStream::iterator, DoubleStream::distinct,
+ IllegalStateException.class,
+ "DoubleStream iterator / distinct succeeded erroneously");
+ assertSecondFails(data,
+ DoubleStream::distinct, DoubleStream::iterator,
+ IllegalStateException.class,
+ "DoubleStream distinct / iterator succeeded erroneously");
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/TEST.properties b/ojluni/src/test/java/util/stream/test/TEST.properties
new file mode 100644
index 0000000..4128f6a
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/TEST.properties
@@ -0,0 +1,8 @@
+# This file identifies root(s) of the test-ng hierarchy.
+
+TestNG.dirs = .
+
+lib.dirs = /java/util/stream/bootlib
+
+# Tests that must run in othervm mode
+othervm.dirs= /java/util/stream
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/lang/invoke/DeserializeMethodTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/lang/invoke/DeserializeMethodTest.java
new file mode 100644
index 0000000..1fbf769
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/lang/invoke/DeserializeMethodTest.java
@@ -0,0 +1,87 @@
+/*
+ * 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.lang.invoke;
+
+import org.testng.annotations.Test;
+
+import java.io.Serializable;
+import java.lang.invoke.SerializedLambda;
+import java.lang.reflect.Method;
+
+import static org.testng.Assert.fail;
+
+/**
+ * Ensure that the $deserializeLambda$ method is present when it should be, and absent otherwise
+ */
+
+@Test(groups = { "serialization-hostile" })
+public class DeserializeMethodTest {
+ private void assertDeserializeMethod(Class<?> clazz, boolean expectedPresent) {
+ try {
+ Method m = clazz.getDeclaredMethod("$deserializeLambda$", SerializedLambda.class);
+ if (!expectedPresent)
+ fail("Unexpected $deserializeLambda$ in " + clazz);
+ }
+ catch (NoSuchMethodException e) {
+ if (expectedPresent)
+ fail("Expected to find $deserializeLambda$ in " + clazz);
+ }
+ }
+
+ static class Empty {}
+
+ public void testEmptyClass() {
+ assertDeserializeMethod(Empty.class, false);
+ }
+
+ static class Cap1 {
+ void foo() {
+ Runnable r = (Runnable & Serializable) () -> { };
+ }
+ }
+
+ public void testCapturingSerLambda() {
+ assertDeserializeMethod(Cap1.class, true);
+ }
+
+ static class Cap2 {
+ void foo() {
+ Runnable r = () -> { };
+ }
+ }
+
+ public void testCapturingNonSerLambda() {
+ assertDeserializeMethod(Cap2.class, false);
+ }
+
+ interface Marker { }
+ static class Cap3 {
+ void foo() {
+ Runnable r = (Runnable & Marker) () -> { };
+ }
+ }
+
+ public void testCapturingNonserIntersectionLambda() {
+ assertDeserializeMethod(Cap3.class, false);
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/lang/invoke/SerializedLambdaTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/lang/invoke/SerializedLambdaTest.java
new file mode 100644
index 0000000..fdbd689
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/lang/invoke/SerializedLambdaTest.java
@@ -0,0 +1,357 @@
+/*
+ * 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.lang.invoke;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.NotSerializableException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.lang.invoke.CallSite;
+import java.lang.invoke.LambdaMetafactory;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.BiPredicate;
+import java.util.function.Consumer;
+import java.util.function.LongConsumer;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+import org.testng.annotations.Test;
+
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertTrue;
+import static org.testng.Assert.fail;
+
+/**
+ * SerializedLambdaTest
+ *
+ * @author Brian Goetz
+ */
+@Test
+public class SerializedLambdaTest {
+ public static final int REPS = 50;
+
+ @SuppressWarnings("unchecked")
+ private<T> void assertSerial(T p, Consumer<T> asserter) throws IOException, ClassNotFoundException {
+ asserter.accept(p);
+
+ for (int i=0; i<REPS; i++) {
+ byte[] bytes = serialize(p);
+ assertTrue(bytes.length > 0);
+
+ asserter.accept((T) deserialize(bytes));
+ }
+ }
+
+ private void assertNotSerial(Predicate<String> p, Consumer<Predicate<String>> asserter)
+ throws IOException, ClassNotFoundException {
+ asserter.accept(p);
+ try {
+ byte[] bytes = serialize(p);
+ fail("Expected serialization failure");
+ }
+ catch (NotSerializableException e) {
+ // success
+ }
+ }
+
+ private byte[] serialize(Object o) throws IOException {
+ ByteArrayOutputStream bos = new ByteArrayOutputStream();
+ ObjectOutputStream oos = new ObjectOutputStream(bos);
+ oos.writeObject(o);
+ oos.close();
+ return bos.toByteArray();
+ }
+
+ private Object deserialize(byte[] bytes) throws IOException, ClassNotFoundException {
+ try(ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes))) {
+ return ois.readObject();
+ }
+ }
+
+ // Test instantiating against intersection type
+ public void testSimpleSerializedInstantiation() throws IOException, ClassNotFoundException {
+ @SuppressWarnings("unchecked")
+ Predicate<String> pred = (Predicate<String> & Serializable) s -> true;
+ assertSerial(pred,
+ p -> {
+ assertTrue(p instanceof Predicate);
+ assertTrue(p instanceof Serializable);
+ assertTrue(p.test(""));
+ });
+ }
+
+ interface SerPredicate<T> extends Predicate<T>, Serializable { }
+
+ // Test instantiating against derived type
+ public void testSimpleSerializedInstantiation2() throws IOException, ClassNotFoundException {
+ SerPredicate<String> serPred = (SerPredicate<String>) s -> true;
+ assertSerial(serPred,
+ p -> {
+ assertTrue(p instanceof Predicate);
+ assertTrue(p instanceof Serializable);
+ assertTrue(p instanceof SerPredicate);
+ assertTrue(p.test(""));
+ });
+ }
+
+ // Negative test: non-serializable lambdas are in fact not serializable
+ public void testNonserializableInstantiation() throws IOException, ClassNotFoundException {
+ @SuppressWarnings("unchecked")
+ Predicate<String> pred = (Predicate<String>) s -> true;
+ assertNotSerial(pred,
+ p -> {
+ assertTrue(p instanceof Predicate);
+ assertFalse(p instanceof Serializable);
+ assertTrue(p.test(""));
+ });
+ }
+
+ // Test lambda capturing int
+ public void testSerializeCapturingInt() throws IOException, ClassNotFoundException {
+ class Moo {
+ @SuppressWarnings("unchecked")
+ Predicate<String> foo(int x) {
+ return (Predicate<String> & Serializable) s -> s.length() >= x;
+ }
+ }
+ Predicate<String> pred = new Moo().foo(3);
+ assertSerial(pred, p -> {
+ assertTrue(p.test("yada"));
+ assertFalse(p.test("no"));
+ });
+ }
+
+ // Test lambda capturing String
+ public void testSerializeCapturingString() throws IOException, ClassNotFoundException {
+ class Moo {
+ @SuppressWarnings("unchecked")
+ Predicate<String> foo(String t) {
+ return (Predicate<String> & Serializable) s -> s.equals(t);
+ }
+ }
+ Predicate<String> pred = new Moo().foo("goo");
+ assertSerial(pred, p -> {
+ assertTrue(p.test("goo"));
+ assertFalse(p.test("foo"));
+ });
+ }
+
+ // Negative test: lambdas that capture a non-serializable var
+ public void testSerializeCapturingNonSerializable() throws IOException, ClassNotFoundException {
+ class Box {
+ String s;
+
+ Box(String s) { this.s = s; }
+ }
+ class Moo {
+ @SuppressWarnings("unchecked")
+ Predicate<String> foo(Box b) {
+ return (Predicate<String> & Serializable) s -> s.equals(b.s);
+ }
+ }
+ Predicate<String> pred = new Moo().foo(new Box("goo"));
+ assertNotSerial(pred, p -> {
+ assertTrue(p.test("goo"));
+ assertFalse(p.test("foo"));
+ });
+ }
+
+ static boolean startsWithA(String s) {
+ return s.startsWith("a");
+ }
+
+ // Test static method ref
+ public void testStaticMR() throws IOException, ClassNotFoundException {
+ @SuppressWarnings("unchecked")
+ Predicate<String> mh1 = (Predicate<String> & Serializable) SerializedLambdaTest::startsWithA;
+ @SuppressWarnings("unchecked")
+ Predicate<String> mh2 = (SerPredicate<String>) SerializedLambdaTest::startsWithA;
+ Consumer<Predicate<String>> b = p -> {
+ assertTrue(p instanceof Serializable);
+ assertTrue(p.test("arf"));
+ assertFalse(p.test("barf"));
+ };
+ assertSerial(mh1, b);
+ assertSerial(mh2, b);
+ }
+
+ // Test unbound method ref of nonserializable class -- should still succeed
+ public void testUnboundMR() throws IOException, ClassNotFoundException {
+ class Moo {
+ public boolean startsWithB(String s) {
+ return s.startsWith("b");
+ }
+ }
+ @SuppressWarnings("unchecked")
+ BiPredicate<Moo, String> mh1 = (BiPredicate<Moo, String> & Serializable) Moo::startsWithB;
+ Consumer<BiPredicate<Moo, String>> b = p -> {
+ assertTrue(p instanceof Serializable);
+ assertTrue(p.test(new Moo(), "barf"));
+ assertFalse(p.test(new Moo(), "arf"));
+ };
+ assertSerial(mh1, b);
+ }
+
+ // Negative test: test bound MR of nonserializable class
+ public void testBoundMRNotSerReceiver() throws IOException, ClassNotFoundException {
+ class Moo {
+ public boolean startsWithB(String s) {
+ return s.startsWith("b");
+ }
+ }
+ Moo moo = new Moo();
+ @SuppressWarnings("unchecked")
+ Predicate<String> mh1 = (Predicate<String> & Serializable) moo::startsWithB;
+ @SuppressWarnings("unchecked")
+ Predicate<String> mh2 = (SerPredicate<String>) moo::startsWithB;
+ Consumer<Predicate<String>> b = p -> {
+ assertTrue(p instanceof Serializable);
+ assertTrue(p.test("barf"));
+ assertFalse(p.test("arf"));
+ };
+ assertNotSerial(mh1, b);
+ assertNotSerial(mh2, b);
+ }
+
+ // Test bound MR of serializable class
+ @SuppressWarnings("serial")
+ static class ForBoundMRef implements Serializable {
+ public boolean startsWithB(String s) {
+ return s.startsWith("b");
+ }
+ }
+
+ public void testBoundMR() throws IOException, ClassNotFoundException {
+ ForBoundMRef moo = new ForBoundMRef();
+ @SuppressWarnings("unchecked")
+ Predicate<String> mh1 = (Predicate<String> & Serializable) moo::startsWithB;
+ @SuppressWarnings("unchecked")
+ Predicate<String> mh2 = (SerPredicate<String>) moo::startsWithB;
+ Consumer<Predicate<String>> b = p -> {
+ assertTrue(p instanceof Serializable);
+ assertTrue(p.test("barf"));
+ assertFalse(p.test("arf"));
+ };
+ assertSerial(mh1, b);
+ assertSerial(mh2, b);
+ }
+
+ static class ForCtorRef {
+ public boolean startsWithB(String s) {
+ return s.startsWith("b");
+ }
+ }
+ // Test ctor ref of nonserializable class
+ public void testCtorRef() throws IOException, ClassNotFoundException {
+ @SuppressWarnings("unchecked")
+ Supplier<ForCtorRef> ctor = (Supplier<ForCtorRef> & Serializable) ForCtorRef::new;
+ Consumer<Supplier<ForCtorRef>> b = s -> {
+ assertTrue(s instanceof Serializable);
+ ForCtorRef m = s.get();
+ assertTrue(m.startsWithB("barf"));
+ assertFalse(m.startsWithB("arf"));
+ };
+ assertSerial(ctor, b);
+ }
+
+ //Test throwing away return type
+ public void testDiscardReturnBound() throws IOException, ClassNotFoundException {
+ List<String> list = new ArrayList<>();
+ Consumer<String> c = (Consumer<String> & Serializable) list::add;
+ assertSerial(c, cc -> { assertTrue(cc instanceof Consumer); });
+
+ AtomicLong a = new AtomicLong();
+ LongConsumer lc = (LongConsumer & Serializable) a::addAndGet;
+ assertSerial(lc, plc -> { plc.accept(3); });
+ }
+
+ // Tests of direct use of metafactories
+
+ private static boolean foo(Object s) { return s != null && ((String) s).length() > 0; }
+ private static final MethodType predicateMT = MethodType.methodType(boolean.class, Object.class);
+ private static final MethodType stringPredicateMT = MethodType.methodType(boolean.class, String.class);
+ private static final Consumer<Predicate<String>> fooAsserter = x -> {
+ assertTrue(x.test("foo"));
+ assertFalse(x.test(""));
+ assertFalse(x.test(null));
+ };
+
+ // standard MF: nonserializable supertype
+ public void testDirectStdNonser() throws Throwable {
+ MethodHandle fooMH = MethodHandles.lookup().findStatic(SerializedLambdaTest.class, "foo", predicateMT);
+
+ // Standard metafactory, non-serializable target: not serializable
+ CallSite cs = LambdaMetafactory.metafactory(MethodHandles.lookup(),
+ "test", MethodType.methodType(Predicate.class),
+ predicateMT, fooMH, stringPredicateMT);
+ Predicate<String> p = (Predicate<String>) cs.getTarget().invokeExact();
+ assertNotSerial(p, fooAsserter);
+ }
+
+ // standard MF: serializable supertype
+ public void testDirectStdSer() throws Throwable {
+ MethodHandle fooMH = MethodHandles.lookup().findStatic(SerializedLambdaTest.class, "foo", predicateMT);
+
+ // Standard metafactory, serializable target: not serializable
+ CallSite cs = LambdaMetafactory.metafactory(MethodHandles.lookup(),
+ "test", MethodType.methodType(SerPredicate.class),
+ predicateMT, fooMH, stringPredicateMT);
+ assertNotSerial((SerPredicate<String>) cs.getTarget().invokeExact(), fooAsserter);
+ }
+
+ // alt MF: nonserializable supertype
+ public void testAltStdNonser() throws Throwable {
+ MethodHandle fooMH = MethodHandles.lookup().findStatic(SerializedLambdaTest.class, "foo", predicateMT);
+
+ // Alt metafactory, non-serializable target: not serializable
+ CallSite cs = LambdaMetafactory.altMetafactory(MethodHandles.lookup(),
+ "test", MethodType.methodType(Predicate.class),
+ predicateMT, fooMH, stringPredicateMT, 0);
+ assertNotSerial((Predicate<String>) cs.getTarget().invokeExact(), fooAsserter);
+ }
+
+ // alt MF: serializable supertype
+ public void testAltStdSer() throws Throwable {
+ MethodHandle fooMH = MethodHandles.lookup().findStatic(SerializedLambdaTest.class, "foo", predicateMT);
+
+ // Alt metafactory, serializable target, no FLAG_SERIALIZABLE: not serializable
+ CallSite cs = LambdaMetafactory.altMetafactory(MethodHandles.lookup(),
+ "test", MethodType.methodType(SerPredicate.class),
+ predicateMT, fooMH, stringPredicateMT, 0);
+ assertNotSerial((SerPredicate<String>) cs.getTarget().invokeExact(), fooAsserter);
+
+ // Alt metafactory, serializable marker, no FLAG_SERIALIZABLE: not serializable
+ cs = LambdaMetafactory.altMetafactory(MethodHandles.lookup(),
+ "test", MethodType.methodType(Predicate.class),
+ predicateMT, fooMH, stringPredicateMT, LambdaMetafactory.FLAG_MARKERS, 1, Serializable.class);
+ assertNotSerial((Predicate<String>) cs.getTarget().invokeExact(), fooAsserter);
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/FillableStringTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/FillableStringTest.java
new file mode 100644
index 0000000..d4cad59
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/FillableStringTest.java
@@ -0,0 +1,56 @@
+/*
+ * 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;
+
+import java.util.Arrays;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.testng.annotations.Test;
+
+import static org.testng.Assert.*;
+
+@Test(groups = "lib")
+public class FillableStringTest {
+ public Stream<String> generate() {
+ return Arrays.asList("one", "two", "three", "four", "five", "six").stream()
+ .filter(s->s.length() > 3)
+ .map(String::toUpperCase);
+ }
+
+ public void testStringBuilder() {
+ String s = generate().collect(Collectors.joining());
+ assertEquals(s, "THREEFOURFIVE");
+ }
+
+ public void testStringBuffer() {
+ String s = generate().collect(Collectors.joining());
+ assertEquals(s, "THREEFOURFIVE");
+ }
+
+ public void testStringJoiner() {
+ String s = generate().collect(Collectors.joining("-"));
+ assertEquals(s, "THREE-FOUR-FIVE");
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/MapTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/MapTest.java
new file mode 100644
index 0000000..74efed5
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/MapTest.java
@@ -0,0 +1,93 @@
+/*
+ * 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;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.LambdaTestHelpers;
+
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+import static org.testng.Assert.assertEquals;
+
+/**
+ * Unit tests for extension methods on Map
+ */
+public class MapTest {
+
+ private static final Map<Integer, String> EXPECTED = new HashMap<>();
+
+ private Map<Integer, String> map;
+
+ @BeforeClass
+ public void setUpClass() {
+ EXPECTED.put(0, "zero");
+ EXPECTED.put(1, "one");
+ EXPECTED.put(2, "two");
+ EXPECTED.put(3, "three");
+ EXPECTED.put(4, "four");
+ EXPECTED.put(5, "five");
+ EXPECTED.put(6, "six");
+ EXPECTED.put(7, "seven");
+ EXPECTED.put(8, "eight");
+ EXPECTED.put(9, "nine");
+ }
+
+ @AfterClass
+ public void tearDownClass() {
+ EXPECTED.clear();
+ }
+
+ @BeforeMethod
+ public void setUp() {
+ map = new HashMap<>(EXPECTED);
+ }
+
+ @AfterMethod
+ public void tearDown() {
+ map.clear();
+ map = null;
+ }
+
+ @Test(groups = { "serialization-hostile" })
+ public void testForEach() {
+ final Set<String> values = new HashSet<>(EXPECTED.size());
+ map.forEach((k, v) -> {values.add(v);});
+ LambdaTestHelpers.assertContentsUnordered(values, EXPECTED.values());
+ }
+
+ @Test
+ public void testReplaceAll() {
+ map.replaceAll((k, v) -> {return v.toUpperCase();});
+ for (final Map.Entry<Integer, String> entry : map.entrySet()) {
+ assertEquals(entry.getValue(), EXPECTED.get(entry.getKey()).toUpperCase());
+ }
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/NullArgsTestCase.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/NullArgsTestCase.java
new file mode 100644
index 0000000..5cae1ba
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/NullArgsTestCase.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 1997, 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;
+
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.function.Consumer;
+
+import static org.testng.Assert.fail;
+
+/**
+ * NullArgsTestCase -- Given a Consumer<Object[]>, and an Object[] array of args, call the block with the args,
+ * assert success, and then call the consumer N times, each time setting one of the args to null, and assert that
+ * all these throw NPE.
+ *
+ * Typically this would be combined with a DataProvider that serves up combinations of things to be tested, as in
+ * IteratorsNullTest.
+ */
+public abstract class NullArgsTestCase {
+ public final String name;
+ public final Consumer<Object[]> sink;
+ public final Object[] args;
+
+ protected NullArgsTestCase(String name, Consumer<Object[]> sink, Object[] args) {
+ this.name = name;
+ this.sink = sink;
+ this.args = args;
+ }
+
+ @Test
+ public void goodNonNull() {
+ sink.accept(args);
+ }
+
+ @Test
+ public void throwWithNull() {
+ for (int i=0; i<args.length; i++) {
+ Object[] temp = Arrays.copyOf(args, args.length);
+ temp[i] = null;
+ try {
+ sink.accept(temp);
+ fail(String.format("Expected NullPointerException for argument %d of test case %s", i, name));
+ }
+ catch (NullPointerException e) {
+ // Success
+ }
+ }
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CollectionAndMapModifyStreamTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CollectionAndMapModifyStreamTest.java
new file mode 100644
index 0000000..9a74214
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CollectionAndMapModifyStreamTest.java
@@ -0,0 +1,167 @@
+/*
+ * 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 java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedDeque;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ConcurrentSkipListMap;
+import java.util.concurrent.ConcurrentSkipListSet;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.LinkedBlockingDeque;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.LinkedTransferQueue;
+import java.util.concurrent.PriorityBlockingQueue;
+import java.util.function.Supplier;
+import java.util.stream.LambdaTestHelpers;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.util.*;
+import java.util.stream.Stream;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertTrue;
+
+/**
+ * Tests laziness of stream operations -- mutations to the source after the stream() but prior to terminal operations
+ * are reflected in the stream contents.
+ */
+@Test
+public class CollectionAndMapModifyStreamTest {
+
+ @DataProvider(name = "collections")
+ public Object[][] createCollections() {
+ List<Integer> content = LambdaTestHelpers.countTo(10);
+
+ List<Collection<Integer>> collections = new ArrayList<>();
+ collections.add(new ArrayList<>(content));
+ collections.add(new LinkedList<>(content));
+ collections.add(new Vector<>(content));
+
+ collections.add(new HashSet<>(content));
+ collections.add(new LinkedHashSet<>(content));
+ collections.add(new TreeSet<>(content));
+
+ Stack<Integer> stack = new Stack<>();
+ stack.addAll(content);
+ collections.add(stack);
+ collections.add(new PriorityQueue<>(content));
+ collections.add(new ArrayDeque<>(content));
+
+ // Concurrent collections
+
+ collections.add(new ConcurrentSkipListSet<>(content));
+
+ ArrayBlockingQueue<Integer> arrayBlockingQueue = new ArrayBlockingQueue<>(content.size());
+ for (Integer i : content)
+ arrayBlockingQueue.add(i);
+ collections.add(arrayBlockingQueue);
+ collections.add(new PriorityBlockingQueue<>(content));
+ collections.add(new LinkedBlockingQueue<>(content));
+ collections.add(new LinkedTransferQueue<>(content));
+ collections.add(new ConcurrentLinkedQueue<>(content));
+ collections.add(new LinkedBlockingDeque<>(content));
+ collections.add(new ConcurrentLinkedDeque<>(content));
+
+ Object[][] params = new Object[collections.size()][];
+ for (int i = 0; i < collections.size(); i++) {
+ params[i] = new Object[]{collections.get(i).getClass().getName(), collections.get(i)};
+ }
+
+ return params;
+ }
+
+ @Test(dataProvider = "collections")
+ public void testCollectionSizeRemove(String name, Collection<Integer> c) {
+ assertTrue(c.remove(1));
+ Stream<Integer> s = c.stream();
+ assertTrue(c.remove(2));
+ Object[] result = s.toArray();
+ assertEquals(result.length, c.size());
+ }
+
+ @DataProvider(name = "maps")
+ public Object[][] createMaps() {
+ Map<Integer, Integer> content = new HashMap<>();
+ for (int i = 0; i < 10; i++) {
+ content.put(i, i);
+ }
+
+ Map<String, Supplier<Map<Integer, Integer>>> maps = new HashMap<>();
+
+ maps.put(HashMap.class.getName(), () -> new HashMap<>(content));
+ maps.put(HashMap.class.getName(), () -> new LinkedHashMap<>(content));
+ maps.put(IdentityHashMap.class.getName(), () -> new IdentityHashMap<>(content));
+ maps.put(WeakHashMap.class.getName(), () -> new WeakHashMap<>(content));
+
+ maps.put(TreeMap.class.getName(), () -> new TreeMap<>(content));
+ maps.put(TreeMap.class.getName() + ".descendingMap()", () -> new TreeMap<>(content).descendingMap());
+
+ // The following are not lazy
+// maps.put(TreeMap.class.getName() + ".descendingMap().descendingMap()", () -> new TreeMap<>(content).descendingMap().descendingMap());
+// maps.put(TreeMap.class.getName() + ".headMap()", () -> new TreeMap<>(content).headMap(content.size() - 1));
+// maps.put(TreeMap.class.getName() + ".descendingMap().headMap()", () -> new TreeMap<>(content).descendingMap().tailMap(content.size() - 1, false));
+
+ // Concurrent collections
+
+ maps.put(ConcurrentHashMap.class.getName(), () -> new ConcurrentHashMap<>(content));
+ maps.put(ConcurrentSkipListMap.class.getName(), () -> new ConcurrentSkipListMap<>(content));
+
+ Object[][] params = new Object[maps.size()][];
+ int i = 0;
+ for (Map.Entry<String, Supplier<Map<Integer, Integer>>> e : maps.entrySet()) {
+ params[i++] = new Object[]{e.getKey(), e.getValue()};
+
+ }
+
+ return params;
+ }
+
+ @Test(dataProvider = "maps", groups = { "serialization-hostile" })
+ public void testMapKeysSizeRemove(String name, Supplier<Map<Integer, Integer>> c) {
+ testCollectionSizeRemove(name + " key set", c.get().keySet());
+ }
+
+ @Test(dataProvider = "maps", groups = { "serialization-hostile" })
+ public void testMapValuesSizeRemove(String name, Supplier<Map<Integer, Integer>> c) {
+ testCollectionSizeRemove(name + " value set", c.get().values());
+ }
+
+ @Test(dataProvider = "maps")
+ public void testMapEntriesSizeRemove(String name, Supplier<Map<Integer, Integer>> c) {
+ testEntrySetSizeRemove(name + " entry set", c.get().entrySet());
+ }
+
+ private void testEntrySetSizeRemove(String name, Set<Map.Entry<Integer, Integer>> c) {
+ Map.Entry<Integer, Integer> first = c.iterator().next();
+ assertTrue(c.remove(first));
+ Stream<Map.Entry<Integer, Integer>> s = c.stream();
+ Map.Entry<Integer, Integer> second = c.iterator().next();
+ assertTrue(c.remove(second));
+ Object[] result = s.toArray();
+ assertEquals(result.length, c.size());
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ConcatOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ConcatOpTest.java
new file mode 100644
index 0000000..43c5134
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ConcatOpTest.java
@@ -0,0 +1,142 @@
+/*
+ * 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 java.util.Spliterator;
+import java.util.stream.BaseStream;
+import java.util.stream.OpTestCase;
+import java.util.stream.StreamTestDataProvider;
+
+import org.testng.annotations.Test;
+
+import java.util.stream.Stream;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+import java.util.stream.DoubleStream;
+import java.util.stream.TestData;
+
+import static java.util.stream.LambdaTestHelpers.*;
+import static org.testng.Assert.assertEquals;
+
+/**
+ * @test
+ * @bug 8021863
+ */
+public class ConcatOpTest extends OpTestCase {
+
+ // Sanity to make sure all type of stream source works
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testOps(String name, TestData.OfRef<Integer> data) {
+ exerciseOpsInt(data,
+ s -> Stream.concat(s, data.stream()),
+ s -> IntStream.concat(s, data.stream().mapToInt(Integer::intValue)),
+ s -> LongStream.concat(s, data.stream().mapToLong(Integer::longValue)),
+ s -> DoubleStream.concat(s, data.stream().mapToDouble(Integer::doubleValue)));
+ }
+
+ public void testSize() {
+ assertSized(Stream.concat(
+ LongStream.range(0, Long.MAX_VALUE / 2).boxed(),
+ LongStream.range(0, Long.MAX_VALUE / 2).boxed()));
+
+ assertUnsized(Stream.concat(
+ LongStream.range(0, Long.MAX_VALUE).boxed(),
+ LongStream.range(0, Long.MAX_VALUE).boxed()));
+
+ assertUnsized(Stream.concat(
+ LongStream.range(0, Long.MAX_VALUE).boxed(),
+ Stream.iterate(0, i -> i + 1)));
+
+ assertUnsized(Stream.concat(
+ Stream.iterate(0, i -> i + 1),
+ LongStream.range(0, Long.MAX_VALUE).boxed()));
+ }
+
+ public void testLongSize() {
+ assertSized(LongStream.concat(
+ LongStream.range(0, Long.MAX_VALUE / 2),
+ LongStream.range(0, Long.MAX_VALUE / 2)));
+
+ assertUnsized(LongStream.concat(
+ LongStream.range(0, Long.MAX_VALUE),
+ LongStream.range(0, Long.MAX_VALUE)));
+
+ assertUnsized(LongStream.concat(
+ LongStream.range(0, Long.MAX_VALUE),
+ LongStream.iterate(0, i -> i + 1)));
+
+ assertUnsized(LongStream.concat(
+ LongStream.iterate(0, i -> i + 1),
+ LongStream.range(0, Long.MAX_VALUE)));
+ }
+
+ public void testIntSize() {
+ assertSized(IntStream.concat(
+ IntStream.range(0, Integer.MAX_VALUE),
+ IntStream.range(0, Integer.MAX_VALUE)));
+
+ assertUnsized(IntStream.concat(
+ LongStream.range(0, Long.MAX_VALUE).mapToInt(i -> (int) i),
+ LongStream.range(0, Long.MAX_VALUE).mapToInt(i -> (int) i)));
+
+ assertUnsized(IntStream.concat(
+ LongStream.range(0, Long.MAX_VALUE).mapToInt(i -> (int) i),
+ IntStream.iterate(0, i -> i + 1)));
+
+ assertUnsized(IntStream.concat(
+ IntStream.iterate(0, i -> i + 1),
+ LongStream.range(0, Long.MAX_VALUE).mapToInt(i -> (int) i)));
+ }
+
+ public void testDoubleSize() {
+ assertSized(DoubleStream.concat(
+ IntStream.range(0, Integer.MAX_VALUE).mapToDouble(i -> i),
+ IntStream.range(0, Integer.MAX_VALUE).mapToDouble(i -> i)));
+
+ assertUnsized(DoubleStream.concat(
+ LongStream.range(0, Long.MAX_VALUE).mapToDouble(i -> i),
+ LongStream.range(0, Long.MAX_VALUE).mapToDouble(i -> i)));
+
+ assertUnsized(DoubleStream.concat(
+ LongStream.range(0, Long.MAX_VALUE).mapToDouble(i -> i),
+ DoubleStream.iterate(0, i -> i + 1)));
+
+ assertUnsized(DoubleStream.concat(
+ DoubleStream.iterate(0, i -> i + 1),
+ LongStream.range(0, Long.MAX_VALUE).mapToDouble(i -> i)));
+ }
+
+ void assertUnsized(BaseStream<?, ?> s) {
+ Spliterator<?> sp = s.spliterator();
+
+ assertFalse(sp.hasCharacteristics(Spliterator.SIZED | Spliterator.SUBSIZED));
+ assertEquals(sp.estimateSize(), Long.MAX_VALUE);
+ }
+
+ void assertSized(BaseStream<?, ?> s) {
+ Spliterator<?> sp = s.spliterator();
+
+ assertTrue(sp.hasCharacteristics(Spliterator.SIZED | Spliterator.SUBSIZED));
+ assertTrue(sp.estimateSize() < Long.MAX_VALUE);
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ConcatTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ConcatTest.java
new file mode 100644
index 0000000..cac59c2
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ConcatTest.java
@@ -0,0 +1,238 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ * 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.DataProvider;
+import org.testng.annotations.Factory;
+import org.testng.annotations.Test;
+import org.testng.annotations.BeforeClass;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Spliterator;
+import java.util.TreeSet;
+import java.util.stream.DoubleStream;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+import java.util.stream.Stream;
+
+import static java.util.stream.LambdaTestHelpers.*;
+import static org.testng.Assert.*;
+
+@Test
+public class ConcatTest {
+ private static Object[][] cases;
+
+ static {
+ List<Integer> part1 = Arrays.asList(5, 3, 4, 1, 2, 6, 2, 4);
+ List<Integer> part2 = Arrays.asList(8, 8, 6, 6, 9, 7, 10, 9);
+ List<Integer> p1p2 = Arrays.asList(5, 3, 4, 1, 2, 6, 2, 4, 8, 8, 6, 6, 9, 7, 10, 9);
+ List<Integer> p2p1 = Arrays.asList(8, 8, 6, 6, 9, 7, 10, 9, 5, 3, 4, 1, 2, 6, 2, 4);
+ List<Integer> empty = new LinkedList<>(); // To be ordered
+ assertTrue(empty.isEmpty());
+ LinkedHashSet<Integer> distinctP1 = new LinkedHashSet<>(part1);
+ LinkedHashSet<Integer> distinctP2 = new LinkedHashSet<>(part2);
+ TreeSet<Integer> sortedP1 = new TreeSet<>(part1);
+ TreeSet<Integer> sortedP2 = new TreeSet<>(part2);
+
+ cases = new Object[][] {
+ { "regular", part1, part2, p1p2 },
+ { "reverse regular", part2, part1, p2p1 },
+ { "front distinct", distinctP1, part2, Arrays.asList(5, 3, 4, 1, 2, 6, 8, 8, 6, 6, 9, 7, 10, 9) },
+ { "back distinct", part1, distinctP2, Arrays.asList(5, 3, 4, 1, 2, 6, 2, 4, 8, 6, 9, 7, 10) },
+ { "both distinct", distinctP1, distinctP2, Arrays.asList(5, 3, 4, 1, 2, 6, 8, 6, 9, 7, 10) },
+ { "front sorted", sortedP1, part2, Arrays.asList(1, 2, 3, 4, 5, 6, 8, 8, 6, 6, 9, 7, 10, 9) },
+ { "back sorted", part1, sortedP2, Arrays.asList(5, 3, 4, 1, 2, 6, 2, 4, 6, 7, 8, 9, 10) },
+ { "both sorted", sortedP1, sortedP2, Arrays.asList(1, 2, 3, 4, 5, 6, 6, 7, 8, 9, 10) },
+ { "reverse both sorted", sortedP2, sortedP1, Arrays.asList(6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6) },
+ { "empty something", empty, part1, part1 },
+ { "something empty", part1, empty, part1 },
+ { "empty empty", empty, empty, empty }
+ };
+ }
+
+ @DataProvider(name = "cases")
+ private static Object[][] getCases() {
+ return cases;
+ }
+
+ @Factory(dataProvider = "cases")
+ public static Object[] createTests(String scenario, Collection<Integer> c1, Collection<Integer> c2, Collection<Integer> expected) {
+ return new Object[] {
+ new ConcatTest(scenario, c1, c2, expected)
+ };
+ }
+
+ protected final String scenario;
+ protected final Collection<Integer> c1;
+ protected final Collection<Integer> c2;
+ protected final Collection<Integer> expected;
+
+ public ConcatTest(String scenario, Collection<Integer> c1, Collection<Integer> c2, Collection<Integer> expected) {
+ this.scenario = scenario;
+ this.c1 = c1;
+ this.c2 = c2;
+ this.expected = expected;
+ }
+
+ // Android-changed: Factor out the prerequisites check out of the constructor.
+ // TestNG crashes hard if an assert is thrown in the constructor.
+ // This is done for test readability only and doesn't impact test logic.
+ @BeforeClass
+ public void checkPrerequisites() {
+ // verify prerequisite
+ Stream<Integer> s1s = c1.stream();
+ Stream<Integer> s2s = c2.stream();
+ Stream<Integer> s1p = c1.parallelStream();
+ Stream<Integer> s2p = c2.parallelStream();
+ assertTrue(s1p.isParallel());
+ assertTrue(s2p.isParallel());
+ assertFalse(s1s.isParallel());
+ assertFalse(s2s.isParallel());
+
+ // Android-changed: Also add the class name to easier debug. Doesn't impact logic.
+ assertTrue(s1s.spliterator().hasCharacteristics(Spliterator.ORDERED), c1.getClass().toString());
+ assertTrue(s1p.spliterator().hasCharacteristics(Spliterator.ORDERED), c2.getClass().toString());
+ assertTrue(s2s.spliterator().hasCharacteristics(Spliterator.ORDERED), c1.getClass().toString());
+ assertTrue(s2p.spliterator().hasCharacteristics(Spliterator.ORDERED), c2.getClass().toString());
+ }
+
+ private <T> void assertConcatContent(Spliterator<T> sp, boolean ordered, Spliterator<T> expected) {
+ // concat stream cannot guarantee uniqueness
+ assertFalse(sp.hasCharacteristics(Spliterator.DISTINCT), scenario);
+ // concat stream cannot guarantee sorted
+ assertFalse(sp.hasCharacteristics(Spliterator.SORTED), scenario);
+ // concat stream is ordered if both are ordered
+ assertEquals(sp.hasCharacteristics(Spliterator.ORDERED), ordered, scenario);
+
+ // Verify elements
+ if (ordered) {
+ assertEquals(toBoxedList(sp),
+ toBoxedList(expected),
+ scenario);
+ } else {
+ assertEquals(toBoxedMultiset(sp),
+ toBoxedMultiset(expected),
+ scenario);
+ }
+ }
+
+ private void assertRefConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
+ Stream<Integer> result = Stream.concat(s1, s2);
+ assertEquals(result.isParallel(), parallel);
+ assertConcatContent(result.spliterator(), ordered, expected.spliterator());
+ }
+
+ private void assertIntConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
+ IntStream result = IntStream.concat(s1.mapToInt(Integer::intValue),
+ s2.mapToInt(Integer::intValue));
+ assertEquals(result.isParallel(), parallel);
+ assertConcatContent(result.spliterator(), ordered,
+ expected.stream().mapToInt(Integer::intValue).spliterator());
+ }
+
+ private void assertLongConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
+ LongStream result = LongStream.concat(s1.mapToLong(Integer::longValue),
+ s2.mapToLong(Integer::longValue));
+ assertEquals(result.isParallel(), parallel);
+ assertConcatContent(result.spliterator(), ordered,
+ expected.stream().mapToLong(Integer::longValue).spliterator());
+ }
+
+ private void assertDoubleConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
+ DoubleStream result = DoubleStream.concat(s1.mapToDouble(Integer::doubleValue),
+ s2.mapToDouble(Integer::doubleValue));
+ assertEquals(result.isParallel(), parallel);
+ assertConcatContent(result.spliterator(), ordered,
+ expected.stream().mapToDouble(Integer::doubleValue).spliterator());
+ }
+
+ public void testRefConcat() {
+ // sequential + sequential -> sequential
+ assertRefConcat(c1.stream(), c2.stream(), false, true);
+ // parallel + parallel -> parallel
+ assertRefConcat(c1.parallelStream(), c2.parallelStream(), true, true);
+ // sequential + parallel -> parallel
+ assertRefConcat(c1.stream(), c2.parallelStream(), true, true);
+ // parallel + sequential -> parallel
+ assertRefConcat(c1.parallelStream(), c2.stream(), true, true);
+
+ // not ordered
+ assertRefConcat(c1.stream().unordered(), c2.stream(), false, false);
+ assertRefConcat(c1.stream(), c2.stream().unordered(), false, false);
+ assertRefConcat(c1.parallelStream().unordered(), c2.stream().unordered(), true, false);
+ }
+
+ public void testIntConcat() {
+ // sequential + sequential -> sequential
+ assertIntConcat(c1.stream(), c2.stream(), false, true);
+ // parallel + parallel -> parallel
+ assertIntConcat(c1.parallelStream(), c2.parallelStream(), true, true);
+ // sequential + parallel -> parallel
+ assertIntConcat(c1.stream(), c2.parallelStream(), true, true);
+ // parallel + sequential -> parallel
+ assertIntConcat(c1.parallelStream(), c2.stream(), true, true);
+
+ // not ordered
+ assertIntConcat(c1.stream().unordered(), c2.stream(), false, false);
+ assertIntConcat(c1.stream(), c2.stream().unordered(), false, false);
+ assertIntConcat(c1.parallelStream().unordered(), c2.stream().unordered(), true, false);
+ }
+
+ public void testLongConcat() {
+ // sequential + sequential -> sequential
+ assertLongConcat(c1.stream(), c2.stream(), false, true);
+ // parallel + parallel -> parallel
+ assertLongConcat(c1.parallelStream(), c2.parallelStream(), true, true);
+ // sequential + parallel -> parallel
+ assertLongConcat(c1.stream(), c2.parallelStream(), true, true);
+ // parallel + sequential -> parallel
+ assertLongConcat(c1.parallelStream(), c2.stream(), true, true);
+
+ // not ordered
+ assertLongConcat(c1.stream().unordered(), c2.stream(), false, false);
+ assertLongConcat(c1.stream(), c2.stream().unordered(), false, false);
+ assertLongConcat(c1.parallelStream().unordered(), c2.stream().unordered(), true, false);
+ }
+
+ public void testDoubleConcat() {
+ // sequential + sequential -> sequential
+ assertDoubleConcat(c1.stream(), c2.stream(), false, true);
+ // parallel + parallel -> parallel
+ assertDoubleConcat(c1.parallelStream(), c2.parallelStream(), true, true);
+ // sequential + parallel -> parallel
+ assertDoubleConcat(c1.stream(), c2.parallelStream(), true, true);
+ // parallel + sequential -> parallel
+ assertDoubleConcat(c1.parallelStream(), c2.stream(), true, true);
+
+ // not ordered
+ assertDoubleConcat(c1.stream().unordered(), c2.stream(), false, false);
+ assertDoubleConcat(c1.stream(), c2.stream().unordered(), false, false);
+ assertDoubleConcat(c1.parallelStream().unordered(), c2.stream().unordered(), true, false);
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountLargeTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountLargeTest.java
new file mode 100644
index 0000000..9b87a09
--- /dev/null
+++ b/ojluni/src/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/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountTest.java
new file mode 100644
index 0000000..5bf2876
--- /dev/null
+++ b/ojluni/src/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<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();
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/DistinctOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/DistinctOpTest.java
new file mode 100644
index 0000000..f59a4f3
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/DistinctOpTest.java
@@ -0,0 +1,200 @@
+/*
+ * 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.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Optional;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.stream.CollectorOps;
+import java.util.stream.Collectors;
+import java.util.stream.DoubleStream;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+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;
+
+import static java.util.stream.LambdaTestHelpers.*;
+
+/**
+ * DistinctOpTest
+ */
+@Test
+public class DistinctOpTest extends OpTestCase {
+
+ public void testUniqOp() {
+ assertCountSum(repeat(0, 10).stream().distinct(), 1, 0);
+ assertCountSum(repeat(1, 10).stream().distinct(), 1, 1);
+ assertCountSum(countTo(0).stream().distinct(), 0, 0);
+ assertCountSum(countTo(10).stream().distinct(), 10, 55);
+ assertCountSum(countTo(10).stream().distinct(), 10, 55);
+ }
+
+ public void testWithUnorderedInfiniteStream() {
+ // These tests should short-circuit, otherwise will fail with a time-out
+ // or an OOME
+
+ // Note that since the streams are unordered and any element is requested
+ // (a non-deterministic process) the only assertion that can be made is
+ // that an element should be found
+
+ Optional<Integer> oi = Stream.iterate(1, i -> i + 1).unordered().parallel().distinct().findAny();
+ assertTrue(oi.isPresent());
+
+ oi = ThreadLocalRandom.current().ints().boxed().parallel().distinct().findAny();
+ assertTrue(oi.isPresent());
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testOp(String name, TestData.OfRef<Integer> data) {
+ Collection<Integer> result = exerciseOpsInt(
+ data,
+ Stream::distinct,
+ IntStream::distinct,
+ LongStream::distinct,
+ DoubleStream::distinct);
+
+ assertUnique(result);
+ assertTrue((data.size() > 0) ? result.size() > 0 : result.size() == 0);
+ assertTrue(result.size() <= data.size());
+ }
+
+ @Test(dataProvider = "withNull:StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testOpWithNull(String name, TestData.OfRef<Integer> data) {
+ Collection<Integer> node = exerciseOps(data, Stream::distinct);
+ assertUnique(node);
+
+ node = withData(data).
+ stream(s -> s.unordered().distinct()).
+ exercise();
+ assertUnique(node);
+
+ node = exerciseOps(data, s -> s.distinct().distinct());
+ assertUnique(node);
+ }
+
+ @Test(dataProvider = "withNull:StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testOpWithNullSorted(String name, TestData.OfRef<Integer> data) {
+ ArrayList<Integer> l = new ArrayList<>();
+ data.into(l).sort(cNullInteger);
+ // Need to inject SORTED into the sorted list source since
+ // sorted() with a comparator ironically clears SORTED
+ Collection<Integer> node = exerciseOps(new SortedTestData<>(l), Stream::distinct);
+ assertUnique(node);
+ assertSorted(node, cNullInteger);
+ }
+
+ @SuppressWarnings("serial")
+ static class SortedTestData<T> extends TestData.AbstractTestData.RefTestData<T, List<T>> {
+ SortedTestData(List<T> coll) {
+ super("SortedTestData", coll,
+ c -> StreamSupport.stream(Spliterators.spliterator(c.toArray(), Spliterator.ORDERED | Spliterator.SORTED), false),
+ c -> StreamSupport.stream(Spliterators.spliterator(c.toArray(), Spliterator.ORDERED | Spliterator.SORTED), true),
+ c -> Spliterators.spliterator(c.toArray(), Spliterator.ORDERED | Spliterator.SORTED),
+ List::size);
+ }
+ }
+
+ public static final Comparator<Integer> cNullInteger = (a, b) -> {
+ if (a == null && b == null) {
+ return 0;
+ }
+ else if (a == null) {
+ return -1;
+ }
+ else if (b == null) {
+ return 1;
+ }
+ else {
+ return Integer.compare(a, b);
+ }
+ };
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testDistinctDistinct(String name, TestData.OfRef<Integer> data) {
+ Collection<Integer> result = exerciseOpsInt(
+ data,
+ s -> s.distinct().distinct(),
+ s -> s.distinct().distinct(),
+ s -> s.distinct().distinct(),
+ s -> s.distinct().distinct());
+
+ assertUnique(result);
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testDistinctSorted(String name, TestData.OfRef<Integer> data) {
+ Collection<Integer> result = withData(data)
+ .stream(s -> s.distinct().sorted(),
+ new CollectorOps.TestParallelSizedOp<>())
+ .exercise();
+ assertUnique(result);
+ assertSorted(result);
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testSortedDistinct(String name, TestData.OfRef<Integer> data) {
+ Collection<Integer> result = withData(data)
+ .stream(s -> s.sorted().distinct(),
+ new CollectorOps.TestParallelSizedOp<>())
+ .exercise();
+ assertUnique(result);
+ assertSorted(result);
+ }
+
+ @Test
+ public void testStable() {
+ // Create N instances of Integer all with the same value
+ List<Integer> input = IntStream.rangeClosed(0, 1000)
+ .mapToObj(i -> new Integer(1000)) // explicit construction
+ .collect(Collectors.toList());
+ Integer expectedElement = input.get(0);
+ TestData<Integer, Stream<Integer>> data = TestData.Factory.ofCollection(
+ "1000 instances of Integer with the same value", input);
+
+ withData(data)
+ .stream(Stream::distinct)
+ .resultAsserter((actual, expected, isOrdered, isParallel) -> {
+ List<Integer> l = new ArrayList<>();
+ actual.forEach(l::add);
+
+ // Assert stability
+ // The single result element should be equal in identity to
+ // the first input element
+ assertEquals(l.size(), 1);
+ assertEquals(System.identityHashCode(l.get(0)),
+ System.identityHashCode(expectedElement));
+
+ })
+ .exercise();
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/DoublePrimitiveOpsTests.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/DoublePrimitiveOpsTests.java
new file mode 100644
index 0000000..c476f18
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/DoublePrimitiveOpsTests.java
@@ -0,0 +1,106 @@
+/*
+ * 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 org.openjdk.tests.java.util.stream;
+
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.Random;
+import java.util.stream.DoubleStream;
+import java.util.stream.LongStream;
+
+import static org.testng.Assert.assertEquals;
+
+@Test
+public class DoublePrimitiveOpsTests {
+
+ // @@@ tests for double are fragile if relying on equality when accumulating and multiplying values
+
+ public void testUnBox() {
+ double sum = Arrays.asList(1.0, 2.0, 3.0, 4.0, 5.0).stream().mapToDouble(i -> i).reduce(0.0, Double::sum);
+ assertEquals(sum, 1.0 + 2.0 + 3.0 + 4.0 + 5.0);
+ }
+
+ public void testToArray() {
+ {
+ double[] array = LongStream.range(1, 10).asDoubleStream().map(i -> i * 2).toArray();
+ assertEquals(array, new double[]{2, 4, 6, 8, 10, 12, 14, 16, 18});
+ }
+
+ {
+ double[] array = LongStream.range(1, 10).parallel().asDoubleStream().map(i -> i * 2).toArray();
+ assertEquals(array, new double[]{2, 4, 6, 8, 10, 12, 14, 16, 18});
+ }
+ }
+
+ public void testSort() {
+ Random r = new Random();
+
+ double[] content = DoubleStream.generate(() -> r.nextDouble()).limit(10).toArray();
+ double[] sortedContent = content.clone();
+ Arrays.sort(sortedContent);
+
+ {
+ double[] array = Arrays.stream(content).sorted().toArray();
+ assertEquals(array, sortedContent);
+ }
+
+ {
+ double[] array = Arrays.stream(content).parallel().sorted().toArray();
+ assertEquals(array, sortedContent);
+ }
+ }
+
+ public void testSortSort() {
+ Random r = new Random();
+
+ double[] content = DoubleStream.generate(() -> r.nextDouble()).limit(10).toArray();
+ double[] sortedContent = content.clone();
+ Arrays.sort(sortedContent);
+
+ {
+ double[] array = Arrays.stream(content).sorted().sorted().toArray();
+ assertEquals(array, sortedContent);
+ }
+
+ {
+ double[] array = Arrays.stream(content).parallel().sorted().sorted().toArray();
+ assertEquals(array, sortedContent);
+ }
+ }
+
+ public void testLimit() {
+ double[] expected = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+ {
+ double[] actual = DoubleStream.iterate(1.0, i -> i + 1.0).limit(9).toArray();
+ Assert.assertTrue(Arrays.equals(expected, actual));
+ }
+
+ {
+ double[] actual = LongStream.range(1, 100).parallel().asDoubleStream().limit(9).toArray();
+ Assert.assertTrue(Arrays.equals(expected, actual));
+ }
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ExplodeOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ExplodeOpTest.java
new file mode 100644
index 0000000..cbd9534
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ExplodeOpTest.java
@@ -0,0 +1,119 @@
+/*
+ * 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.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.function.Function;
+import java.util.stream.*;
+
+import static java.util.stream.LambdaTestHelpers.*;
+
+/**
+ * ExplodeOpTest
+ *
+ * @author Brian Goetz
+ */
+@Test
+public class ExplodeOpTest extends OpTestCase {
+
+ static final Function<Integer, Stream<Integer>> integerRangeMapper
+ = e -> IntStream.range(0, e).boxed();
+
+ public void testFlatMap() {
+ String[] stringsArray = {"hello", "there", "", "yada"};
+ Stream<String> strings = Arrays.asList(stringsArray).stream();
+ assertConcat(strings.flatMap(flattenChars).iterator(), "hellothereyada");
+
+ assertCountSum(countTo(10).stream().flatMap(mfId), 10, 55);
+ assertCountSum(countTo(10).stream().flatMap(mfNull), 0, 0);
+ assertCountSum(countTo(3).stream().flatMap(mfLt), 6, 4);
+
+ exerciseOps(TestData.Factory.ofArray("stringsArray", stringsArray), s -> s.flatMap(flattenChars));
+ exerciseOps(TestData.Factory.ofArray("LONG_STRING", new String[] {LONG_STRING}), s -> s.flatMap(flattenChars));
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testOps(String name, TestData.OfRef<Integer> data) {
+ Collection<Integer> result = exerciseOps(data, s -> s.flatMap(mfId));
+ assertEquals(data.size(), result.size());
+
+ result = exerciseOps(data, s -> s.flatMap(mfNull));
+ assertEquals(0, result.size());
+
+ result = exerciseOps(data, s-> s.flatMap(e -> Stream.empty()));
+ assertEquals(0, result.size());
+
+ exerciseOps(data, s -> s.flatMap(mfLt));
+ exerciseOps(data, s -> s.flatMap(integerRangeMapper));
+ exerciseOps(data, s -> s.flatMap((Integer e) -> IntStream.range(0, e).boxed().limit(10)));
+ }
+
+ //
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testIntOps(String name, TestData.OfInt data) {
+ Collection<Integer> result = exerciseOps(data, s -> s.flatMap(i -> Collections.singleton(i).stream().mapToInt(j -> j)));
+ assertEquals(data.size(), result.size());
+ assertContents(data, result);
+
+ result = exerciseOps(data, s -> s.flatMap(i -> IntStream.empty()));
+ assertEquals(0, result.size());
+
+ exerciseOps(data, s -> s.flatMap(e -> IntStream.range(0, e)));
+ exerciseOps(data, s -> s.flatMap(e -> IntStream.range(0, e).limit(10)));
+ }
+
+ //
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testLongOps(String name, TestData.OfLong data) {
+ Collection<Long> result = exerciseOps(data, s -> s.flatMap(i -> Collections.singleton(i).stream().mapToLong(j -> j)));
+ assertEquals(data.size(), result.size());
+ assertContents(data, result);
+
+ result = exerciseOps(data, s -> LongStream.empty());
+ assertEquals(0, result.size());
+
+ exerciseOps(data, s -> s.flatMap(e -> LongStream.range(0, e)));
+ exerciseOps(data, s -> s.flatMap(e -> LongStream.range(0, e).limit(10)));
+ }
+
+ //
+
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testDoubleOps(String name, TestData.OfDouble data) {
+ Collection<Double> result = exerciseOps(data, s -> s.flatMap(i -> Collections.singleton(i).stream().mapToDouble(j -> j)));
+ assertEquals(data.size(), result.size());
+ assertContents(data, result);
+
+ result = exerciseOps(data, s -> DoubleStream.empty());
+ assertEquals(0, result.size());
+
+ exerciseOps(data, s -> s.flatMap(e -> IntStream.range(0, (int) e).asDoubleStream()));
+ exerciseOps(data, s -> s.flatMap(e -> IntStream.range(0, (int) e).limit(10).asDoubleStream()));
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/FilterOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/FilterOpTest.java
new file mode 100644
index 0000000..12ff052
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/FilterOpTest.java
@@ -0,0 +1,109 @@
+/*
+ * 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 java.util.Collection;
+import java.util.stream.*;
+
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+
+import static java.util.stream.LambdaTestHelpers.*;
+
+/**
+ * FilterOpTest
+ *
+ * @author Brian Goetz
+ */
+@Test
+public class FilterOpTest extends OpTestCase {
+ public void testFilter() {
+ assertCountSum(countTo(0).stream().filter(pTrue), 0, 0);
+ assertCountSum(countTo(10).stream().filter(pFalse), 0, 0);
+ assertCountSum(countTo(10).stream().filter(pEven), 5, 30);
+ assertCountSum(countTo(10).stream().filter(pOdd), 5, 25);
+ assertCountSum(countTo(10).stream().filter(pTrue), 10, 55);
+ assertCountSum(countTo(10).stream().filter(pEven).filter(pOdd), 0, 0);
+
+ exerciseOps(countTo(1000), s -> s.filter(pTrue), countTo(1000));
+ exerciseOps(countTo(1000), s -> s.filter(pFalse), countTo(0));
+ exerciseOps(countTo(1000), s -> s.filter(e -> e > 100), range(101, 1000));
+ exerciseOps(countTo(1000), s -> s.filter(e -> e < 100), countTo(99));
+ exerciseOps(countTo(1000), s -> s.filter(e -> e == 100), Arrays.asList(100));
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testOps(String name, TestData.OfRef<Integer> data) {
+ Collection<Integer> result = exerciseOps(data, s -> s.filter(pTrue));
+ assertEquals(result.size(), data.size());
+
+ result = exerciseOps(data, s -> s.filter(pFalse));
+ assertEquals(result.size(), 0);
+
+ exerciseOps(data, s -> s.filter(pEven));
+ exerciseOps(data, s -> s.filter(pOdd));
+
+ result = exerciseOps(data, s -> s.filter(pOdd.and(pEven)));
+ assertEquals(result.size(), 0);
+
+ result = exerciseOps(data, s -> s.filter(pOdd.or(pEven)));
+ assertEquals(result.size(), data.size());
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testOps(String name, TestData.OfInt data) {
+ Collection<Integer> result = exerciseOps(data, s -> s.filter(i -> true));
+ assertEquals(result.size(), data.size());
+
+ result = exerciseOps(data, s -> s.filter(i -> false));
+ assertEquals(result.size(), 0);
+
+ exerciseOps(data, s -> s.filter(i -> 0 == i % 2));
+ exerciseOps(data, s -> s.filter(i -> 1 == i % 2));
+ }
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testOps(String name, TestData.OfLong data) {
+ Collection<Long> result = exerciseOps(data, s -> s.filter(i -> true));
+ assertEquals(result.size(), data.size());
+
+ result = exerciseOps(data, s -> s.filter(i -> false));
+ assertEquals(result.size(), 0);
+
+ exerciseOps(data, s -> s.filter(i -> 0 == i % 2));
+ exerciseOps(data, s -> s.filter(i -> 1 == i % 2));
+ }
+
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testOps(String name, TestData.OfDouble data) {
+ Collection<Double> result = exerciseOps(data, s -> s.filter(i -> true));
+ assertEquals(result.size(), data.size());
+
+ result = exerciseOps(data, s -> s.filter(i -> false));
+ assertEquals(result.size(), 0);
+
+ exerciseOps(data, s -> s.filter(i -> 0 == ((long) i) % 2));
+ exerciseOps(data, s -> s.filter(i -> 1 == ((long) i) % 2));
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/FindAnyOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/FindAnyOpTest.java
new file mode 100644
index 0000000..64a9240
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/FindAnyOpTest.java
@@ -0,0 +1,157 @@
+/*
+ * 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 java.util.*;
+import java.util.function.BiConsumer;
+import java.util.stream.*;
+
+import org.testng.annotations.Test;
+
+import java.util.function.Function;
+
+import static java.util.stream.LambdaTestHelpers.*;
+
+
+/**
+ * FindAnyOpTest
+ */
+@Test
+public class FindAnyOpTest extends OpTestCase {
+
+ public void testFindAny() {
+ assertFalse(Collections.emptySet().stream().findAny().isPresent(), "no result");
+ assertFalse(countTo(10).stream().filter(x -> x > 10).findAny().isPresent(), "no result");
+ assertTrue(countTo(10).stream().filter(pEven).findAny().isPresent(), "with result");
+ }
+
+ public void testFindAnyParallel() {
+ assertFalse(Collections.emptySet().parallelStream().findAny().isPresent(), "no result");
+ assertFalse(countTo(1000).parallelStream().filter(x -> x > 1000).findAny().isPresent(), "no result");
+ assertTrue(countTo(1000).parallelStream().filter(pEven).findAny().isPresent(), "with result");
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testStream(String name, TestData.OfRef<Integer> data) {
+ exerciseStream(data, s -> s);
+ exerciseStream(data, s -> s.filter(pTrue));
+ exerciseStream(data, s -> s.filter(pFalse));
+ exerciseStream(data, s -> s.filter(pEven));
+ }
+
+ void exerciseStream(TestData.OfRef<Integer> data, Function<Stream<Integer>, Stream<Integer>> fs) {
+ Optional<Integer> or = withData(data).terminal(fs, s -> s.findAny()).equalator(VALID_ANSWER).exercise();
+ if (or.isPresent()) {
+ Integer r = or.get();
+ Iterator<Integer> it = fs.apply(data.stream()).iterator();
+ boolean contained = false;
+ while (!contained && it.hasNext()) {
+ contained = Objects.equals(r, it.next());
+ }
+ assertTrue(contained);
+ }
+ else {
+ assertFalse(fs.apply(data.stream()).iterator().hasNext());
+ }
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testIntStream(String name, TestData.OfInt data) {
+ exerciseIntStream(data, s -> s);
+ exerciseIntStream(data, s -> s.filter(ipTrue));
+ exerciseIntStream(data, s -> s.filter(ipFalse));
+ exerciseIntStream(data, s -> s.filter(ipEven));
+ }
+
+ void exerciseIntStream(TestData.OfInt data, Function<IntStream, IntStream> fs) {
+ OptionalInt or = withData(data).terminal(fs, s -> s.findAny()).equalator(INT_VALID_ANSWER).exercise();
+ if (or.isPresent()) {
+ int r = or.getAsInt();
+ PrimitiveIterator.OfInt it = fs.apply(data.stream()).iterator();
+ boolean contained = false;
+ while (!contained && it.hasNext()) {
+ contained = r == it.nextInt();
+ }
+ assertTrue(contained);
+ }
+ else {
+ assertFalse(fs.apply(data.stream()).iterator().hasNext());
+ }
+ }
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testLongStream(String name, TestData.OfLong data) {
+ exerciseLongStream(data, s -> s);
+ exerciseLongStream(data, s -> s.filter(lpTrue));
+ exerciseLongStream(data, s -> s.filter(lpFalse));
+ exerciseLongStream(data, s -> s.filter(lpEven));
+ }
+
+ void exerciseLongStream(TestData.OfLong data, Function<LongStream, LongStream> fs) {
+ OptionalLong or = withData(data).terminal(fs, s -> s.findAny()).equalator(LONG_VALID_ANSWER).exercise();
+ if (or.isPresent()) {
+ long r = or.getAsLong();
+ PrimitiveIterator.OfLong it = fs.apply(data.stream()).iterator();
+ boolean contained = false;
+ while (!contained && it.hasNext()) {
+ contained = r == it.nextLong();
+ }
+ assertTrue(contained);
+ }
+ else {
+ assertFalse(fs.apply(data.stream()).iterator().hasNext());
+ }
+ }
+
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testDoubleStream(String name, TestData.OfDouble data) {
+ exerciseDoubleStream(data, s -> s);
+ exerciseDoubleStream(data, s -> s.filter(dpTrue));
+ exerciseDoubleStream(data, s -> s.filter(dpEven));
+ exerciseDoubleStream(data, s -> s.filter(dpFalse));
+ }
+
+ void exerciseDoubleStream(TestData.OfDouble data, Function<DoubleStream, DoubleStream> fs) {
+ OptionalDouble or = withData(data).terminal(fs, s -> s.findAny()).equalator(DOUBLE_VALID_ANSWER).exercise();
+ if (or.isPresent()) {
+ double r = or.getAsDouble();
+ PrimitiveIterator.OfDouble it = fs.apply(data.stream()).iterator();
+ boolean contained = false;
+ while (!contained && it.hasNext()) {
+ contained = r == it.nextDouble();
+ }
+ assertTrue(contained);
+ }
+ else {
+ assertFalse(fs.apply(data.stream()).iterator().hasNext());
+ }
+ }
+
+ static final BiConsumer<Optional<Integer>, Optional<Integer>> VALID_ANSWER = (a, b) -> assertEquals(a.isPresent(), b.isPresent());
+
+ static final BiConsumer<OptionalInt, OptionalInt> INT_VALID_ANSWER = (a, b) -> assertEquals(a.isPresent(), b.isPresent());
+
+ static final BiConsumer<OptionalLong, OptionalLong> LONG_VALID_ANSWER = (a, b) -> assertEquals(a.isPresent(), b.isPresent());
+
+ static final BiConsumer<OptionalDouble, OptionalDouble> DOUBLE_VALID_ANSWER = (a, b) -> assertEquals(a.isPresent(), b.isPresent());
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/FindFirstOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/FindFirstOpTest.java
new file mode 100644
index 0000000..02e3d07
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/FindFirstOpTest.java
@@ -0,0 +1,132 @@
+/*
+ * 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 java.util.*;
+import java.util.stream.*;
+
+import org.testng.annotations.Test;
+
+import java.util.function.Function;
+
+import static java.util.stream.LambdaTestHelpers.*;
+
+
+/**
+ * FindFirstOpTest
+ */
+@Test
+public class FindFirstOpTest extends OpTestCase {
+
+ public void testFindFirst() {
+ assertFalse(Collections.emptySet().stream().findFirst().isPresent(), "no result");
+ assertFalse(countTo(10).stream().filter(x -> x > 10).findFirst().isPresent(), "no result");
+
+ exerciseOps(countTo(1000), s -> Arrays.asList(new Integer[]{s.filter(pEven).findFirst().get()}).stream(), Arrays.asList(2));
+ exerciseOps(countTo(1000), s -> Arrays.asList(new Integer[]{s.findFirst().get()}).stream(), Arrays.asList(1));
+ exerciseOps(countTo(1000), s -> Arrays.asList(new Integer[]{s.filter(e -> e == 499).findFirst().get()}).stream(), Arrays.asList(499));
+ exerciseOps(countTo(1000), s -> Arrays.asList(new Integer[]{s.filter(e -> e == 999).findFirst().get()}).stream(), Arrays.asList(999));
+ exerciseOps(countTo(0), s -> Arrays.asList(new Integer[]{s.findFirst().orElse(-1)}).stream(), Arrays.asList(-1));
+ exerciseOps(countTo(1000), s -> Arrays.asList(new Integer[]{s.filter(e -> e == 1499).findFirst().orElse(-1)}).stream(), Arrays.asList(-1));
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testStream(String name, TestData.OfRef<Integer> data) {
+ exerciseStream(data, s -> s);
+ exerciseStream(data, s -> s.filter(pTrue));
+ exerciseStream(data, s -> s.filter(pFalse));
+ exerciseStream(data, s -> s.filter(pEven));
+ }
+
+ void exerciseStream(TestData.OfRef<Integer> data, Function<Stream<Integer>, Stream<Integer>> fs) {
+ Optional<Integer> r = exerciseTerminalOps(data, fs, s -> s.findFirst());
+ if (r.isPresent()) {
+ Iterator<Integer> i = fs.apply(data.stream()).iterator();
+ assertTrue(i.hasNext());
+ assertEquals(i.next(), r.get());
+ }
+ else {
+ assertFalse(fs.apply(data.stream()).iterator().hasNext());
+ }
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testIntStream(String name, TestData.OfInt data) {
+ exerciseIntStream(data, s -> s);
+ exerciseIntStream(data, s -> s.filter(ipTrue));
+ exerciseIntStream(data, s -> s.filter(ipFalse));
+ exerciseIntStream(data, s -> s.filter(ipEven));
+ }
+
+ void exerciseIntStream(TestData.OfInt data, Function<IntStream, IntStream> fs) {
+ OptionalInt r = exerciseTerminalOps(data, fs, s -> s.findFirst());
+ if (r.isPresent()) {
+ PrimitiveIterator.OfInt i = fs.apply(data.stream()).iterator();
+ assertTrue(i.hasNext());
+ assertEquals(i.nextInt(), r.getAsInt());
+ }
+ else {
+ assertFalse(fs.apply(data.stream()).iterator().hasNext());
+ }
+ }
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testLongStream(String name, TestData.OfLong data) {
+ exerciseLongStream(data, s -> s);
+ exerciseLongStream(data, s -> s.filter(lpTrue));
+ exerciseLongStream(data, s -> s.filter(lpFalse));
+ exerciseLongStream(data, s -> s.filter(lpEven));
+ }
+
+ void exerciseLongStream(TestData.OfLong data, Function<LongStream, LongStream> fs) {
+ OptionalLong r = exerciseTerminalOps(data, fs, s -> s.findFirst());
+ if (r.isPresent()) {
+ PrimitiveIterator.OfLong i = fs.apply(data.stream()).iterator();
+ assertTrue(i.hasNext());
+ assertEquals(i.nextLong(), r.getAsLong());
+ }
+ else {
+ assertFalse(fs.apply(data.stream()).iterator().hasNext());
+ }
+ }
+
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testDoubleStream(String name, TestData.OfDouble data) {
+ exerciseDoubleStream(data, s -> s);
+ exerciseDoubleStream(data, s -> s.filter(dpTrue));
+ exerciseDoubleStream(data, s -> s.filter(dpFalse));
+ exerciseDoubleStream(data, s -> s.filter(dpEven));
+ }
+
+ void exerciseDoubleStream(TestData.OfDouble data, Function<DoubleStream, DoubleStream> fs) {
+ OptionalDouble r = exerciseTerminalOps(data, fs, s -> s.findFirst());
+ if (r.isPresent()) {
+ PrimitiveIterator.OfDouble i = fs.apply(data.stream()).iterator();
+ assertTrue(i.hasNext());
+ assertEquals(i.nextDouble(), r.getAsDouble());
+ }
+ else {
+ assertFalse(fs.apply(data.stream()).iterator().hasNext());
+ }
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ForEachOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ForEachOpTest.java
new file mode 100644
index 0000000..e7337e6
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ForEachOpTest.java
@@ -0,0 +1,261 @@
+/*
+ * 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.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+import java.util.stream.*;
+
+import static java.util.stream.LambdaTestHelpers.countTo;
+
+/**
+ * ForEachOpTest
+ */
+@Test
+public class ForEachOpTest extends OpTestCase {
+
+ @Test(groups = { "serialization-hostile" })
+ public void testForEach() {
+ exerciseTerminalOps(countTo(10),
+ s -> {
+ AtomicInteger count = new AtomicInteger(0);
+ s.forEach(e -> count.incrementAndGet());
+ return count.get();
+ },
+ 10);
+
+ exerciseTerminalOps(countTo(10),
+ s -> {
+ AtomicInteger sum = new AtomicInteger(0);
+ s.forEach(sum::addAndGet);
+ return sum.get();
+ },
+ 55);
+ }
+
+ private <U> ResultAsserter<List<U>> resultAsserter() {
+ return (act, exp, ord, par) -> {
+ if (par) {
+ LambdaTestHelpers.assertContentsUnordered(act, exp);
+ }
+ else {
+ LambdaTestHelpers.assertContents(act, exp);
+ }
+ };
+ }
+
+ @Test(groups = { "serialization-hostile" })
+ public void testForEachOrdered() {
+ List<Integer> input = countTo(10000);
+ TestData.OfRef<Integer> data = TestData.Factory.ofCollection("[1, 10000]", input);
+
+ Function<Stream<Integer>, List<Integer>> terminalFunc = s -> {
+ List<Integer> l = new ArrayList<>();
+ s.forEachOrdered(l::add);
+ return l;
+ };
+
+ // Test head
+ withData(data).
+ terminal(terminalFunc).
+ expectedResult(input).
+ exercise();
+
+ // Test multiple stages
+ withData(data).
+ terminal(s -> s.map(LambdaTestHelpers.identity()), terminalFunc).
+ expectedResult(input).
+ exercise();
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testForEach(String name, TestData.OfRef<Integer> data) {
+ Function<Stream<Integer>, List<Integer>> terminalFunc = s -> {
+ List<Integer> l = Collections.synchronizedList(new ArrayList<>());
+ s.forEach(l::add);
+ return l;
+ };
+
+ // Test head
+ withData(data).
+ terminal(terminalFunc).
+ resultAsserter(resultAsserter()).
+ exercise();
+
+ // Test multiple stages
+ withData(data).
+ terminal(s -> s.map(LambdaTestHelpers.identity()), terminalFunc).
+ resultAsserter(resultAsserter()).
+ exercise();
+ }
+
+ //
+
+ @Test(groups = { "serialization-hostile" })
+ public void testIntForEachOrdered() {
+ List<Integer> input = countTo(10000);
+ TestData.OfInt data = TestData.Factory.ofIntSupplier("[1, 10000]",
+ () -> IntStream.range(1, 10001));
+
+ Function<IntStream, List<Integer>> terminalFunc = s -> {
+ List<Integer> l = new ArrayList<>();
+ s.forEachOrdered(l::add);
+ return l;
+ };
+
+ // Test head
+ withData(data).
+ terminal(terminalFunc).
+ expectedResult(input).
+ exercise();
+
+ // Test multiple stages
+ withData(data).
+ terminal(s -> s.map(i -> i), terminalFunc).
+ expectedResult(input).
+ exercise();
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testIntForEach(String name, TestData.OfInt data) {
+ Function<IntStream, List<Integer>> terminalFunc = s -> {
+ List<Integer> l = Collections.synchronizedList(new ArrayList<Integer>());
+ s.forEach(l::add);
+ return l;
+ };
+
+ // Test head
+ withData(data).
+ terminal(terminalFunc).
+ resultAsserter(resultAsserter()).
+ exercise();
+
+ // Test multiple stages
+ withData(data).
+ terminal(s -> s.map(i -> i), terminalFunc).
+ resultAsserter(resultAsserter()).
+ exercise();
+ }
+
+ //
+
+ @Test(groups = { "serialization-hostile" })
+ public void testLongForEachOrdered() {
+ List<Integer> input = countTo(10000);
+ TestData.OfLong data = TestData.Factory.ofLongSupplier("[1, 10000]",
+ () -> LongStream.range(1, 10001));
+
+ Function<LongStream, List<Integer>> terminalFunc = s -> {
+ List<Integer> l = new ArrayList<>();
+ s.forEachOrdered(e -> l.add((int) e));
+ return l;
+ };
+
+ // Test head
+ withData(data).
+ terminal(terminalFunc).
+ expectedResult(input).
+ exercise();
+
+ // Test multiple stages
+ withData(data).
+ terminal(s -> s.map(i -> i), terminalFunc).
+ expectedResult(input).
+ exercise();
+ }
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testLongOps(String name, TestData.OfLong data) {
+ Function<LongStream, List<Long>> terminalFunc = s -> {
+ List<Long> l = Collections.synchronizedList(new ArrayList<Long>());
+ s.forEach(l::add);
+ return l;
+ };
+
+ // Test head
+ withData(data).
+ terminal(terminalFunc).
+ resultAsserter(resultAsserter()).
+ exercise();
+
+ // Test multiple stages
+ withData(data).
+ terminal(s -> s.map(i -> i), terminalFunc).
+ resultAsserter(resultAsserter()).
+ exercise();
+ }
+
+ //
+
+ @Test(groups = { "serialization-hostile" })
+ public void testDoubleForEachOrdered() {
+ List<Integer> input = countTo(10000);
+ TestData.OfDouble data = TestData.Factory.ofDoubleSupplier("[1, 10000]",
+ () -> IntStream.range(1, 10001).asDoubleStream());
+
+ Function<DoubleStream, List<Integer>> terminalFunc = s -> {
+ List<Integer> l = new ArrayList<>();
+ s.forEachOrdered(e -> l.add((int) e));
+ return l;
+ };
+
+ // Test head
+ withData(data).
+ terminal(terminalFunc).
+ expectedResult(input).
+ exercise();
+
+ // Test multiple stages
+ withData(data).
+ terminal(s -> s.map(i -> i), terminalFunc).
+ expectedResult(input).
+ exercise();
+ }
+
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testDoubleOps(String name, TestData.OfDouble data) {
+ Function<DoubleStream, List<Double>> terminalFunc = s -> {
+ List<Double> l = Collections.synchronizedList(new ArrayList<Double>());
+ s.forEach(l::add);
+ return l;
+ };
+
+ // Test head
+ withData(data).
+ terminal(terminalFunc).
+ resultAsserter(resultAsserter()).
+ exercise();
+
+ // Test multiple stages
+ withData(data).
+ terminal(s -> s.map(i -> i), terminalFunc).
+ resultAsserter(resultAsserter()).
+ exercise();
+ }
+
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/GroupByOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/GroupByOpTest.java
new file mode 100644
index 0000000..dc9e197
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/GroupByOpTest.java
@@ -0,0 +1,173 @@
+/*
+ * 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 java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
+import java.util.stream.LambdaTestHelpers;
+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;
+
+import static java.util.stream.LambdaTestHelpers.countTo;
+import static java.util.stream.LambdaTestHelpers.mDoubler;
+import static java.util.stream.LambdaTestHelpers.mId;
+import static java.util.stream.LambdaTestHelpers.mZero;
+import static java.util.stream.LambdaTestHelpers.pEven;
+import static java.util.stream.LambdaTestHelpers.pFalse;
+import static java.util.stream.LambdaTestHelpers.pOdd;
+import static java.util.stream.LambdaTestHelpers.pTrue;
+
+/**
+ * GroupByOpTest
+ *
+ */
+@Test
+public class GroupByOpTest extends OpTestCase {
+
+ public void testBypassCollect() {
+ @SuppressWarnings("unchecked")
+ Collector<Integer, Map<Boolean, List<Integer>>, Map<Boolean, List<Integer>>> collector
+ = (Collector<Integer, Map<Boolean, List<Integer>>, Map<Boolean, List<Integer>>>) Collectors.groupingBy(LambdaTestHelpers.forPredicate(pEven, true, false));
+
+ Map<Boolean, List<Integer>> m = collector.supplier().get();
+ int[] ints = countTo(10).stream().mapToInt(e -> (int) e).toArray();
+ for (int i : ints)
+ collector.accumulator().accept(m, i);
+
+ assertEquals(2, m.keySet().size());
+ for(Collection<Integer> group : m.values()) {
+ int count = 0;
+ Stream<Integer> stream = group.stream();
+ Iterator<Integer> it = stream.iterator();
+ while (it.hasNext()) {
+ it.next();
+ ++count;
+ }
+ assertEquals(5, count);
+ }
+ }
+
+ public void testGroupBy() {
+ Map<Boolean,List<Integer>> result = countTo(10).stream().collect(Collectors.groupingBy(LambdaTestHelpers.forPredicate(pEven, true, false)));
+
+ assertEquals(2, result.keySet().size());
+ for(Collection<Integer> group : result.values()) {
+ int count = 0;
+ Stream<Integer> stream = group.stream();
+ Iterator<Integer> it = stream.iterator();
+ while (it.hasNext()) {
+ it.next();
+ ++count;
+ }
+ assertEquals(5, count);
+ }
+ }
+
+ static class MapperData<T, K> {
+ Function<T, K> m;
+ int expectedSize;
+
+ MapperData(Function<T, K> m, int expectedSize) {
+ this.m = m;
+ this.expectedSize = expectedSize;
+ }
+ }
+
+ List<MapperData<Integer, ?>> getMapperData(TestData.OfRef<Integer> data) {
+ int uniqueSize = data.into(new HashSet<>()).size();
+
+ return Arrays.asList(
+ new MapperData<>(mId, uniqueSize),
+ new MapperData<>(mZero, Math.min(1, data.size())),
+ new MapperData<>(mDoubler, uniqueSize),
+ new MapperData<>(LambdaTestHelpers.compose(mId, mDoubler), uniqueSize),
+ new MapperData<>(LambdaTestHelpers.compose(mDoubler, mDoubler), uniqueSize),
+
+ new MapperData<>(LambdaTestHelpers.forPredicate(pFalse, true, false), Math.min(1, uniqueSize)),
+ new MapperData<>(LambdaTestHelpers.forPredicate(pTrue, true, false), Math.min(1, uniqueSize)),
+ new MapperData<>(LambdaTestHelpers.forPredicate(pEven, true, false), Math.min(2, uniqueSize)),
+ new MapperData<>(LambdaTestHelpers.forPredicate(pOdd, true, false), Math.min(2, uniqueSize))
+ );
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testOps(String name, TestData.OfRef<Integer> data) {
+ // @@@ More things to test here:
+ // - Every value in data is present in right bucket
+ // - Total number of values equals size of data
+
+ for (MapperData<Integer, ?> md : getMapperData(data)) {
+ Collector<Integer, ?, Map<Object, List<Integer>>> tab = Collectors.groupingBy(md.m);
+ Map<Object, List<Integer>> result =
+ withData(data)
+ .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);
+ }
+ }
+
+ static void assertObjectEquals(Object a, Object b) {
+ assertTrue(Objects.equals(a, b));
+ }
+
+ static <K, V> void assertMultiMapEquals(Map<K, ? extends Collection<V>> a, Map<K, ? extends Collection<V>> b) {
+ assertTrue(multiMapEquals(a, b));
+ }
+
+ static<K, V> boolean multiMapEquals(Map<K, ? extends Collection<V>> a, Map<K, ? extends Collection<V>> b) {
+ if (!Objects.equals(a.keySet(), b.keySet())) {
+ return false;
+ }
+
+ for (K k : a.keySet()) {
+ Set<V> as = new HashSet<>(a.get(k));
+ Set<V> bs = new HashSet<>(b.get(k));
+ if (!Objects.equals(as, bs)) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest.java
new file mode 100644
index 0000000..61f2e29
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest.java
@@ -0,0 +1,453 @@
+/*
+ * Copyright (c) 2012, 2015, 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.DataProvider;
+import org.testng.annotations.Test;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Spliterator;
+import java.util.function.Function;
+import java.util.function.UnaryOperator;
+import java.util.stream.DoubleStream;
+import java.util.stream.DoubleStreamTestScenario;
+import java.util.stream.IntStream;
+import java.util.stream.IntStreamTestScenario;
+import java.util.stream.LambdaTestHelpers;
+import java.util.stream.LongStream;
+import java.util.stream.LongStreamTestScenario;
+import java.util.stream.OpTestCase;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+import java.util.stream.StreamTestScenario;
+import java.util.stream.TestData;
+
+import static java.util.stream.LambdaTestHelpers.assertUnique;
+
+
+@Test
+public class InfiniteStreamWithLimitOpTest extends OpTestCase {
+
+ private static final long SKIP_LIMIT_SIZE = 1 << 16;
+
+ @DataProvider(name = "Stream.limit")
+ @SuppressWarnings("rawtypes")
+ public static Object[][] sliceFunctionsDataProvider() {
+ Function<String, String> f = s -> String.format(s, SKIP_LIMIT_SIZE);
+
+ List<Object[]> data = new ArrayList<>();
+
+ data.add(new Object[]{f.apply("Stream.limit(%d)"),
+ (UnaryOperator<Stream>) s -> s.limit(SKIP_LIMIT_SIZE)});
+ data.add(new Object[]{f.apply("Stream.skip(%1$d).limit(%1$d)"),
+ (UnaryOperator<Stream>) s -> s.skip(SKIP_LIMIT_SIZE).limit(SKIP_LIMIT_SIZE)});
+
+ return data.toArray(new Object[0][]);
+ }
+
+ @DataProvider(name = "IntStream.limit")
+ public static Object[][] intSliceFunctionsDataProvider() {
+ Function<String, String> f = s -> String.format(s, SKIP_LIMIT_SIZE);
+
+ List<Object[]> data = new ArrayList<>();
+
+ data.add(new Object[]{f.apply("IntStream.limit(%d)"),
+ (UnaryOperator<IntStream>) s -> s.limit(SKIP_LIMIT_SIZE)});
+ data.add(new Object[]{f.apply("IntStream.skip(%1$d).limit(%1$d)"),
+ (UnaryOperator<IntStream>) s -> s.skip(SKIP_LIMIT_SIZE).limit(SKIP_LIMIT_SIZE)});
+
+ return data.toArray(new Object[0][]);
+ }
+
+ @DataProvider(name = "LongStream.limit")
+ public static Object[][] longSliceFunctionsDataProvider() {
+ Function<String, String> f = s -> String.format(s, SKIP_LIMIT_SIZE);
+
+ List<Object[]> data = new ArrayList<>();
+
+ data.add(new Object[]{f.apply("LongStream.limit(%d)"),
+ (UnaryOperator<LongStream>) s -> s.limit(SKIP_LIMIT_SIZE)});
+ data.add(new Object[]{f.apply("LongStream.skip(%1$d).limit(%1$d)"),
+ (UnaryOperator<LongStream>) s -> s.skip(SKIP_LIMIT_SIZE).limit(SKIP_LIMIT_SIZE)});
+
+ return data.toArray(new Object[0][]);
+ }
+
+ @DataProvider(name = "DoubleStream.limit")
+ public static Object[][] doubleSliceFunctionsDataProvider() {
+ Function<String, String> f = s -> String.format(s, SKIP_LIMIT_SIZE);
+
+ List<Object[]> data = new ArrayList<>();
+
+ data.add(new Object[]{f.apply("DoubleStream.limit(%d)"),
+ (UnaryOperator<DoubleStream>) s -> s.limit(SKIP_LIMIT_SIZE)});
+ data.add(new Object[]{f.apply("DoubleStream.skip(%1$d).limit(%1$d)"),
+ (UnaryOperator<DoubleStream>) s -> s.skip(SKIP_LIMIT_SIZE).limit(SKIP_LIMIT_SIZE)});
+
+ return data.toArray(new Object[0][]);
+ }
+
+ private <T> ResultAsserter<Iterable<T>> unorderedAsserter() {
+ return (act, exp, ord, par) -> {
+ if (par & !ord) {
+ // Can only assert that all elements of the actual result
+ // are distinct and that the count is the limit size
+ // any element within the range [0, Long.MAX_VALUE) may be
+ // present
+ assertUnique(act);
+ long count = 0;
+ for (T l : act) {
+ count++;
+ }
+ assertEquals(count, SKIP_LIMIT_SIZE, "size not equal");
+ }
+ else {
+ LambdaTestHelpers.assertContents(act, exp);
+ }
+ };
+ }
+
+ private TestData.OfRef<Long> refLongs() {
+ return refLongRange(0, Long.MAX_VALUE);
+ }
+
+ private TestData.OfRef<Long> refLongRange(long l, long u) {
+ return TestData.Factory.ofSupplier(
+ String.format("[%d, %d)", l, u),
+ () -> LongStream.range(l, u).boxed());
+ }
+
+ private TestData.OfInt ints() {
+ return intRange(0, Integer.MAX_VALUE);
+ }
+
+ private TestData.OfInt intRange(int l, int u) {
+ return TestData.Factory.ofIntSupplier(
+ String.format("[%d, %d)", l, u),
+ () -> IntStream.range(l, u));
+ }
+
+ private TestData.OfLong longs() {
+ return longRange(0, Long.MAX_VALUE);
+ }
+
+ private TestData.OfLong longRange(long l, long u) {
+ return TestData.Factory.ofLongSupplier(
+ String.format("[%d, %d)", l, u),
+ () -> LongStream.range(l, u));
+ }
+
+ private TestData.OfDouble doubles() {
+ return doubleRange(0, 1L << 53);
+ }
+
+ private TestData.OfDouble doubleRange(long l, long u) {
+ return TestData.Factory.ofDoubleSupplier(
+ String.format("[%d, %d)", l, u),
+ () -> LongStream.range(l, u).mapToDouble(i -> (double) i));
+ }
+
+
+ // Sized/subsized range
+
+ @Test(dataProvider = "Stream.limit")
+ public void testSubsizedWithRange(String description, UnaryOperator<Stream<Long>> fs) {
+ // Range is [0, Long.MAX_VALUE), splits are SUBSIZED
+ // Such a size will induce out of memory errors for incorrect
+ // slice implementations
+ withData(refLongs()).
+ stream(s -> fs.apply(s)).
+ without(StreamTestScenario.CLEAR_SIZED_SCENARIOS).
+ exercise();
+ }
+
+ @Test(dataProvider = "IntStream.limit")
+ public void testIntSubsizedWithRange(String description, UnaryOperator<IntStream> fs) {
+ // Range is [0, Integer.MAX_VALUE), splits are SUBSIZED
+ // Such a size will induce out of memory errors for incorrect
+ // slice implementations
+ withData(ints()).
+ stream(s -> fs.apply(s)).
+ without(IntStreamTestScenario.CLEAR_SIZED_SCENARIOS).
+ exercise();
+ }
+
+ @Test(dataProvider = "LongStream.limit")
+ public void testLongSubsizedWithRange(String description, UnaryOperator<LongStream> fs) {
+ // Range is [0, Long.MAX_VALUE), splits are SUBSIZED
+ // Such a size will induce out of memory errors for incorrect
+ // slice implementations
+ withData(longs()).
+ stream(s -> fs.apply(s)).
+ without(LongStreamTestScenario.CLEAR_SIZED_SCENARIOS).
+ exercise();
+ }
+
+ @Test(dataProvider = "DoubleStream.limit")
+ public void testDoubleSubsizedWithRange(String description, UnaryOperator<DoubleStream> fs) {
+ // Range is [0, 2^53), splits are SUBSIZED
+ // Such a size will induce out of memory errors for incorrect
+ // slice implementations
+ withData(doubles()).
+ stream(s -> fs.apply(s)).
+ without(DoubleStreamTestScenario.CLEAR_SIZED_SCENARIOS).
+ exercise();
+ }
+
+
+ // Unordered finite not SIZED/SUBSIZED
+
+ @Test(dataProvider = "Stream.limit")
+ public void testUnorderedFinite(String description, UnaryOperator<Stream<Long>> fs) {
+ // Range is [0, Long.MAX_VALUE), splits are SUBSIZED
+ // Such a size will induce out of memory errors for incorrect
+ // slice implementations
+ withData(longs()).
+ stream(s -> fs.apply(s.filter(i -> true).unordered().boxed())).
+ resultAsserter(unorderedAsserter()).
+ exercise();
+ }
+
+ @Test(dataProvider = "IntStream.limit")
+ public void testIntUnorderedFinite(String description, UnaryOperator<IntStream> fs) {
+ // Range is [0, Integer.MAX_VALUE), splits are SUBSIZED
+ // Such a size will induce out of memory errors for incorrect
+ // slice implementations
+ withData(ints()).
+ stream(s -> fs.apply(s.filter(i -> true).unordered())).
+ resultAsserter(unorderedAsserter()).
+ exercise();
+ }
+
+ @Test(dataProvider = "LongStream.limit")
+ public void testLongUnorderedFinite(String description, UnaryOperator<LongStream> fs) {
+ // Range is [0, Long.MAX_VALUE), splits are SUBSIZED
+ // Such a size will induce out of memory errors for incorrect
+ // slice implementations
+ withData(longs()).
+ stream(s -> fs.apply(s.filter(i -> true).unordered())).
+ resultAsserter(unorderedAsserter()).
+ exercise();
+ }
+
+ @Test(dataProvider = "DoubleStream.limit")
+ public void testDoubleUnorderedFinite(String description, UnaryOperator<DoubleStream> fs) {
+ // Range is [0, 1L << 53), splits are SUBSIZED
+ // Such a size will induce out of memory errors for incorrect
+ // slice implementations
+ // Upper bound ensures values mapped to doubles will be unique
+ withData(doubles()).
+ stream(s -> fs.apply(s.filter(i -> true).unordered())).
+ resultAsserter(unorderedAsserter()).
+ exercise();
+ }
+
+
+ // Unordered finite not SUBSIZED
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ private Spliterator.OfLong proxyNotSubsized(Spliterator.OfLong s) {
+ InvocationHandler ih = new InvocationHandler() {
+ @Override
+ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+ switch (method.getName()) {
+ case "characteristics": {
+ int c = (Integer) method.invoke(s, args);
+ return c & ~Spliterator.SUBSIZED;
+ }
+ case "hasCharacteristics": {
+ int c = (Integer) args[0];
+ boolean b = (Boolean) method.invoke(s, args);
+ return b & ((c & Spliterator.SUBSIZED) == 0);
+ }
+ default:
+ return method.invoke(s, args);
+ }
+ }
+ };
+
+ return (Spliterator.OfLong) Proxy.newProxyInstance(this.getClass().getClassLoader(),
+ new Class[]{Spliterator.OfLong.class},
+ ih);
+ }
+
+ private TestData.OfLong proxiedLongRange(long l, long u) {
+ return TestData.Factory.ofLongSupplier(
+ String.format("[%d, %d)", l, u),
+ () -> StreamSupport.longStream(proxyNotSubsized(LongStream.range(l, u).spliterator()), false));
+ }
+
+ @Test(dataProvider = "Stream.limit")
+ public void testUnorderedSizedNotSubsizedFinite(String description, UnaryOperator<Stream<Long>> fs) {
+ // Range is [0, Long.MAX_VALUE), splits are not SUBSIZED (proxy clears
+ // the SUBSIZED characteristic)
+ // Such a size will induce out of memory errors for incorrect
+ // slice implementations
+ withData(proxiedLongRange(0, Long.MAX_VALUE)).
+ stream(s -> fs.apply(s.unordered().boxed())).
+ resultAsserter(unorderedAsserter()).
+ exercise();
+ }
+
+ @Test(dataProvider = "IntStream.limit")
+ public void testIntUnorderedSizedNotSubsizedFinite(String description, UnaryOperator<IntStream> fs) {
+ // Range is [0, Integer.MAX_VALUE), splits are not SUBSIZED (proxy clears
+ // the SUBSIZED characteristic)
+ // Such a size will induce out of memory errors for incorrect
+ // slice implementations
+ withData(proxiedLongRange(0, Integer.MAX_VALUE)).
+ stream(s -> fs.apply(s.unordered().mapToInt(i -> (int) i))).
+ resultAsserter(unorderedAsserter()).
+ exercise();
+ }
+
+ @Test(dataProvider = "LongStream.limit")
+ public void testLongUnorderedSizedNotSubsizedFinite(String description, UnaryOperator<LongStream> fs) {
+ // Range is [0, Long.MAX_VALUE), splits are not SUBSIZED (proxy clears
+ // the SUBSIZED characteristic)
+ // Such a size will induce out of memory errors for incorrect
+ // slice implementations
+ withData(proxiedLongRange(0, Long.MAX_VALUE)).
+ stream(s -> fs.apply(s.unordered())).
+ resultAsserter(unorderedAsserter()).
+ exercise();
+ }
+
+ @Test(dataProvider = "DoubleStream.limit")
+ public void testDoubleUnorderedSizedNotSubsizedFinite(String description, UnaryOperator<DoubleStream> fs) {
+ // Range is [0, Double.MAX_VALUE), splits are not SUBSIZED (proxy clears
+ // the SUBSIZED characteristic)
+ // Such a size will induce out of memory errors for incorrect
+ // slice implementations
+ withData(proxiedLongRange(0, 1L << 53)).
+ stream(s -> fs.apply(s.unordered().mapToDouble(i -> (double) i))).
+ resultAsserter(unorderedAsserter()).
+ exercise();
+ }
+
+
+ // Unordered generation
+
+ @Test(dataProvider = "Stream.limit")
+ public void testUnorderedGenerator(String description, UnaryOperator<Stream<Long>> fs) {
+ // Source is spliterator of infinite size
+ TestData.OfRef<Long> generator = TestData.Factory.ofSupplier(
+ "[1L, 1L, ...]", () -> Stream.generate(() -> 1L));
+
+ withData(generator).
+ stream(s -> fs.apply(s.filter(i -> true).unordered())).
+ exercise();
+ }
+
+ @Test(dataProvider = "IntStream.limit")
+ public void testIntUnorderedGenerator(String description, UnaryOperator<IntStream> fs) {
+ // Source is spliterator of infinite size
+ TestData.OfInt generator = TestData.Factory.ofIntSupplier(
+ "[1, 1, ...]", () -> IntStream.generate(() -> 1));
+
+ withData(generator).
+ stream(s -> fs.apply(s.filter(i -> true).unordered())).
+ exercise();
+ }
+
+ @Test(dataProvider = "LongStream.limit")
+ public void testLongUnorderedGenerator(String description, UnaryOperator<LongStream> fs) {
+ // Source is spliterator of infinite size
+ TestData.OfLong generator = TestData.Factory.ofLongSupplier(
+ "[1L, 1L, ...]", () -> LongStream.generate(() -> 1));
+
+ withData(generator).
+ stream(s -> fs.apply(s.filter(i -> true).unordered())).
+ exercise();
+ }
+
+ @Test(dataProvider = "DoubleStream.limit")
+ public void testDoubleUnorderedGenerator(String description, UnaryOperator<DoubleStream> fs) {
+ // Source is spliterator of infinite size
+ TestData.OfDouble generator = TestData.Factory.ofDoubleSupplier(
+ "[1.0, 1.0, ...]", () -> DoubleStream.generate(() -> 1.0));
+
+ withData(generator).
+ stream(s -> fs.apply(s.filter(i -> true).unordered())).
+ exercise();
+ }
+
+
+ // Unordered iteration
+
+ @Test(dataProvider = "Stream.limit")
+ public void testUnorderedIteration(String description, UnaryOperator<Stream<Long>> fs) {
+ // Source is a right-balanced tree of infinite size
+ TestData.OfRef<Long> iterator = TestData.Factory.ofSupplier(
+ "[1L, 2L, 3L, ...]", () -> Stream.iterate(1L, i -> i + 1L));
+
+ // Ref
+ withData(iterator).
+ stream(s -> fs.apply(s.unordered())).
+ resultAsserter(unorderedAsserter()).
+ exercise();
+ }
+
+ @Test(dataProvider = "IntStream.limit")
+ public void testIntUnorderedIteration(String description, UnaryOperator<IntStream> fs) {
+ // Source is a right-balanced tree of infinite size
+ TestData.OfInt iterator = TestData.Factory.ofIntSupplier(
+ "[1, 2, 3, ...]", () -> IntStream.iterate(1, i -> i + 1));
+
+ // Ref
+ withData(iterator).
+ stream(s -> fs.apply(s.unordered())).
+ resultAsserter(unorderedAsserter()).
+ exercise();
+ }
+
+ @Test(dataProvider = "LongStream.limit")
+ public void testLongUnorderedIteration(String description, UnaryOperator<LongStream> fs) {
+ // Source is a right-balanced tree of infinite size
+ TestData.OfLong iterator = TestData.Factory.ofLongSupplier(
+ "[1L, 2L, 3L, ...]", () -> LongStream.iterate(1, i -> i + 1));
+
+ // Ref
+ withData(iterator).
+ stream(s -> fs.apply(s.unordered())).
+ resultAsserter(unorderedAsserter()).
+ exercise();
+ }
+
+ @Test(dataProvider = "DoubleStream.limit")
+ public void testDoubleUnorderedIteration(String description, UnaryOperator<DoubleStream> fs) {
+ // Source is a right-balanced tree of infinite size
+ TestData.OfDouble iterator = TestData.Factory.ofDoubleSupplier(
+ "[1.0, 2.0, 3.0, ...]", () -> DoubleStream.iterate(1, i -> i + 1));
+
+ // Ref
+ withData(iterator).
+ stream(s -> fs.apply(s.unordered())).
+ resultAsserter(unorderedAsserter()).
+ exercise();
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntPrimitiveOpsTests.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntPrimitiveOpsTests.java
new file mode 100644
index 0000000..1efc5fd
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntPrimitiveOpsTests.java
@@ -0,0 +1,183 @@
+/*
+ * 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.Assert;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.IntConsumer;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import static org.testng.Assert.assertEquals;
+
+@Test
+public class IntPrimitiveOpsTests {
+
+ public void testSum() {
+ long sum = IntStream.range(1, 10).filter(i -> i % 2 == 0).sum();
+ assertEquals(sum, 20);
+ }
+
+ public void testMap() {
+ long sum = IntStream.range(1, 10).filter(i -> i % 2 == 0).map(i -> i * 2).sum();
+ assertEquals(sum, 40);
+ }
+
+ public void testParSum() {
+ long sum = IntStream.range(1, 10).parallel().filter(i -> i % 2 == 0).sum();
+ assertEquals(sum, 20);
+ }
+
+ @Test(groups = { "serialization-hostile" })
+ public void testTee() {
+ int[] teeSum = new int[1];
+ long sum = IntStream.range(1, 10).filter(i -> i % 2 == 0).peek(i -> { teeSum[0] = teeSum[0] + i; }).sum();
+ assertEquals(teeSum[0], sum);
+ }
+
+ @Test(groups = { "serialization-hostile" })
+ public void testForEach() {
+ int[] sum = new int[1];
+ IntStream.range(1, 10).filter(i -> i % 2 == 0).forEach(i -> { sum[0] = sum[0] + i; });
+ assertEquals(sum[0], 20);
+ }
+
+ @Test(groups = { "serialization-hostile" })
+ public void testParForEach() {
+ AtomicInteger ai = new AtomicInteger(0);
+ IntStream.range(1, 10).parallel().filter(i -> i % 2 == 0).forEach(ai::addAndGet);
+ assertEquals(ai.get(), 20);
+ }
+
+ public void testBox() {
+ List<Integer> l = IntStream.range(1, 10).parallel().boxed().collect(Collectors.toList());
+ int sum = l.stream().reduce(0, (a, b) -> a + b);
+ assertEquals(sum, 45);
+ }
+
+ public void testUnBox() {
+ long sum = Arrays.asList(1, 2, 3, 4, 5).stream().mapToInt(i -> (int) i).sum();
+ assertEquals(sum, 15);
+ }
+
+ public void testToArray() {
+ {
+ int[] array = IntStream.range(1, 10).map(i -> i * 2).toArray();
+ assertEquals(array, new int[]{2, 4, 6, 8, 10, 12, 14, 16, 18});
+ }
+
+ {
+ int[] array = IntStream.range(1, 10).parallel().map(i -> i * 2).toArray();
+ assertEquals(array, new int[]{2, 4, 6, 8, 10, 12, 14, 16, 18});
+ }
+ }
+
+ public void testSort() {
+ Random r = new Random();
+
+ int[] content = IntStream.generate(() -> r.nextInt(100)).limit(10).toArray();
+ int[] sortedContent = content.clone();
+ Arrays.sort(sortedContent);
+
+ {
+ int[] array = Arrays.stream(content).sorted().toArray();
+ assertEquals(array, sortedContent);
+ }
+
+ {
+ int[] array = Arrays.stream(content).parallel().sorted().toArray();
+ assertEquals(array, sortedContent);
+ }
+ }
+
+ public void testSortSort() {
+ Random r = new Random();
+
+ int[] content = IntStream.generate(() -> r.nextInt(100)).limit(10).toArray();
+ int[] sortedContent = content.clone();
+ Arrays.sort(sortedContent);
+
+ {
+ int[] array = Arrays.stream(content).sorted().sorted().toArray();
+ assertEquals(array, sortedContent);
+ }
+
+ {
+ int[] array = Arrays.stream(content).parallel().sorted().sorted().toArray();
+ assertEquals(array, sortedContent);
+ }
+ }
+
+ public void testSequential() {
+
+ int[] expected = IntStream.range(1, 1000).toArray();
+
+ class AssertingConsumer implements IntConsumer {
+ private final int[] array;
+ int offset;
+
+ AssertingConsumer(int[] array) {
+ this.array = array;
+ }
+
+ @Override
+ public void accept(int value) {
+ assertEquals(array[offset++], value);
+ }
+
+ public int getCount() { return offset; }
+ }
+
+ {
+ AssertingConsumer consumer = new AssertingConsumer(expected);
+ IntStream.range(1, 1000).sequential().forEach(consumer);
+ assertEquals(expected.length, consumer.getCount());
+ }
+
+ {
+ AssertingConsumer consumer = new AssertingConsumer(expected);
+ IntStream.range(1, 1000).parallel().sequential().forEach(consumer);
+ assertEquals(expected.length, consumer.getCount());
+ }
+ }
+
+ public void testLimit() {
+ int[] expected = IntStream.range(1, 10).toArray();
+
+ {
+ int[] actual = IntStream.iterate(1, i -> i + 1).limit(9).toArray();
+ Assert.assertTrue(Arrays.equals(expected, actual));
+ }
+
+ {
+ int[] actual = IntStream.range(1, 100).parallel().limit(9).toArray();
+ Assert.assertTrue(Arrays.equals(expected, actual));
+ }
+ }
+
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntReduceTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntReduceTest.java
new file mode 100644
index 0000000..baf9007
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntReduceTest.java
@@ -0,0 +1,81 @@
+/*
+ * 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 java.util.stream.IntStream;
+import java.util.stream.IntStreamTestDataProvider;
+import java.util.stream.OpTestCase;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.OptionalInt;
+import java.util.stream.TestData;
+
+import static java.util.stream.LambdaTestHelpers.*;
+
+public class IntReduceTest extends OpTestCase {
+ public void testReduce() {
+ int[] a = IntStream.range(1, 11).toArray();
+
+ assertEquals(55, Arrays.stream(a).reduce(irPlus).getAsInt());
+ assertEquals(55, Arrays.stream(a).reduce(0, irPlus));
+ assertEquals(10, Arrays.stream(a).reduce(irMax).getAsInt());
+ assertEquals(1, Arrays.stream(a).reduce(irMin).getAsInt());
+
+ assertEquals(0, IntStream.empty().reduce(0, irPlus));
+ assertFalse(IntStream.empty().reduce(irPlus).isPresent());
+
+ assertEquals(110, Arrays.stream(a).map(irDoubler).reduce(irPlus).getAsInt());
+ assertEquals(20, Arrays.stream(a).map(irDoubler).reduce(irMax).getAsInt());
+ assertEquals(2, Arrays.stream(a).map(irDoubler).reduce(irMin).getAsInt());
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testOps(String name, TestData.OfInt data) {
+ assertEquals(0, (int) exerciseTerminalOps(data, s -> s.filter(ipFalse), s -> s.reduce(0, irPlus)));
+
+ OptionalInt seedless = exerciseTerminalOps(data, s -> s.reduce(irPlus));
+ int folded = exerciseTerminalOps(data, s -> s.reduce(0, irPlus));
+ assertEquals(folded, seedless.orElse(0));
+
+ seedless = exerciseTerminalOps(data, s -> s.reduce(irMin));
+ folded = exerciseTerminalOps(data, s -> s.reduce(Integer.MAX_VALUE, irMin));
+ assertEquals(folded, seedless.orElse(Integer.MAX_VALUE));
+
+ seedless = exerciseTerminalOps(data, s -> s.reduce(irMax));
+ folded = exerciseTerminalOps(data, s -> s.reduce(Integer.MIN_VALUE, irMax));
+ assertEquals(folded, seedless.orElse(Integer.MIN_VALUE));
+
+ seedless = exerciseTerminalOps(data, s -> s.map(irDoubler), s -> s.reduce(irPlus));
+ folded = exerciseTerminalOps(data, s -> s.map(irDoubler), s -> s.reduce(0, irPlus));
+ assertEquals(folded, seedless.orElse(0));
+
+ seedless = exerciseTerminalOps(data, s -> s.map(irDoubler), s -> s.reduce(irMin));
+ folded = exerciseTerminalOps(data, s -> s.map(irDoubler), s -> s.reduce(Integer.MAX_VALUE, irMin));
+ assertEquals(folded, seedless.orElse(Integer.MAX_VALUE));
+
+ seedless = exerciseTerminalOps(data, s -> s.map(irDoubler), s -> s.reduce(irMax));
+ folded = exerciseTerminalOps(data, s -> s.map(irDoubler), s -> s.reduce(Integer.MIN_VALUE, irMax));
+ assertEquals(folded, seedless.orElse(Integer.MIN_VALUE));
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntSliceOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntSliceOpTest.java
new file mode 100644
index 0000000..51d1362
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntSliceOpTest.java
@@ -0,0 +1,208 @@
+/*
+ * 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 java.util.Collection;
+import java.util.stream.*;
+
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static java.util.stream.LambdaTestHelpers.assertCountSum;
+
+/**
+ * SliceOpTest
+ *
+ * @author Brian Goetz
+ */
+@Test
+public class IntSliceOpTest extends OpTestCase {
+
+ private static final int[] EMPTY_INT_ARRAY = new int[0];
+
+ public void testSkip() {
+ assertCountSum(IntStream.range(0, 0).skip(0).boxed(), 0, 0);
+ assertCountSum(IntStream.range(0, 0).skip(4).boxed(), 0, 0);
+ assertCountSum(IntStream.range(1, 5).skip(4).boxed(), 0, 0);
+ assertCountSum(IntStream.range(1, 5).skip(2).boxed(), 2, 7);
+ assertCountSum(IntStream.range(1, 5).skip(0).boxed(), 4, 10);
+
+ assertCountSum(IntStream.range(0, 0).parallel().skip(0).boxed(), 0, 0);
+ assertCountSum(IntStream.range(0, 0).parallel().skip(4).boxed(), 0, 0);
+ assertCountSum(IntStream.range(1, 5).parallel().skip(4).boxed(), 0, 0);
+ assertCountSum(IntStream.range(1, 5).parallel().skip(2).boxed(), 2, 7);
+ assertCountSum(IntStream.range(1, 5).parallel().skip(0).boxed(), 4, 10);
+
+ exerciseOps(EMPTY_INT_ARRAY, s -> s.skip(0), EMPTY_INT_ARRAY);
+ exerciseOps(EMPTY_INT_ARRAY, s -> s.skip(10), EMPTY_INT_ARRAY);
+
+ exerciseOps(IntStream.range(1, 2).toArray(), s -> s.skip(0), IntStream.range(1, 2).toArray());
+ exerciseOps(IntStream.range(1, 2).toArray(), s -> s.skip(1), EMPTY_INT_ARRAY);
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.skip(0), IntStream.range(1, 101).toArray());
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.skip(10), IntStream.range(11, 101).toArray());
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.skip(100), EMPTY_INT_ARRAY);
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.skip(200), EMPTY_INT_ARRAY);
+ }
+
+ public void testLimit() {
+ assertCountSum(IntStream.range(0, 0).limit(4).boxed(), 0, 0);
+ assertCountSum(IntStream.range(1, 3).limit(4).boxed(), 2, 3);
+ assertCountSum(IntStream.range(1, 5).limit(4).boxed(), 4, 10);
+ assertCountSum(IntStream.range(1, 9).limit(4).boxed(), 4, 10);
+
+ assertCountSum(IntStream.range(0, 0).parallel().limit(4).boxed(), 0, 0);
+ assertCountSum(IntStream.range(1, 3).parallel().limit(4).boxed(), 2, 3);
+ assertCountSum(IntStream.range(1, 5).parallel().limit(4).boxed(), 4, 10);
+ assertCountSum(IntStream.range(1, 9).parallel().limit(4).boxed(), 4, 10);
+
+ exerciseOps(EMPTY_INT_ARRAY, s -> s.limit(0), EMPTY_INT_ARRAY);
+ exerciseOps(EMPTY_INT_ARRAY, s -> s.limit(10), EMPTY_INT_ARRAY);
+
+ exerciseOps(IntStream.range(1, 2).toArray(), s -> s.limit(0), EMPTY_INT_ARRAY);
+ exerciseOps(IntStream.range(1, 2).toArray(), s -> s.limit(1), IntStream.range(1, 2).toArray());
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.limit(0), EMPTY_INT_ARRAY);
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.limit(10), IntStream.range(1, 11).toArray());
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.limit(10).limit(10), IntStream.range(1, 11).toArray());
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.limit(100), IntStream.range(1, 101).toArray());
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.limit(100).limit(10), IntStream.range(1, 11).toArray());
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.limit(200), IntStream.range(1, 101).toArray());
+ }
+
+ public void testSkipLimit() {
+ exerciseOps(EMPTY_INT_ARRAY, s -> s.skip(0).limit(0), EMPTY_INT_ARRAY);
+ exerciseOps(EMPTY_INT_ARRAY, s -> s.skip(0).limit(10), EMPTY_INT_ARRAY);
+ exerciseOps(EMPTY_INT_ARRAY, s -> s.skip(10).limit(0), EMPTY_INT_ARRAY);
+ exerciseOps(EMPTY_INT_ARRAY, s -> s.skip(10).limit(10), EMPTY_INT_ARRAY);
+
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.skip(0).limit(100), IntStream.range(1, 101).toArray());
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.skip(0).limit(10), IntStream.range(1, 11).toArray());
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.skip(0).limit(0), EMPTY_INT_ARRAY);
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.skip(10).limit(100), IntStream.range(11, 101).toArray());
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.skip(10).limit(10), IntStream.range(11, 21).toArray());
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.skip(10).limit(0), EMPTY_INT_ARRAY);
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.skip(100).limit(100), EMPTY_INT_ARRAY);
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.skip(100).limit(10), EMPTY_INT_ARRAY);
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.skip(100).limit(0), EMPTY_INT_ARRAY);
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.skip(200).limit(100), EMPTY_INT_ARRAY);
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.skip(200).limit(10), EMPTY_INT_ARRAY);
+ exerciseOps(IntStream.range(1, 101).toArray(), s -> s.skip(200).limit(0), EMPTY_INT_ARRAY);
+ }
+
+ private int sliceSize(int dataSize, int skip, int limit) {
+ int size = Math.max(0, dataSize - skip);
+ if (limit >= 0)
+ size = Math.min(size, limit);
+ return size;
+ }
+
+ private int sliceSize(int dataSize, int skip) {
+ return Math.max(0, dataSize - skip);
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testSkipOps(String name, TestData.OfInt data) {
+ List<Integer> skips = sizes(data.size());
+
+ for (int s : skips) {
+ setContext("skip", s);
+ Collection<Integer> sr = exerciseOps(data, st -> st.skip(s));
+ assertEquals(sr.size(), sliceSize(data.size(), s));
+
+ sr = exerciseOps(data, st -> st.skip(s).skip(s / 2));
+ assertEquals(sr.size(), sliceSize(sliceSize(data.size(), s), s / 2));
+ }
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testSkipLimitOps(String name, TestData.OfInt data) {
+ List<Integer> skips = sizes(data.size());
+ List<Integer> limits = skips;
+
+ for (int s : skips) {
+ setContext("skip", s);
+ for (int limit : limits) {
+ setContext("limit", limit);
+ Collection<Integer> sr = exerciseOps(data, st -> st.skip(s).limit(limit));
+ assertEquals(sr.size(), sliceSize(sliceSize(data.size(), s), 0, limit));
+
+ sr = exerciseOps(data, st -> st.skip(s).limit(limit));
+ assertEquals(sr.size(), sliceSize(data.size(), s, limit));
+ }
+ }
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testLimitOps(String name, TestData.OfInt data) {
+ List<Integer> limits = sizes(data.size());
+
+ for (int limit : limits) {
+ setContext("limit", limit);
+ Collection<Integer> sr = exerciseOps(data, st -> st.limit(limit));
+ assertEquals(sr.size(), sliceSize(data.size(), 0, limit));
+
+ sr = exerciseOps(data, st -> st.limit(limit).limit(limit / 2));
+ assertEquals(sr.size(), sliceSize(sliceSize(data.size(), 0, limit), 0, limit / 2));
+ }
+ }
+
+ public void testLimitSort() {
+ exerciseOps(IntStream.range(1, 101).map(i -> 101 - i).toArray(), s -> s.limit(10).sorted());
+ }
+
+ @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())
+ .limit(l).toArray();
+ // For the case of a zero limit, one element will get pushed through the sink chain
+ assertEquals(ai.get(), l, "tee block was called too many times");
+ }
+ }
+
+ public void testSkipParallel() {
+ int[] l = IntStream.range(1, 1001).parallel().skip(200).limit(200).sequential().toArray();
+ assertEquals(l.length, 200);
+ assertEquals(l[l.length - 1], 400);
+ }
+
+ public void testLimitParallel() {
+ int[] l = IntStream.range(1, 1001).parallel().limit(500).sequential().toArray();
+ assertEquals(l.length, 500);
+ assertEquals(l[l.length - 1], 500);
+ }
+
+ private List<Integer> sizes(int size) {
+ if (size < 4) {
+ return Arrays.asList(0, 1, 2, 3, 4, 6);
+ }
+ else {
+ return Arrays.asList(0, 1, size / 2, size - 1, size, size + 1, 2 * size);
+ }
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntUniqOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntUniqOpTest.java
new file mode 100644
index 0000000..3ec5d21
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntUniqOpTest.java
@@ -0,0 +1,72 @@
+/*
+ * 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 java.util.Collection;
+import java.util.stream.*;
+
+import org.testng.annotations.Test;
+
+import static java.util.stream.LambdaTestHelpers.assertCountSum;
+import static java.util.stream.LambdaTestHelpers.assertUnique;
+
+/**
+ * UniqOpTest
+ */
+@Test
+public class IntUniqOpTest extends OpTestCase {
+
+ public void testUniqOp() {
+ assertCountSum(IntStream.generate(() -> 0).limit(10).distinct().boxed(), 1, 0);
+ assertCountSum(IntStream.generate(() -> 1).limit(10).distinct().boxed(), 1, 1);
+ assertCountSum(IntStream.range(0, 0).distinct().boxed(), 0, 0);
+ assertCountSum(IntStream.range(1, 11).distinct().boxed(), 10, 55);
+ assertCountSum(IntStream.range(1, 11).distinct().boxed(), 10, 55);
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testOp(String name, TestData.OfInt data) {
+ Collection<Integer> result = exerciseOps(data, s -> s.distinct().boxed());
+
+ assertUnique(result);
+ if (data.size() > 0)
+ assertTrue(result.size() > 0);
+ else
+ assertTrue(result.size() == 0);
+ assertTrue(result.size() <= data.size());
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testOpSorted(String name, TestData.OfInt data) {
+ Collection<Integer> result = withData(data).
+ stream(s -> s.sorted().distinct().boxed()).
+ exercise();
+
+ assertUnique(result);
+ if (data.size() > 0)
+ assertTrue(result.size() > 0);
+ else
+ assertTrue(result.size() == 0);
+ assertTrue(result.size() <= data.size());
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/LongPrimitiveOpsTests.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/LongPrimitiveOpsTests.java
new file mode 100644
index 0000000..fc8fa2a
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/LongPrimitiveOpsTests.java
@@ -0,0 +1,183 @@
+/*
+ * 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.Assert;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.LongConsumer;
+import java.util.stream.Collectors;
+import java.util.stream.LongStream;
+
+import static org.testng.Assert.assertEquals;
+
+@Test
+public class LongPrimitiveOpsTests {
+
+ public void testSum() {
+ long sum = LongStream.range(1, 10).filter(i -> i % 2 == 0).sum();
+ assertEquals(sum, 20);
+ }
+
+ public void testMap() {
+ long sum = LongStream.range(1, 10).filter(i -> i % 2 == 0).map(i -> i * 2).sum();
+ assertEquals(sum, 40);
+ }
+
+ public void testParSum() {
+ long sum = LongStream.range(1, 10).parallel().filter(i -> i % 2 == 0).sum();
+ assertEquals(sum, 20);
+ }
+
+ @Test(groups = { "serialization-hostile" })
+ public void testTee() {
+ long[] teeSum = new long[1];
+ long sum = LongStream.range(1, 10).filter(i -> i % 2 == 0).peek(i -> { teeSum[0] = teeSum[0] + i; }).sum();
+ assertEquals(teeSum[0], sum);
+ }
+
+ @Test(groups = { "serialization-hostile" })
+ public void testForEach() {
+ long[] sum = new long[1];
+ LongStream.range(1, 10).filter(i -> i % 2 == 0).forEach(i -> { sum[0] = sum[0] + i; });
+ assertEquals(sum[0], 20);
+ }
+
+ @Test(groups = { "serialization-hostile" })
+ public void testParForEach() {
+ AtomicLong ai = new AtomicLong(0);
+ LongStream.range(1, 10).parallel().filter(i -> i % 2 == 0).forEach(ai::addAndGet);
+ assertEquals(ai.get(), 20);
+ }
+
+ public void testBox() {
+ List<Long> l = LongStream.range(1, 10).parallel().boxed().collect(Collectors.toList());
+ long sum = l.stream().reduce(0L, (a, b) -> a + b);
+ assertEquals(sum, 45);
+ }
+
+ public void testUnBox() {
+ long sum = Arrays.asList(1L, 2L, 3L, 4L, 5L).stream().mapToLong(i -> (long) i).sum();
+ assertEquals(sum, 15);
+ }
+
+ public void testToArray() {
+ {
+ long[] array = LongStream.range(1, 10).map(i -> i * 2).toArray();
+ assertEquals(array, new long[]{2, 4, 6, 8, 10, 12, 14, 16, 18});
+ }
+
+ {
+ long[] array = LongStream.range(1, 10).parallel().map(i -> i * 2).toArray();
+ assertEquals(array, new long[]{2, 4, 6, 8, 10, 12, 14, 16, 18});
+ }
+ }
+
+ public void testSort() {
+ Random r = new Random();
+
+ long[] content = LongStream.generate(() -> r.nextLong()).limit(10).toArray();
+ long[] sortedContent = content.clone();
+ Arrays.sort(sortedContent);
+
+ {
+ long[] array = Arrays.stream(content).sorted().toArray();
+ assertEquals(array, sortedContent);
+ }
+
+ {
+ long[] array = Arrays.stream(content).parallel().sorted().toArray();
+ assertEquals(array, sortedContent);
+ }
+ }
+
+ public void testSortSort() {
+ Random r = new Random();
+
+ long[] content = LongStream.generate(() -> r.nextLong()).limit(10).toArray();
+ long[] sortedContent = content.clone();
+ Arrays.sort(sortedContent);
+
+ {
+ long[] array = Arrays.stream(content).sorted().sorted().toArray();
+ assertEquals(array, sortedContent);
+ }
+
+ {
+ long[] array = Arrays.stream(content).parallel().sorted().sorted().toArray();
+ assertEquals(array, sortedContent);
+ }
+ }
+
+ public void testSequential() {
+
+ long[] expected = LongStream.range(1, 1000).toArray();
+
+ class AssertingConsumer implements LongConsumer {
+ private final long[] array;
+ int offset;
+
+ AssertingConsumer(long[] array) {
+ this.array = array;
+ }
+
+ @Override
+ public void accept(long value) {
+ assertEquals(array[offset++], value);
+ }
+
+ public int getCount() { return offset; }
+ }
+
+ {
+ AssertingConsumer consumer = new AssertingConsumer(expected);
+ LongStream.range(1, 1000).sequential().forEach(consumer);
+ assertEquals(expected.length, consumer.getCount());
+ }
+
+ {
+ AssertingConsumer consumer = new AssertingConsumer(expected);
+ LongStream.range(1, 1000).parallel().sequential().forEach(consumer);
+ assertEquals(expected.length, consumer.getCount());
+ }
+ }
+
+ public void testLimit() {
+ long[] expected = LongStream.range(1, 10).toArray();
+
+ {
+ long[] actual = LongStream.iterate(1, i -> i + 1).limit(9).toArray();
+ Assert.assertTrue(Arrays.equals(expected, actual));
+ }
+
+ {
+ long[] actual = LongStream.range(1, 100).parallel().limit(9).toArray();
+ Assert.assertTrue(Arrays.equals(expected, actual));
+ }
+ }
+
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MapOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MapOpTest.java
new file mode 100644
index 0000000..4f7aaf6
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MapOpTest.java
@@ -0,0 +1,125 @@
+/*
+ * 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.stream.*;
+
+import static java.util.stream.LambdaTestHelpers.*;
+
+/**
+ * MapOpTest
+ *
+ * @author Brian Goetz
+ */
+@Test
+public class MapOpTest extends OpTestCase {
+
+ public void testMap() {
+ assertCountSum(countTo(0).stream().map(mId), 0, 0);
+ assertCountSum(countTo(10).stream().map(mId), 10, 55);
+ assertCountSum(countTo(10).stream().map(mZero), 10, 0);
+ assertCountSum(countTo(0).stream().map(mDoubler), 0, 0);
+ assertCountSum(countTo(10).stream().map(mDoubler), 10, 110);
+ assertCountSum(countTo(10).stream().map(mDoubler).map(mDoubler), 10, 220);
+
+ exerciseOps(countTo(0), s -> s.map(LambdaTestHelpers.identity()), countTo(0));
+ exerciseOps(countTo(1000), s -> s.map(LambdaTestHelpers.identity()), countTo(1000));
+ // @@@ Force cast to integer so output is Stream<Integer> rather an IntStream
+ // this just ensures that no warnings are logged about boxing
+ // when the result is compared with the output
+ exerciseOps(countTo(1000), s -> s.map(e -> (Integer) (1000 + e)), range(1001, 2000));
+ }
+
+ public void testEveryMapShape() {
+ assertCountSum(countTo(1000).stream()
+ .mapToInt(i -> i - 1)
+ .mapToObj(i -> i + 1)
+ .mapToLong(i -> i - 1)
+ .mapToObj(i -> i + 1)
+ .mapToDouble(i -> i - 1)
+ .mapToObj(i -> i + 1)
+ .mapToInt(i -> (int) (double) i)
+ .mapToLong(i -> i)
+ .mapToDouble(i -> i)
+ .mapToLong(i -> (long) i)
+ .mapToInt(i -> (int) i)
+ .mapToObj(i -> i),
+ 1000, countTo(1000).stream().mapToInt(i -> i).sum());
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testOps(String name, TestData.OfRef<Integer> data) {
+ exerciseOpsInt(data, s -> s.map(mId), s -> s.map(e -> e), s -> s.map(e -> e), s -> s.map(e -> e));
+ exerciseOpsInt(data, s -> s.map(mZero), s -> s.map(e -> 0), s -> s.map(e -> 0), s -> s.map(e -> 0));
+ exerciseOpsInt(data, s -> s.map(mDoubler), s -> s.map(e -> 2*e), s -> s.map(e -> 2*e), s -> s.map(e -> 2*e));
+ exerciseOpsInt(data, s -> s.map(LambdaTestHelpers.compose(mId, mDoubler)), s -> s.map(e -> 2*e), s -> s.map(e -> 2*e), s -> s.map(e -> 2*e));
+ exerciseOpsInt(data, s -> s.map(LambdaTestHelpers.compose(mDoubler, mDoubler)), s -> s.map(e -> 4*e), s -> s.map(e -> 4*e), s -> s.map(e -> 4*e));
+ exerciseOps(data, s -> s.mapToInt(i -> i));
+ exerciseOps(data, s -> s.mapToLong(i -> i));
+ exerciseOps(data, s -> s.mapToDouble(i -> i));
+ }
+
+ //
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testIntOps(String name, TestData.OfInt data) {
+ exerciseOps(data, s -> s.mapToObj(i -> i));
+ exerciseOps(data, s -> s.map(i -> 0));
+ exerciseOps(data, s -> s.map(i -> i * 2));
+ exerciseOps(data, s -> s.asLongStream());
+ exerciseOps(data, s -> s.asDoubleStream());
+ exerciseOps(data, s -> s.boxed());
+ exerciseOps(data, s -> s.mapToObj(Integer::toString));
+ exerciseOps(data, s -> s.mapToLong(i -> i));
+ exerciseOps(data, s -> s.mapToDouble(i -> i));
+ }
+
+ //
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testLongOps(String name, TestData.OfLong data) {
+ exerciseOps(data, s -> s.mapToObj(i -> i));
+ exerciseOps(data, s -> s.map(i -> 0L));
+ exerciseOps(data, s -> s.map(i -> i * 2L));
+ exerciseOps(data, s -> s.asDoubleStream());
+ exerciseOps(data, s -> s.boxed());
+ exerciseOps(data, s -> s.mapToObj(e -> Long.toString(e)));
+ exerciseOps(data, s -> s.mapToInt(i -> (int) i));
+ exerciseOps(data, s -> s.mapToDouble(i -> i));
+ }
+
+ //
+
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testDoubleOps(String name, TestData.OfDouble data) {
+ exerciseOps(data, s -> s.mapToObj(i -> i));
+ exerciseOps(data, s -> s.map(i -> 0.0));
+ exerciseOps(data, s -> s.map(i -> i * 2.0));
+ exerciseOps(data, s -> s.boxed());
+ exerciseOps(data, s -> s.mapToObj(e -> Double.toString(e)));
+ exerciseOps(data, s -> s.mapToLong(i -> (long) i));
+ exerciseOps(data, s -> s.mapToInt(i -> (int) i));
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MatchOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MatchOpTest.java
new file mode 100644
index 0000000..dc825da
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MatchOpTest.java
@@ -0,0 +1,422 @@
+/*
+ * 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 java.util.Arrays;
+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.Function;
+import java.util.function.IntPredicate;
+import java.util.function.LongPredicate;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+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.StreamSupport;
+import java.util.stream.StreamTestDataProvider;
+import java.util.stream.TestData;
+
+import org.testng.annotations.Test;
+
+import static java.util.stream.LambdaTestHelpers.countTo;
+import static java.util.stream.LambdaTestHelpers.dpEven;
+import static java.util.stream.LambdaTestHelpers.dpFalse;
+import static java.util.stream.LambdaTestHelpers.dpOdd;
+import static java.util.stream.LambdaTestHelpers.dpTrue;
+import static java.util.stream.LambdaTestHelpers.ipEven;
+import static java.util.stream.LambdaTestHelpers.ipFalse;
+import static java.util.stream.LambdaTestHelpers.ipOdd;
+import static java.util.stream.LambdaTestHelpers.ipTrue;
+import static java.util.stream.LambdaTestHelpers.lpEven;
+import static java.util.stream.LambdaTestHelpers.lpFalse;
+import static java.util.stream.LambdaTestHelpers.lpOdd;
+import static java.util.stream.LambdaTestHelpers.lpTrue;
+import static java.util.stream.LambdaTestHelpers.pEven;
+import static java.util.stream.LambdaTestHelpers.pFalse;
+import static java.util.stream.LambdaTestHelpers.pOdd;
+import static java.util.stream.LambdaTestHelpers.pTrue;
+
+/**
+ * MatchOpTest
+ *
+ * @author Brian Goetz
+ */
+@Test
+public class MatchOpTest extends OpTestCase {
+ private enum Kind { ANY, ALL, NONE }
+
+ @SuppressWarnings("unchecked")
+ private static final Predicate<Integer>[] INTEGER_PREDICATES
+ = (Predicate<Integer>[]) new Predicate<?>[]{pTrue, pFalse, pEven, pOdd};
+
+ @SuppressWarnings({"serial", "rawtypes"})
+ private final Map kinds
+ = new HashMap<Kind, Function<Predicate<Integer>, Function<Stream<Integer>, Boolean>>>() {{
+ put(Kind.ANY, p -> s -> s.anyMatch(p));
+ put(Kind.ALL, p -> s -> s.allMatch(p));
+ put(Kind.NONE, p -> s -> s.noneMatch(p));
+ }};
+
+ @SuppressWarnings("unchecked")
+ private <T> Map<Kind, Function<Predicate<T>, Function<Stream<T>, Boolean>>> kinds() {
+ return (Map<Kind, Function<Predicate<T>, Function<Stream<T>, Boolean>>>) kinds;
+ }
+
+ private <T> void assertPredicates(List<T> source, Kind kind, Predicate<T>[] predicates, boolean... answers) {
+ for (int i = 0; i < predicates.length; i++) {
+ setContext("i", i);
+ boolean match = this.<T>kinds().get(kind).apply(predicates[i]).apply(source.stream());
+ assertEquals(answers[i], match, kind.toString() + predicates[i].toString());
+ }
+ }
+
+ public void testStreamMatches() {
+ assertPredicates(countTo(0), Kind.ANY, INTEGER_PREDICATES, false, false, false, false);
+ assertPredicates(countTo(0), Kind.ALL, INTEGER_PREDICATES, true, true, true, true);
+ assertPredicates(countTo(0), Kind.NONE, INTEGER_PREDICATES, true, true, true, true);
+
+ assertPredicates(countTo(1), Kind.ANY, INTEGER_PREDICATES, true, false, false, true);
+ assertPredicates(countTo(1), Kind.ALL, INTEGER_PREDICATES, true, false, false, true);
+ assertPredicates(countTo(1), Kind.NONE, INTEGER_PREDICATES, false, true, true, false);
+
+ assertPredicates(countTo(5), Kind.ANY, INTEGER_PREDICATES, true, false, true, true);
+ assertPredicates(countTo(5), Kind.ALL, INTEGER_PREDICATES, true, false, false, false);
+ assertPredicates(countTo(5), Kind.NONE, INTEGER_PREDICATES, false, true, false, false);
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testStream(String name, TestData.OfRef<Integer> data) {
+ for (Predicate<Integer> p : INTEGER_PREDICATES) {
+ setContext("p", p);
+ for (Kind kind : Kind.values()) {
+ setContext("kind", kind);
+ exerciseTerminalOps(data, this.<Integer>kinds().get(kind).apply(p));
+ exerciseTerminalOps(data, s -> s.filter(pFalse), this.<Integer>kinds().get(kind).apply(p));
+ exerciseTerminalOps(data, s -> s.filter(pEven), this.<Integer>kinds().get(kind).apply(p));
+ }
+ }
+ }
+
+ public void testInfinite() {
+ class CycleIterator implements Iterator<Integer> {
+ final Supplier<Iterator<Integer>> source;
+ Iterator<Integer> i = null;
+
+ CycleIterator(Supplier<Iterator<Integer>> source) {
+ this.source = source;
+ }
+
+ @Override
+ 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();
+ }
+ }
+
+ Supplier<Iterator<Integer>> source = () -> Arrays.asList(1, 2, 3, 4).iterator();
+ Supplier<Stream<Integer>> s = () -> StreamSupport.stream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0), false);
+
+ 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));
+ }
+
+ //
+
+ private static final IntPredicate[] INT_PREDICATES
+ = new IntPredicate[]{ipTrue, ipFalse, ipEven, ipOdd};
+
+ @SuppressWarnings("serial")
+ private final Map<Kind, Function<IntPredicate, Function<IntStream, Boolean>>> intKinds
+ = new HashMap<Kind, Function<IntPredicate, Function<IntStream, Boolean>>>() {{
+ put(Kind.ANY, p -> s -> s.anyMatch(p));
+ put(Kind.ALL, p -> s -> s.allMatch(p));
+ put(Kind.NONE, p -> s -> s.noneMatch(p));
+ }};
+
+ private void assertIntPredicates(Supplier<IntStream> 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());
+ }
+ }
+
+ public void testIntStreamMatches() {
+ assertIntPredicates(() -> IntStream.range(0, 0), Kind.ANY, INT_PREDICATES, false, false, false, false);
+ assertIntPredicates(() -> IntStream.range(0, 0), Kind.ALL, INT_PREDICATES, true, true, true, true);
+ assertIntPredicates(() -> IntStream.range(0, 0), Kind.NONE, INT_PREDICATES, true, true, true, true);
+
+ assertIntPredicates(() -> IntStream.range(1, 2), Kind.ANY, INT_PREDICATES, true, false, false, true);
+ assertIntPredicates(() -> IntStream.range(1, 2), Kind.ALL, INT_PREDICATES, true, false, false, true);
+ assertIntPredicates(() -> IntStream.range(1, 2), Kind.NONE, INT_PREDICATES, false, true, true, false);
+
+ assertIntPredicates(() -> IntStream.range(1, 6), Kind.ANY, INT_PREDICATES, true, false, true, true);
+ assertIntPredicates(() -> IntStream.range(1, 6), Kind.ALL, INT_PREDICATES, true, false, false, false);
+ assertIntPredicates(() -> IntStream.range(1, 6), Kind.NONE, INT_PREDICATES, false, true, false, false);
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testIntStream(String name, TestData.OfInt data) {
+ 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 CycleIterator implements PrimitiveIterator.OfInt {
+ final Supplier<PrimitiveIterator.OfInt> source;
+ PrimitiveIterator.OfInt i = null;
+
+ CycleIterator(Supplier<PrimitiveIterator.OfInt> source) {
+ this.source = source;
+ }
+
+ @Override
+ 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<PrimitiveIterator.OfInt> source = () -> Arrays.stream(new int[]{1, 2, 3, 4}).iterator();
+ Supplier<IntStream> s = () -> StreamSupport.intStream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0), false);
+
+ 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));
+ }
+
+ //
+
+ private static final LongPredicate[] LONG_PREDICATES
+ = new LongPredicate[]{lpTrue, lpFalse, lpEven, lpOdd};
+
+ @SuppressWarnings("serial")
+ private final Map<Kind, Function<LongPredicate, Function<LongStream, Boolean>>> longKinds
+ = new HashMap<Kind, Function<LongPredicate, Function<LongStream, Boolean>>>() {{
+ put(Kind.ANY, p -> s -> s.anyMatch(p));
+ put(Kind.ALL, p -> s -> s.allMatch(p));
+ put(Kind.NONE, p -> s -> s.noneMatch(p));
+ }};
+
+ private void assertLongPredicates(Supplier<LongStream> 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());
+ }
+ }
+
+ public void testLongStreamMatches() {
+ assertLongPredicates(() -> LongStream.range(0, 0), Kind.ANY, LONG_PREDICATES, false, false, false, false);
+ assertLongPredicates(() -> LongStream.range(0, 0), Kind.ALL, LONG_PREDICATES, true, true, true, true);
+ assertLongPredicates(() -> LongStream.range(0, 0), Kind.NONE, LONG_PREDICATES, true, true, true, true);
+
+ assertLongPredicates(() -> LongStream.range(1, 2), Kind.ANY, LONG_PREDICATES, true, false, false, true);
+ assertLongPredicates(() -> LongStream.range(1, 2), Kind.ALL, LONG_PREDICATES, true, false, false, true);
+ assertLongPredicates(() -> LongStream.range(1, 2), Kind.NONE, LONG_PREDICATES, false, true, true, false);
+
+ assertLongPredicates(() -> LongStream.range(1, 6), Kind.ANY, LONG_PREDICATES, true, false, true, true);
+ assertLongPredicates(() -> LongStream.range(1, 6), Kind.ALL, LONG_PREDICATES, true, false, false, false);
+ assertLongPredicates(() -> LongStream.range(1, 6), Kind.NONE, LONG_PREDICATES, false, true, false, false);
+ }
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testLongStream(String name, TestData.OfLong data) {
+ 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 CycleIterator implements PrimitiveIterator.OfLong {
+ final Supplier<PrimitiveIterator.OfLong> source;
+ PrimitiveIterator.OfLong i = null;
+
+ CycleIterator(Supplier<PrimitiveIterator.OfLong> source) {
+ this.source = source;
+ }
+
+ @Override
+ 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<PrimitiveIterator.OfLong> source = () -> Arrays.stream(new long[]{1, 2, 3, 4}).iterator();
+ Supplier<LongStream> s = () -> StreamSupport.longStream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0), false);
+
+ 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));
+ }
+
+ //
+
+ private static final DoublePredicate[] DOUBLE_PREDICATES
+ = new DoublePredicate[]{dpTrue, dpFalse, dpEven, dpOdd};
+
+ @SuppressWarnings("serial")
+ private final Map<Kind, Function<DoublePredicate, Function<DoubleStream, Boolean>>> doubleKinds
+ = new HashMap<Kind, Function<DoublePredicate, Function<DoubleStream, Boolean>>>() {{
+ put(Kind.ANY, p -> s -> s.anyMatch(p));
+ put(Kind.ALL, p -> s -> s.allMatch(p));
+ put(Kind.NONE, p -> s -> s.noneMatch(p));
+ }};
+
+ private void assertDoublePredicates(Supplier<DoubleStream> 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());
+ }
+ }
+
+ public void testDoubleStreamMatches() {
+ assertDoublePredicates(() -> LongStream.range(0, 0).asDoubleStream(), Kind.ANY, DOUBLE_PREDICATES, false, false, false, false);
+ assertDoublePredicates(() -> LongStream.range(0, 0).asDoubleStream(), Kind.ALL, DOUBLE_PREDICATES, true, true, true, true);
+ assertDoublePredicates(() -> LongStream.range(0, 0).asDoubleStream(), Kind.NONE, DOUBLE_PREDICATES, true, true, true, true);
+
+ assertDoublePredicates(() -> LongStream.range(1, 2).asDoubleStream(), Kind.ANY, DOUBLE_PREDICATES, true, false, false, true);
+ assertDoublePredicates(() -> LongStream.range(1, 2).asDoubleStream(), Kind.ALL, DOUBLE_PREDICATES, true, false, false, true);
+ assertDoublePredicates(() -> LongStream.range(1, 2).asDoubleStream(), Kind.NONE, DOUBLE_PREDICATES, false, true, true, false);
+
+ assertDoublePredicates(() -> LongStream.range(1, 6).asDoubleStream(), Kind.ANY, DOUBLE_PREDICATES, true, false, true, true);
+ assertDoublePredicates(() -> LongStream.range(1, 6).asDoubleStream(), Kind.ALL, DOUBLE_PREDICATES, true, false, false, false);
+ assertDoublePredicates(() -> LongStream.range(1, 6).asDoubleStream(), Kind.NONE, DOUBLE_PREDICATES, false, true, false, false);
+ }
+
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testDoubleStream(String name, TestData.OfDouble data) {
+ 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 CycleIterator implements PrimitiveIterator.OfDouble {
+ final Supplier<PrimitiveIterator.OfDouble> source;
+ PrimitiveIterator.OfDouble i = null;
+
+ CycleIterator(Supplier<PrimitiveIterator.OfDouble> source) {
+ this.source = source;
+ }
+
+ @Override
+ 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<PrimitiveIterator.OfDouble> source = () -> Arrays.stream(new double[]{1, 2, 3, 4}).iterator();
+ Supplier<DoubleStream> s = () -> StreamSupport.doubleStream(Spliterators.spliteratorUnknownSize(new CycleIterator(source), 0), false);
+
+ 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/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MinMaxTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MinMaxTest.java
new file mode 100644
index 0000000..eed4a82
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MinMaxTest.java
@@ -0,0 +1,92 @@
+/*
+ * 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 java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+import java.util.stream.*;
+
+import org.testng.annotations.Test;
+
+import static java.util.stream.LambdaTestHelpers.countTo;
+
+/**
+ * MinMaxTest
+ *
+ * @author Brian Goetz
+ */
+@Test
+public class MinMaxTest extends OpTestCase {
+ public void testMinMax() {
+ assertTrue(!countTo(0).stream().min(Integer::compare).isPresent());
+ assertTrue(!countTo(0).stream().max(Integer::compare).isPresent());
+ assertEquals(1, (int) countTo(1000).stream().min(Integer::compare).get());
+ assertEquals(1000, (int) countTo(1000).stream().max(Integer::compare).get());
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testOps(String name, TestData.OfRef<Integer> data) {
+ exerciseTerminalOps(data, s -> s.min(Integer::compare));
+ exerciseTerminalOps(data, s -> s.max(Integer::compare));
+ }
+
+ public void testIntMinMax() {
+ assertEquals(IntStream.empty().min(), OptionalInt.empty());
+ assertEquals(IntStream.empty().max(), OptionalInt.empty());
+ assertEquals(1, IntStream.range(1, 1001).min().getAsInt());
+ assertEquals(1000, IntStream.range(1, 1001).max().getAsInt());
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testIntOps(String name, TestData.OfInt data) {
+ exerciseTerminalOps(data, s -> s.min());
+ exerciseTerminalOps(data, s -> s.max());
+ }
+
+ public void testLongMinMax() {
+ assertEquals(LongStream.empty().min(), OptionalLong.empty());
+ assertEquals(LongStream.empty().max(), OptionalLong.empty());
+ assertEquals(1, LongStream.range(1, 1001).min().getAsLong());
+ assertEquals(1000, LongStream.range(1, 1001).max().getAsLong());
+ }
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testLongOps(String name, TestData.OfLong data) {
+ exerciseTerminalOps(data, s -> s.min());
+ exerciseTerminalOps(data, s -> s.max());
+ }
+
+ public void testDoubleMinMax() {
+ assertEquals(DoubleStream.empty().min(), OptionalDouble.empty());
+ assertEquals(DoubleStream.empty().max(), OptionalDouble.empty());
+ assertEquals(1.0, LongStream.range(1, 1001).asDoubleStream().min().getAsDouble());
+ assertEquals(1000.0, LongStream.range(1, 1001).asDoubleStream().max().getAsDouble());
+ }
+
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testDoubleOps(String name, TestData.OfDouble data) {
+ exerciseTerminalOps(data, s -> s.min());
+ exerciseTerminalOps(data, s -> s.max());
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/PrimitiveAverageOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/PrimitiveAverageOpTest.java
new file mode 100644
index 0000000..82491e5
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/PrimitiveAverageOpTest.java
@@ -0,0 +1,50 @@
+/*
+ * 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 java.util.stream.*;
+
+import org.testng.annotations.Test;
+
+public class PrimitiveAverageOpTest extends OpTestCase {
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testOps(String name, TestData.OfInt data) {
+ exerciseTerminalOps(data, s -> s.average());
+ }
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testOps(String name, TestData.OfLong data) {
+ exerciseTerminalOps(data, s -> s.average());
+ }
+
+ // @@@ For Double depending on the input data the average algorithm may produce slightly
+ // different results for the sequential and parallel evaluation.results are within
+ // While the following works at the moment, it could change when double data, not cast from long
+ // values is introduced, or if the average/sum algorithm is modified.
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testOps(String name, TestData.OfDouble data) {
+ exerciseTerminalOps(data, s -> s.average());
+ }
+
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/PrimitiveSumTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/PrimitiveSumTest.java
new file mode 100644
index 0000000..6f2822f9
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/PrimitiveSumTest.java
@@ -0,0 +1,65 @@
+/*
+ * 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 java.util.stream.*;
+
+import org.testng.annotations.Test;
+
+public class PrimitiveSumTest extends OpTestCase {
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testOps(String name, TestData.OfInt data) {
+ exerciseTerminalOps(data, s -> s.sum());
+
+ withData(data).
+ terminal(s -> (long) s.sum()).
+ expectedResult(data.stream().asLongStream().reduce(0, LambdaTestHelpers.lrPlus)).
+ exercise();
+ }
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testOps(String name, TestData.OfLong data) {
+ exerciseTerminalOps(data, s -> s.sum());
+
+ withData(data).
+ terminal(s -> s.sum()).
+ expectedResult(data.stream().reduce(0, LambdaTestHelpers.lrPlus)).
+ exercise();
+ }
+
+ // @@@ For Double depending on the input data the average algorithm may produce slightly
+ // different results for the sequential and parallel evaluation.results are within
+ // While the following works at the moment, it could change when double data, not cast from long
+ // values is introduced, or if the sum algorithm is modified.
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testOps(String name, TestData.OfDouble data) {
+ exerciseTerminalOps(data, s -> s.sum());
+
+ withData(data).
+ terminal(s -> s.sum()).
+ expectedResult(data.stream().reduce(0, LambdaTestHelpers.drPlus)).
+ exercise();
+ }
+}
+
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/RangeTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/RangeTest.java
new file mode 100644
index 0000000..20ae203
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/RangeTest.java
@@ -0,0 +1,339 @@
+/*
+ * 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 java.util.Arrays;
+import java.util.Optional;
+import java.util.Spliterator;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+import java.util.stream.OpTestCase;
+import java.util.stream.SpliteratorTestHelper;
+import java.util.stream.Stream;
+import java.util.stream.TestData;
+
+import org.testng.annotations.Test;
+
+/**
+ * Primitive range tests
+ *
+ * @author Brian Goetz
+ */
+@Test
+public class RangeTest extends OpTestCase {
+
+ public void testInfiniteRangeFindFirst() {
+ Integer first = Stream.iterate(0, i -> i + 1).filter(i -> i > 10000).findFirst().get();
+ assertEquals(first, Stream.iterate(0, i -> i + 1).parallel().filter(i -> i > 10000).findFirst().get());
+
+ // Limit is required to transform the infinite stream to a finite stream
+ // since the exercising requires a finite stream
+ withData(TestData.Factory.ofSupplier(
+ "", () -> Stream.iterate(0, i -> i + 1).filter(i -> i > 10000).limit(20000))).
+ terminal(s->s.findFirst()).expectedResult(Optional.of(10001)).exercise();
+ }
+
+ //
+
+ 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++) {
+ exp[p] = i;
+ }
+
+ int[] inc = IntStream.range(start, end).toArray();
+ assertEquals(inc.length, size);
+ assertTrue(Arrays.equals(exp, inc));
+
+ withData(intRangeData(start, end)).stream(s -> s).
+ expectedResult(exp).exercise();
+ }
+ }
+
+ // 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++) {
+ exp[p] = i;
+ }
+
+ int[] inc = IntStream.rangeClosed(start, end).toArray();
+ assertEquals(inc.length, size);
+ assertTrue(Arrays.equals(exp, inc));
+
+ withData(intRangeClosedData(start, end)).stream(s -> s).
+ expectedResult(exp).exercise();
+ }
+ }
+
+ // Closed, maximum upper bound of Integer.MAX_VALUE
+ {
+ int[] inc = IntStream.rangeClosed(Integer.MAX_VALUE - 1, Integer.MAX_VALUE).toArray();
+ assertEquals(2, inc.length);
+ assertEquals(Integer.MAX_VALUE - 1, inc[0]);
+ assertEquals(Integer.MAX_VALUE, inc[1]);
+
+ inc = IntStream.rangeClosed(Integer.MAX_VALUE, Integer.MAX_VALUE).toArray();
+ assertEquals(1, inc.length);
+ assertEquals(Integer.MAX_VALUE, inc[0]);
+
+ SpliteratorTestHelper.testIntSpliterator(
+ () -> IntStream.rangeClosed(Integer.MAX_VALUE - 8, Integer.MAX_VALUE).spliterator());
+ }
+
+ // Range wider than Integer.MAX_VALUE
+ {
+ Spliterator.OfInt s = IntStream.rangeClosed(Integer.MIN_VALUE, Integer.MAX_VALUE).
+ spliterator();
+ assertEquals(s.estimateSize(), 1L << 32);
+ }
+ }
+
+ TestData.OfInt intRangeData(int start, int end) {
+ return TestData.Factory.ofIntSupplier("int range", () -> IntStream.range(start, end));
+ }
+
+ TestData.OfInt intRangeClosedData(int start, int end) {
+ return TestData.Factory.ofIntSupplier("int rangeClosed", () -> IntStream.rangeClosed(start, end));
+ }
+
+ public void tesIntRangeReduce() {
+ withData(intRangeData(0, 10000)).
+ terminal(s -> s.reduce(0, Integer::sum)).exercise();
+ }
+
+ public void testIntInfiniteRangeLimit() {
+ withData(TestData.Factory.ofIntSupplier(
+ "int range", () -> IntStream.iterate(0, i -> i + 1).limit(10000))).
+ terminal(s -> s.reduce(0, Integer::sum)).exercise();
+ }
+
+ public void testIntInfiniteRangeFindFirst() {
+ int first = IntStream.iterate(0, i -> i + 1).filter(i -> i > 10000).findFirst().getAsInt();
+ assertEquals(first, IntStream.iterate(0, i -> i + 1).parallel().filter(i -> i > 10000).findFirst().getAsInt());
+ }
+
+ //
+
+ 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++) {
+ exp[(int) p] = i;
+ }
+
+ long[] inc = LongStream.range(start, end).toArray();
+ assertEquals(inc.length, size);
+ assertTrue(Arrays.equals(exp, inc));
+
+ withData(longRangeData(start, end)).stream(s -> s).
+ expectedResult(exp).exercise();
+ }
+ }
+
+ // 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++) {
+ exp[(int) p] = i;
+ }
+
+ long[] inc = LongStream.rangeClosed(start, end).toArray();
+ assertEquals(inc.length, size);
+ assertTrue(Arrays.equals(exp, inc));
+
+ withData(longRangeClosedData(start, end)).stream(s -> s).
+ expectedResult(exp).exercise();
+ }
+ }
+
+ // Closed, maximum upper bound of Long.MAX_VALUE
+ {
+ long[] inc = LongStream.rangeClosed(Long.MAX_VALUE - 1, Long.MAX_VALUE).toArray();
+ assertEquals(2, inc.length);
+ assertEquals(Long.MAX_VALUE - 1, inc[0]);
+ assertEquals(Long.MAX_VALUE, inc[1]);
+
+ inc = LongStream.rangeClosed(Long.MAX_VALUE, Long.MAX_VALUE).toArray();
+ assertEquals(1, inc.length);
+ assertEquals(Long.MAX_VALUE, inc[0]);
+
+ SpliteratorTestHelper.testLongSpliterator(
+ () -> LongStream.rangeClosed(Long.MAX_VALUE - 8, Long.MAX_VALUE).spliterator());
+ }
+ }
+
+ TestData.OfLong longRangeData(long start, long end) {
+ return TestData.Factory.ofLongSupplier("long range", () -> LongStream.range(start, end));
+ }
+
+ TestData.OfLong longRangeClosedData(long start, long end) {
+ return TestData.Factory.ofLongSupplier("long rangeClosed", () -> LongStream.rangeClosed(start, end));
+ }
+
+ public void testLongRangeReduce() {
+ withData(longRangeData(0, 10000)).
+ terminal(s -> s.reduce(0, Long::sum)).exercise();
+ }
+
+ public void testLongInfiniteRangeLimit() {
+ withData(TestData.Factory.ofLongSupplier(
+ "long range", () -> LongStream.iterate(0, i -> i + 1).limit(10000))).
+ terminal(s -> s.reduce(0, Long::sum)).exercise();
+ }
+
+ public void testLongInfiniteRangeFindFirst() {
+ long first = LongStream.iterate(0, i -> i + 1).filter(i -> i > 10000).findFirst().getAsLong();
+ assertEquals(first, LongStream.iterate(0, i -> i + 1).parallel().filter(i -> i > 10000).findFirst().getAsLong());
+ }
+
+ private static void assertSizedAndSubSized(Spliterator<?> s) {
+ assertTrue(s.hasCharacteristics(Spliterator.SIZED | Spliterator.SUBSIZED));
+ }
+
+ private static void assertNotSizedAndSubSized(Spliterator<?> s) {
+ assertFalse(s.hasCharacteristics(Spliterator.SIZED | Spliterator.SUBSIZED));
+ }
+
+ public void testLongLongRange() {
+ // Test [Long.MIN_VALUE, Long.MAX_VALUE)
+ // This will concatenate streams of three ranges
+ // [Long.MIN_VALUE, x) [x, 0) [0, Long.MAX_VALUE)
+ // where x = Long.divideUnsigned(0 - Long.MIN_VALUE, 2) + 1
+ {
+ Spliterator.OfLong s = LongStream.range(Long.MIN_VALUE, Long.MAX_VALUE).spliterator();
+
+ assertEquals(s.estimateSize(), Long.MAX_VALUE);
+ assertNotSizedAndSubSized(s);
+
+ Spliterator.OfLong s1 = s.trySplit();
+ assertNotSizedAndSubSized(s1);
+ assertSizedAndSubSized(s);
+
+ Spliterator.OfLong s2 = s1.trySplit();
+ assertSizedAndSubSized(s1);
+ assertSizedAndSubSized(s2);
+
+ assertTrue(s.estimateSize() == Long.MAX_VALUE);
+ assertTrue(s1.estimateSize() < Long.MAX_VALUE);
+ assertTrue(s2.estimateSize() < Long.MAX_VALUE);
+
+ assertEquals(s.estimateSize() + s1.estimateSize() + s2.estimateSize(),
+ Long.MAX_VALUE - Long.MIN_VALUE);
+ }
+
+ long[][] ranges = { {Long.MIN_VALUE, 0}, {-1, Long.MAX_VALUE} };
+ for (int i = 0; i < ranges.length; i++) {
+ long start = ranges[i][0];
+ long end = ranges[i][1];
+
+ Spliterator.OfLong s = LongStream.range(start, end).spliterator();
+
+ assertEquals(s.estimateSize(), Long.MAX_VALUE);
+ assertNotSizedAndSubSized(s);
+
+ Spliterator.OfLong s1 = s.trySplit();
+ assertSizedAndSubSized(s1);
+ assertSizedAndSubSized(s);
+
+ assertTrue(s.estimateSize() < Long.MAX_VALUE);
+ assertTrue(s1.estimateSize() < Long.MAX_VALUE);
+
+ assertEquals(s.estimateSize() + s1.estimateSize(), end - start);
+ }
+ }
+
+ public void testLongLongRangeClosed() {
+ // Test [Long.MIN_VALUE, Long.MAX_VALUE]
+ // This will concatenate streams of four ranges
+ // [Long.MIN_VALUE, x) [x, 0) [0, y) [y, Long.MAX_VALUE]
+ // where x = Long.divideUnsigned(0 - Long.MIN_VALUE, 2) + 1
+ // y = Long.divideUnsigned(Long.MAX_VALUE, 2) + 1
+
+ {
+ Spliterator.OfLong s = LongStream.rangeClosed(Long.MIN_VALUE, Long.MAX_VALUE).spliterator();
+
+ assertEquals(s.estimateSize(), Long.MAX_VALUE);
+ assertNotSizedAndSubSized(s);
+
+ Spliterator.OfLong s1 = s.trySplit();
+ assertNotSizedAndSubSized(s1);
+ assertNotSizedAndSubSized(s);
+
+ Spliterator.OfLong s2 = s1.trySplit();
+ assertSizedAndSubSized(s1);
+ assertSizedAndSubSized(s2);
+
+ Spliterator.OfLong s3 = s.trySplit();
+ assertSizedAndSubSized(s3);
+ assertSizedAndSubSized(s);
+
+ assertTrue(s.estimateSize() < Long.MAX_VALUE);
+ assertTrue(s3.estimateSize() < Long.MAX_VALUE);
+ assertTrue(s1.estimateSize() < Long.MAX_VALUE);
+ assertTrue(s2.estimateSize() < Long.MAX_VALUE);
+
+ assertEquals(s.estimateSize() + s3.estimateSize() + s1.estimateSize() + s2.estimateSize(),
+ Long.MAX_VALUE - Long.MIN_VALUE + 1);
+ }
+
+ long[][] ranges = { {Long.MIN_VALUE, 0}, {-1, Long.MAX_VALUE} };
+ for (int i = 0; i < ranges.length; i++) {
+ long start = ranges[i][0];
+ long end = ranges[i][1];
+
+ Spliterator.OfLong s = LongStream.rangeClosed(start, end).spliterator();
+
+ assertEquals(s.estimateSize(), Long.MAX_VALUE);
+ assertNotSizedAndSubSized(s);
+
+ Spliterator.OfLong s1 = s.trySplit();
+ assertSizedAndSubSized(s1);
+ assertSizedAndSubSized(s);
+
+ assertTrue(s.estimateSize() < Long.MAX_VALUE);
+ assertTrue(s1.estimateSize() < Long.MAX_VALUE);
+
+ assertEquals(s.estimateSize() + s1.estimateSize(), end - start + 1);
+ }
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ReduceByOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ReduceByOpTest.java
new file mode 100644
index 0000000..3fcb469
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ReduceByOpTest.java
@@ -0,0 +1,68 @@
+/*
+ * 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 java.util.List;
+import java.util.stream.LambdaTestHelpers;
+import java.util.stream.OpTestCase;
+import java.util.stream.Stream;
+import java.util.stream.StreamTestDataProvider;
+import org.testng.annotations.Test;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.stream.TestData;
+
+import static java.util.stream.Collectors.groupingBy;
+import static java.util.stream.Collectors.reducing;
+import static java.util.stream.LambdaTestHelpers.*;
+
+/**
+ * ReduceByOpTest
+ *
+ * @author Brian Goetz
+ */
+@Test
+public class ReduceByOpTest extends OpTestCase {
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testOps(String name, TestData.OfRef<Integer> data) {
+ Map<Boolean,List<Integer>> gbResult = data.stream().collect(groupingBy(LambdaTestHelpers.forPredicate(pEven, true, false)));
+ Map<Boolean, Integer> result = data.stream().collect(groupingBy(LambdaTestHelpers.forPredicate(pEven, true, false), reducing(0, rPlus)));
+ assertEquals(result.size(), gbResult.size());
+ for (Map.Entry<Boolean, Integer> entry : result.entrySet()) {
+ setContext("entry", entry);
+ Boolean key = entry.getKey();
+ assertEquals(entry.getValue(), data.stream().filter(e -> pEven.test(e) == key).reduce(0, rPlus));
+ }
+
+ int uniqueSize = data.into(new HashSet<Integer>()).size();
+ Map<Integer, List<Integer>> mgResult = exerciseTerminalOps(data, s -> s.collect(groupingBy(mId)));
+ Map<Integer, Integer> miResult = exerciseTerminalOps(data, s -> s.collect(groupingBy(mId, reducing(0, e -> 1, Integer::sum))));
+ assertEquals(miResult.keySet().size(), uniqueSize);
+ for (Map.Entry<Integer, Integer> entry : miResult.entrySet()) {
+ setContext("entry", entry);
+ assertEquals((int) entry.getValue(), mgResult.get(entry.getKey()).size());
+ }
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ReduceTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ReduceTest.java
new file mode 100644
index 0000000..fd4c687
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ReduceTest.java
@@ -0,0 +1,87 @@
+/*
+ * 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 java.util.stream.OpTestCase;
+import java.util.stream.Stream;
+import java.util.stream.StreamTestDataProvider;
+import org.testng.annotations.Test;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.TestData;
+
+import static java.util.stream.LambdaTestHelpers.*;
+
+/**
+ * ReduceOpTest
+ *
+ * @author Brian Goetz
+ */
+@Test
+public class ReduceTest extends OpTestCase {
+ public void testReduce() {
+ List<Integer> list = countTo(10);
+
+ assertEquals(55, (int) list.stream().reduce(rPlus).get());
+ assertEquals(55, (int) list.stream().reduce(0, rPlus));
+ assertEquals(10, (int) list.stream().reduce(rMax).get());
+ assertEquals(1, (int) list.stream().reduce(rMin).get());
+
+ assertEquals(0, (int) countTo(0).stream().reduce(0, rPlus));
+ assertTrue(!countTo(0).stream().reduce(rPlus).isPresent());
+
+ assertEquals(110, (int) list.stream().map(mDoubler).reduce(rPlus).get());
+ assertEquals(20, (int) list.stream().map(mDoubler).reduce(rMax).get());
+ assertEquals(2, (int) list.stream().map(mDoubler).reduce(rMin).get());
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testOps(String name, TestData.OfRef<Integer> data) {
+ assertEquals(0, (int) exerciseTerminalOps(data, s -> s.filter(pFalse), s -> s.reduce(0, rPlus, rPlus)));
+
+ Optional<Integer> seedless = exerciseTerminalOps(data, s -> s.reduce(rPlus));
+ Integer folded = exerciseTerminalOps(data, s -> s.reduce(0, rPlus, rPlus));
+ assertEquals(folded, seedless.orElse(0));
+
+ seedless = exerciseTerminalOps(data, s -> s.reduce(rMin));
+ folded = exerciseTerminalOps(data, s -> s.reduce(Integer.MAX_VALUE, rMin, rMin));
+ assertEquals(folded, seedless.orElse(Integer.MAX_VALUE));
+
+ seedless = exerciseTerminalOps(data, s -> s.reduce(rMax));
+ folded = exerciseTerminalOps(data, s -> s.reduce(Integer.MIN_VALUE, rMax, rMax));
+ assertEquals(folded, seedless.orElse(Integer.MIN_VALUE));
+
+ seedless = exerciseTerminalOps(data, s -> s.map(mDoubler), s -> s.reduce(rPlus));
+ folded = exerciseTerminalOps(data, s -> s.map(mDoubler), s -> s.reduce(0, rPlus, rPlus));
+ assertEquals(folded, seedless.orElse(0));
+
+ seedless = exerciseTerminalOps(data, s -> s.map(mDoubler), s -> s.reduce(rMin));
+ folded = exerciseTerminalOps(data, s -> s.map(mDoubler), s -> s.reduce(Integer.MAX_VALUE, rMin, rMin));
+ assertEquals(folded, seedless.orElse(Integer.MAX_VALUE));
+
+ seedless = exerciseTerminalOps(data, s -> s.map(mDoubler), s -> s.reduce(rMax));
+ folded = exerciseTerminalOps(data, s -> s.map(mDoubler), s -> s.reduce(Integer.MIN_VALUE, rMax, rMax));
+ assertEquals(folded, seedless.orElse(Integer.MIN_VALUE));
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SequentialOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SequentialOpTest.java
new file mode 100644
index 0000000..efa5c62
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SequentialOpTest.java
@@ -0,0 +1,135 @@
+/*
+ * 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 java.util.stream.LambdaTestHelpers;
+import java.util.stream.OpTestCase;
+import java.util.stream.StreamTestDataProvider;
+import org.testng.annotations.Test;
+
+import java.util.Iterator;
+import java.util.Comparator;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
+import java.util.Spliterator;
+import java.util.stream.Stream;
+import java.util.stream.TestData;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertTrue;
+
+/**
+ * SequentialOpTest
+ *
+ * @author Brian Goetz
+ */
+public class SequentialOpTest extends OpTestCase {
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class,
+ groups = { "serialization-hostile" })
+ public void testLazy(String name, TestData.OfRef<Integer> data) {
+ Function<Integer, Integer> id = LambdaTestHelpers.identity();
+ AtomicInteger counter = new AtomicInteger();
+ Supplier<Stream<Integer>>[] suppliers = new Supplier[] { () -> data.stream(), () -> data.parallelStream() };
+ UnaryOperator<Stream<Integer>>[] configs
+ = new UnaryOperator[] {
+ (UnaryOperator<Stream<Integer>>) s -> s.peek(e -> { counter.incrementAndGet(); }),
+ (UnaryOperator<Stream<Integer>>) s -> s.map(id).peek(e -> { counter.incrementAndGet(); }).sequential().map(id),
+ (UnaryOperator<Stream<Integer>>) s -> s.map(id).peek(e -> { counter.incrementAndGet(); }).parallel().map(id),
+ (UnaryOperator<Stream<Integer>>) s -> s.sequential().map(id).peek(e -> {
+ counter.incrementAndGet();
+ }).map(id),
+ (UnaryOperator<Stream<Integer>>) s -> s.parallel().map(id).peek(e -> { counter.incrementAndGet(); }).map(id)
+ };
+
+ for (int i = 0; i < suppliers.length; i++) {
+ setContext("supplierIndex", i);
+ Supplier<Stream<Integer>> supp = suppliers[i];
+ for (int j = 0; j < configs.length; j++) {
+ setContext("configIndex", j);
+ UnaryOperator<Stream<Integer>> config = configs[j];
+ counter.set(0);
+ Stream<Integer> stream = config.apply(supp.get());
+ assertEquals(0, counter.get());
+
+ Iterator<Integer> iterator = stream.iterator();
+ assertEquals(0, counter.get());
+
+ if (iterator.hasNext())
+ iterator.next();
+ assertTrue(data.size() == 0 || counter.get() > 0);
+
+ counter.set(0);
+ stream = config.apply(supp.get());
+ Spliterator<Integer> spliterator = stream.spliterator();
+ assertEquals(0, counter.get());
+
+ spliterator.forEachRemaining(e -> {
+ });
+ assertTrue(data.size() == 0 || counter.get() > 0);
+ }
+ }
+ }
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testMixedSeqPar(String name, TestData.OfRef<Integer> data) {
+ Function<Integer, Integer> id = LambdaTestHelpers.identity();
+ UnaryOperator<Stream<Integer>>[] changers
+ = new UnaryOperator[] {
+ (UnaryOperator<Stream<Integer>>) s -> s,
+ (UnaryOperator<Stream<Integer>>) s -> s.sequential(),
+ (UnaryOperator<Stream<Integer>>) s -> s.parallel(),
+ (UnaryOperator<Stream<Integer>>) s -> s.unordered()
+ };
+ UnaryOperator<Stream<Integer>>[] stuff
+ = new UnaryOperator[] {
+ (UnaryOperator<Stream<Integer>>) s -> s,
+ (UnaryOperator<Stream<Integer>>) s -> s.map(id),
+ (UnaryOperator<Stream<Integer>>) s -> s.sorted(Comparator.naturalOrder()),
+ (UnaryOperator<Stream<Integer>>) s -> s.map(id).sorted(Comparator.naturalOrder()).map(id),
+ (UnaryOperator<Stream<Integer>>) s -> s.filter(LambdaTestHelpers.pEven).sorted(Comparator.naturalOrder()).map(id),
+ };
+
+ for (int c1Index = 0; c1Index < changers.length; c1Index++) {
+ setContext("c1Index", c1Index);
+ UnaryOperator<Stream<Integer>> c1 = changers[c1Index];
+ for (int s1Index = 0; s1Index < stuff.length; s1Index++) {
+ setContext("s1Index", s1Index);
+ UnaryOperator<Stream<Integer>> s1 = stuff[s1Index];
+ for (int c2Index = 0; c2Index < changers.length; c2Index++) {
+ setContext("c2Index", c2Index);
+ UnaryOperator<Stream<Integer>> c2 = changers[c2Index];
+ for (int s2Index = 0; s2Index < stuff.length; s2Index++) {
+ setContext("s2Index", s2Index);
+ UnaryOperator<Stream<Integer>> s2 = stuff[s2Index];
+ UnaryOperator<Stream<Integer>> composed = s -> s2.apply(c2.apply(s1.apply(c1.apply(s))));
+ exerciseOps(data, composed);
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java
new file mode 100644
index 0000000..44499d0
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java
@@ -0,0 +1,343 @@
+/*
+ * 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.concurrent.atomic.AtomicInteger;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+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.StreamSupport;
+import java.util.stream.StreamTestDataProvider;
+import java.util.stream.TestData;
+
+import static java.util.stream.LambdaTestHelpers.*;
+
+/**
+ * SliceOpTest
+ *
+ * @author Brian Goetz
+ */
+@Test
+public class SliceOpTest extends OpTestCase {
+
+ public void testSkip() {
+ assertCountSum(countTo(0).stream().skip(0), 0, 0);
+ assertCountSum(countTo(0).stream().skip(4), 0, 0);
+ assertCountSum(countTo(4).stream().skip(4), 0, 0);
+ assertCountSum(countTo(4).stream().skip(2), 2, 7);
+ assertCountSum(countTo(4).stream().skip(0), 4, 10);
+
+ assertCountSum(countTo(0).parallelStream().skip(0), 0, 0);
+ assertCountSum(countTo(0).parallelStream().skip(4), 0, 0);
+ assertCountSum(countTo(4).parallelStream().skip(4), 0, 0);
+ assertCountSum(countTo(4).parallelStream().skip(2), 2, 7);
+ assertCountSum(countTo(4).parallelStream().skip(0), 4, 10);
+
+ exerciseOps(Collections.emptyList(), s -> s.skip(0), Collections.emptyList());
+ exerciseOps(Collections.emptyList(), s -> s.skip(10), Collections.emptyList());
+
+ exerciseOps(countTo(1), s -> s.skip(0), countTo(1));
+ exerciseOps(countTo(1), s -> s.skip(1), Collections.emptyList());
+ exerciseOps(countTo(100), s -> s.skip(0), countTo(100));
+ exerciseOps(countTo(100), s -> s.skip(10), range(11, 100));
+ exerciseOps(countTo(100), s -> s.skip(100), Collections.emptyList());
+ exerciseOps(countTo(100), s -> s.skip(200), Collections.emptyList());
+ }
+
+ public void testLimit() {
+ assertCountSum(countTo(0).stream().limit(4), 0, 0);
+ assertCountSum(countTo(2).stream().limit(4), 2, 3);
+ assertCountSum(countTo(4).stream().limit(4), 4, 10);
+ assertCountSum(countTo(8).stream().limit(4), 4, 10);
+
+ assertCountSum(countTo(0).parallelStream().limit(4), 0, 0);
+ assertCountSum(countTo(2).parallelStream().limit(4), 2, 3);
+ assertCountSum(countTo(4).parallelStream().limit(4), 4, 10);
+ assertCountSum(countTo(8).parallelStream().limit(4), 4, 10);
+
+ exerciseOps(Collections.emptyList(), s -> s.limit(0), Collections.emptyList());
+ exerciseOps(Collections.emptyList(), s -> s.limit(10), Collections.emptyList());
+ exerciseOps(countTo(1), s -> s.limit(0), Collections.emptyList());
+ exerciseOps(countTo(1), s -> s.limit(1), countTo(1));
+ exerciseOps(countTo(100), s -> s.limit(0), Collections.emptyList());
+ exerciseOps(countTo(100), s -> s.limit(10), countTo(10));
+ exerciseOps(countTo(100), s -> s.limit(10).limit(10), countTo(10));
+ exerciseOps(countTo(100), s -> s.limit(100), countTo(100));
+ exerciseOps(countTo(100), s -> s.limit(100).limit(10), countTo(10));
+ exerciseOps(countTo(100), s -> s.limit(200), countTo(100));
+ }
+
+ public void testSkipLimit() {
+ exerciseOps(Collections.emptyList(), s -> s.skip(0).limit(0), Collections.emptyList());
+ exerciseOps(Collections.emptyList(), s -> s.skip(0).limit(10), Collections.emptyList());
+ exerciseOps(Collections.emptyList(), s -> s.skip(10).limit(0), Collections.emptyList());
+ exerciseOps(Collections.emptyList(), s -> s.skip(10).limit(10), Collections.emptyList());
+
+ exerciseOps(countTo(100), s -> s.skip(0).limit(100), countTo(100));
+ exerciseOps(countTo(100), s -> s.skip(0).limit(10), countTo(10));
+ exerciseOps(countTo(100), s -> s.skip(0).limit(0), Collections.emptyList());
+ exerciseOps(countTo(100), s -> s.skip(10).limit(100), range(11, 100));
+ exerciseOps(countTo(100), s -> s.skip(10).limit(10), range(11, 20));
+ exerciseOps(countTo(100), s -> s.skip(10).limit(0), Collections.emptyList());
+ exerciseOps(countTo(100), s -> s.skip(100).limit(100), Collections.emptyList());
+ exerciseOps(countTo(100), s -> s.skip(100).limit(10), Collections.emptyList());
+ exerciseOps(countTo(100), s -> s.skip(100).limit(0), Collections.emptyList());
+ exerciseOps(countTo(100), s -> s.skip(200).limit(100), Collections.emptyList());
+ exerciseOps(countTo(100), s -> s.skip(200).limit(10), Collections.emptyList());
+ exerciseOps(countTo(100), s -> s.skip(200).limit(0), Collections.emptyList());
+ }
+
+ public void testSlice() {
+ exerciseOps(Collections.emptyList(), s -> s.skip(0).limit(0), Collections.emptyList());
+ exerciseOps(Collections.emptyList(), s -> s.skip(0).limit(10), Collections.emptyList());
+ exerciseOps(Collections.emptyList(), s -> s.skip(10).limit(10), Collections.emptyList());
+ exerciseOps(Collections.emptyList(), s -> s.skip(10).limit(20), Collections.emptyList());
+
+ exerciseOps(countTo(100), s -> s.skip(0).limit(100), countTo(100));
+ exerciseOps(countTo(100), s -> s.skip(0).limit(10), countTo(10));
+ exerciseOps(countTo(100), s -> s.skip(0).limit(0), Collections.emptyList());
+ exerciseOps(countTo(100), s -> s.skip(10).limit(100), range(11, 100));
+ exerciseOps(countTo(100), s -> s.skip(10).limit(10), range(11, 20));
+ exerciseOps(countTo(100), s -> s.skip(10).limit(0), Collections.emptyList());
+ exerciseOps(countTo(100), s -> s.skip(100).limit(100), Collections.emptyList());
+ exerciseOps(countTo(100), s -> s.skip(100).limit(10), Collections.emptyList());
+ exerciseOps(countTo(100), s -> s.skip(100).limit(0), Collections.emptyList());
+ exerciseOps(countTo(100), s -> s.skip(200).limit(100), Collections.emptyList());
+ exerciseOps(countTo(100), s -> s.skip(200).limit(10), Collections.emptyList());
+ exerciseOps(countTo(100), s -> s.skip(200).limit(0), Collections.emptyList());
+ }
+
+ private int sliceSize(int dataSize, int skip, int limit) {
+ int size = Math.max(0, dataSize - skip);
+ if (limit >= 0)
+ size = Math.min(size, limit);
+ return size;
+ }
+
+ private int sliceSize(int dataSize, int skip) {
+ return Math.max(0, dataSize - skip);
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class,
+ groups = { "serialization-hostile" })
+ public void testSkipOps(String name, TestData.OfRef<Integer> data) {
+ List<Integer> skips = sizes(data.size());
+
+ for (int s : skips) {
+ setContext("skip", s);
+ testSliceMulti(data,
+ sliceSize(data.size(), s),
+ st -> st.skip(s),
+ st -> st.skip(s),
+ st -> st.skip(s),
+ st -> st.skip(s));
+
+ testSliceMulti(data,
+ sliceSize(sliceSize(data.size(), s), s/2),
+ st -> st.skip(s).skip(s / 2),
+ st -> st.skip(s).skip(s / 2),
+ st -> st.skip(s).skip(s / 2),
+ st -> st.skip(s).skip(s / 2));
+ }
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class,
+ groups = { "serialization-hostile" })
+ public void testSkipLimitOps(String name, TestData.OfRef<Integer> data) {
+ List<Integer> skips = sizes(data.size());
+ List<Integer> limits = skips;
+
+ for (int s : skips) {
+ setContext("skip", s);
+ for (int l : limits) {
+ setContext("limit", l);
+ testSliceMulti(data,
+ sliceSize(sliceSize(data.size(), s), 0, l),
+ st -> st.skip(s).limit(l),
+ st -> st.skip(s).limit(l),
+ st -> st.skip(s).limit(l),
+ st -> st.skip(s).limit(l));
+ }
+ }
+ }
+
+ public void testSkipLimitOpsWithNonSplittingSpliterator() {
+ class NonSplittingNotSubsizedOrderedSpliterator<T> implements Spliterator<T> {
+ Spliterator<T> s;
+
+ NonSplittingNotSubsizedOrderedSpliterator(Spliterator<T> s) {
+ assert s.hasCharacteristics(Spliterator.ORDERED);
+ this.s = s;
+ }
+
+ @Override
+ public boolean tryAdvance(Consumer<? super T> action) {
+ return s.tryAdvance(action);
+ }
+
+ @Override
+ public void forEachRemaining(Consumer<? super T> action) {
+ s.forEachRemaining(action);
+ }
+
+ @Override
+ public Spliterator<T> trySplit() {
+ return null;
+ }
+
+ @Override
+ public long estimateSize() {
+ return s.estimateSize();
+ }
+
+ @Override
+ public int characteristics() {
+ return s.characteristics() & ~(Spliterator.SUBSIZED);
+ }
+
+ @Override
+ public Comparator<? super T> getComparator() {
+ return s.getComparator();
+ }
+ }
+ List<Integer> list = IntStream.range(0, 100).boxed().collect(Collectors.toList());
+ TestData.OfRef<Integer> data = TestData.Factory.ofSupplier(
+ "Non splitting, not SUBSIZED, ORDERED, stream",
+ () -> StreamSupport.stream(new NonSplittingNotSubsizedOrderedSpliterator<>(list.spliterator()), false));
+
+ testSkipLimitOps("testSkipLimitOpsWithNonSplittingSpliterator", data);
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class,
+ groups = { "serialization-hostile" })
+ public void testLimitOps(String name, TestData.OfRef<Integer> data) {
+ List<Integer> limits = sizes(data.size());
+
+ 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));
+ }
+
+ 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<Iterable<Integer>> sliceResultAsserter(Iterable<Integer> data,
+ int expectedSize) {
+ return (act, exp, ord, par) -> {
+ if (par & !ord) {
+ List<Integer> expected = new ArrayList<>();
+ data.forEach(expected::add);
+
+ List<Integer> 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<Integer> data,
+ int expectedSize,
+ Function<Stream<Integer>, Stream<Integer>> mRef,
+ Function<IntStream, IntStream> mInt,
+ Function<LongStream, LongStream> mLong,
+ Function<DoubleStream, DoubleStream> mDouble) {
+
+ @SuppressWarnings({ "rawtypes", "unchecked" })
+ Function<Stream<Integer>, Stream<Integer>>[] 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<Integer> data,
+ int expectedSize,
+ Function<Stream<Integer>, Stream<Integer>>... ms) {
+ for (int i = 0; i < ms.length; i++) {
+ setContext("mIndex", i);
+ Function<Stream<Integer>, Stream<Integer>> m = ms[i];
+ Collection<Integer> sr = withData(data)
+ .stream(m)
+ .resultAsserter(sliceResultAsserter(data, expectedSize))
+ .exercise();
+ assertEquals(sr.size(), expectedSize);
+ }
+ }
+
+ public void testLimitSort() {
+ List<Integer> l = countTo(100);
+ Collections.reverse(l);
+ exerciseOps(l, s -> s.limit(10).sorted(Comparator.naturalOrder()));
+ }
+
+ @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())
+ .limit(l).toArray();
+ // For the case of a zero limit, one element will get pushed through the sink chain
+ assertEquals(ai.get(), l, "tee block was called too many times");
+ }
+ }
+
+ private List<Integer> sizes(int size) {
+ if (size < 4) {
+ return Arrays.asList(0, 1, 2, 3, 4, 6);
+ }
+ else {
+ return Arrays.asList(0, 1, size / 2, size - 1, size, size + 1, 2 * size);
+ }
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SortedOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SortedOpTest.java
new file mode 100644
index 0000000..3ca690e
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SortedOpTest.java
@@ -0,0 +1,361 @@
+/*
+ * 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.Spliterators;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.*;
+
+import static java.util.stream.LambdaTestHelpers.*;
+
+/**
+ * SortedOpTest
+ *
+ * @author Brian Goetz
+ */
+@Test
+public class SortedOpTest extends OpTestCase {
+
+ public void testRefStreamTooLarge() {
+ Function<LongStream, Stream<Long>> f = s ->
+ // Clear the SORTED flag
+ s.mapToObj(i -> i)
+ .sorted();
+
+ testStreamTooLarge(f, Stream::findFirst);
+ }
+
+ public void testIntStreamTooLarge() {
+ Function<LongStream, IntStream> f = s ->
+ // Clear the SORTED flag
+ s.mapToInt(i -> (int) i)
+ .sorted();
+
+ testStreamTooLarge(f, IntStream::findFirst);
+ }
+
+ public void testLongStreamTooLarge() {
+ Function<LongStream, LongStream> f = s ->
+ // Clear the SORTED flag
+ s.map(i -> i)
+ .sorted();
+
+ testStreamTooLarge(f, LongStream::findFirst);
+ }
+
+ public void testDoubleStreamTooLarge() {
+ Function<LongStream, DoubleStream> f = s ->
+ // Clear the SORTED flag
+ s.mapToDouble(i -> (double) i)
+ .sorted();
+
+ testStreamTooLarge(f, DoubleStream::findFirst);
+ }
+
+ <T, S extends BaseStream<T, S>> void testStreamTooLarge(Function<LongStream, S> s,
+ Function<S, ?> terminal) {
+ // Set up conditions for a large input > maximum array size
+ Supplier<LongStream> input = () -> LongStream.range(0, 1L + Integer.MAX_VALUE);
+
+ // Transformation functions
+ List<Function<LongStream, LongStream>> transforms = Arrays.asList(
+ ls -> ls,
+ ls -> ls.parallel(),
+ // Clear the SIZED flag
+ ls -> ls.limit(Long.MAX_VALUE),
+ ls -> ls.limit(Long.MAX_VALUE).parallel());
+
+ for (Function<LongStream, LongStream> transform : transforms) {
+ RuntimeException caught = null;
+ try {
+ terminal.apply(s.apply(transform.apply(input.get())));
+ } catch (RuntimeException e) {
+ caught = e;
+ }
+ assertNotNull(caught, "Expected an instance of exception IllegalArgumentException but no exception thrown");
+ assertTrue(caught instanceof IllegalArgumentException,
+ String.format("Expected an instance of exception IllegalArgumentException but got %s", caught));
+ }
+ }
+
+ public void testSorted() {
+ assertCountSum(countTo(0).stream().sorted(), 0, 0);
+ assertCountSum(countTo(10).stream().sorted(), 10, 55);
+ assertCountSum(countTo(10).stream().sorted(cInteger.reversed()), 10, 55);
+
+ List<Integer> to10 = countTo(10);
+ assertSorted(to10.stream().sorted(cInteger.reversed()).iterator(), cInteger.reversed());
+
+ Collections.reverse(to10);
+ assertSorted(to10.stream().sorted().iterator());
+
+ Spliterator<Integer> s = to10.stream().sorted().spliterator();
+ assertTrue(s.hasCharacteristics(Spliterator.SORTED));
+
+ s = to10.stream().sorted(cInteger.reversed()).spliterator();
+ assertFalse(s.hasCharacteristics(Spliterator.SORTED));
+ }
+
+ @Test(groups = { "serialization-hostile" })
+ public void testSequentialShortCircuitTerminal() {
+ // The sorted op for sequential evaluation will buffer all elements when
+ // accepting then at the end sort those elements and push those elements
+ // downstream
+ // A peek operation is added in-between the sorted() and terminal
+ // operation that counts the number of calls to its consumer and
+ // asserts that the number of calls is at most the required quantity
+
+ List<Integer> l = Arrays.asList(5, 4, 3, 2, 1);
+
+ Function<Integer, Stream<Integer>> knownSize = i -> assertNCallsOnly(
+ l.stream().sorted(), Stream::peek, i);
+ Function<Integer, Stream<Integer>> unknownSize = i -> assertNCallsOnly
+ (unknownSizeStream(l).sorted(), Stream::peek, i);
+
+ // Find
+ assertEquals(knownSize.apply(1).findFirst(), Optional.of(1));
+ assertEquals(knownSize.apply(1).findAny(), Optional.of(1));
+ assertEquals(unknownSize.apply(1).findFirst(), Optional.of(1));
+ assertEquals(unknownSize.apply(1).findAny(), Optional.of(1));
+
+ // Match
+ assertEquals(knownSize.apply(2).anyMatch(i -> i == 2), true);
+ assertEquals(knownSize.apply(2).noneMatch(i -> i == 2), false);
+ assertEquals(knownSize.apply(2).allMatch(i -> i == 2), false);
+ assertEquals(unknownSize.apply(2).anyMatch(i -> i == 2), true);
+ assertEquals(unknownSize.apply(2).noneMatch(i -> i == 2), false);
+ assertEquals(unknownSize.apply(2).allMatch(i -> i == 2), false);
+ }
+
+ private <T> Stream<T> unknownSizeStream(List<T> l) {
+ return StreamSupport.stream(Spliterators.spliteratorUnknownSize(l.iterator(), 0), false);
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testOps(String name, TestData.OfRef<Integer> data) {
+ Collection<Integer> result = exerciseOpsInt(data, Stream::sorted, IntStream::sorted, LongStream::sorted, DoubleStream::sorted);
+ assertSorted(result.iterator());
+ assertContentsUnordered(data, result);
+
+ result = exerciseOps(data, s -> s.sorted(cInteger.reversed()));
+ assertSorted(result.iterator(), cInteger.reversed());
+ assertContentsUnordered(data, result);
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testSortSort(String name, TestData.OfRef<Integer> data) {
+ // For parallel cases ensure the size is known
+ Collection<Integer> result = withData(data)
+ .stream(s -> s.sorted().sorted(),
+ new CollectorOps.TestParallelSizedOp<Integer>())
+ .exercise();
+
+ assertSorted(result);
+ assertContentsUnordered(data, result);
+
+ result = withData(data)
+ .stream(s -> s.sorted(cInteger.reversed()).sorted(cInteger.reversed()),
+ new CollectorOps.TestParallelSizedOp<Integer>())
+ .exercise();
+
+ assertSorted(result, cInteger.reversed());
+ assertContentsUnordered(data, result);
+
+ result = withData(data)
+ .stream(s -> s.sorted().sorted(cInteger.reversed()),
+ new CollectorOps.TestParallelSizedOp<Integer>())
+ .exercise();
+
+ assertSorted(result, cInteger.reversed());
+ assertContentsUnordered(data, result);
+
+ result = withData(data)
+ .stream(s -> s.sorted(cInteger.reversed()).sorted(),
+ new CollectorOps.TestParallelSizedOp<Integer>())
+ .exercise();
+
+ assertSorted(result);
+ assertContentsUnordered(data, result);
+ }
+
+ //
+
+ @Test(groups = { "serialization-hostile" })
+ public void testIntSequentialShortCircuitTerminal() {
+ int[] a = new int[]{5, 4, 3, 2, 1};
+
+ Function<Integer, IntStream> knownSize = i -> assertNCallsOnly(
+ Arrays.stream(a).sorted(), (s, c) -> s.peek(c::accept), i);
+ Function<Integer, IntStream> unknownSize = i -> assertNCallsOnly
+ (unknownSizeIntStream(a).sorted(), (s, c) -> s.peek(c::accept), i);
+
+ // Find
+ assertEquals(knownSize.apply(1).findFirst(), OptionalInt.of(1));
+ assertEquals(knownSize.apply(1).findAny(), OptionalInt.of(1));
+ assertEquals(unknownSize.apply(1).findFirst(), OptionalInt.of(1));
+ assertEquals(unknownSize.apply(1).findAny(), OptionalInt.of(1));
+
+ // Match
+ assertEquals(knownSize.apply(2).anyMatch(i -> i == 2), true);
+ assertEquals(knownSize.apply(2).noneMatch(i -> i == 2), false);
+ assertEquals(knownSize.apply(2).allMatch(i -> i == 2), false);
+ assertEquals(unknownSize.apply(2).anyMatch(i -> i == 2), true);
+ assertEquals(unknownSize.apply(2).noneMatch(i -> i == 2), false);
+ assertEquals(unknownSize.apply(2).allMatch(i -> i == 2), false);
+ }
+
+ private IntStream unknownSizeIntStream(int[] a) {
+ return StreamSupport.intStream(Spliterators.spliteratorUnknownSize(Spliterators.iterator(Arrays.spliterator(a)), 0), false);
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testIntOps(String name, TestData.OfInt data) {
+ Collection<Integer> result = exerciseOps(data, s -> s.sorted());
+ assertSorted(result);
+ assertContentsUnordered(data, result);
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testIntSortSort(String name, TestData.OfInt data) {
+ // For parallel cases ensure the size is known
+ Collection<Integer> result = withData(data)
+ .stream(s -> s.sorted().sorted(), new CollectorOps.TestParallelSizedOp.OfInt())
+ .exercise();
+
+ assertSorted(result);
+ assertContentsUnordered(data, result);
+ }
+
+ //
+
+ @Test(groups = { "serialization-hostile" })
+ public void testLongSequentialShortCircuitTerminal() {
+ long[] a = new long[]{5, 4, 3, 2, 1};
+
+ Function<Integer, LongStream> knownSize = i -> assertNCallsOnly(
+ Arrays.stream(a).sorted(), (s, c) -> s.peek(c::accept), i);
+ Function<Integer, LongStream> unknownSize = i -> assertNCallsOnly
+ (unknownSizeLongStream(a).sorted(), (s, c) -> s.peek(c::accept), i);
+
+ // Find
+ assertEquals(knownSize.apply(1).findFirst(), OptionalLong.of(1));
+ assertEquals(knownSize.apply(1).findAny(), OptionalLong.of(1));
+ assertEquals(unknownSize.apply(1).findFirst(), OptionalLong.of(1));
+ assertEquals(unknownSize.apply(1).findAny(), OptionalLong.of(1));
+
+ // Match
+ assertEquals(knownSize.apply(2).anyMatch(i -> i == 2), true);
+ assertEquals(knownSize.apply(2).noneMatch(i -> i == 2), false);
+ assertEquals(knownSize.apply(2).allMatch(i -> i == 2), false);
+ assertEquals(unknownSize.apply(2).anyMatch(i -> i == 2), true);
+ assertEquals(unknownSize.apply(2).noneMatch(i -> i == 2), false);
+ assertEquals(unknownSize.apply(2).allMatch(i -> i == 2), false);
+ }
+
+ private LongStream unknownSizeLongStream(long[] a) {
+ return StreamSupport.longStream(Spliterators.spliteratorUnknownSize(Spliterators.iterator(Arrays.spliterator(a)), 0), false);
+ }
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testLongOps(String name, TestData.OfLong data) {
+ Collection<Long> result = exerciseOps(data, s -> s.sorted());
+ assertSorted(result);
+ assertContentsUnordered(data, result);
+ }
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testLongSortSort(String name, TestData.OfLong data) {
+ // For parallel cases ensure the size is known
+ Collection<Long> result = withData(data)
+ .stream(s -> s.sorted().sorted(), new CollectorOps.TestParallelSizedOp.OfLong())
+ .exercise();
+
+ assertSorted(result);
+ assertContentsUnordered(data, result);
+ }
+
+ //
+
+ @Test(groups = { "serialization-hostile" })
+ public void testDoubleSequentialShortCircuitTerminal() {
+ double[] a = new double[]{5.0, 4.0, 3.0, 2.0, 1.0};
+
+ Function<Integer, DoubleStream> knownSize = i -> assertNCallsOnly(
+ Arrays.stream(a).sorted(), (s, c) -> s.peek(c::accept), i);
+ Function<Integer, DoubleStream> unknownSize = i -> assertNCallsOnly
+ (unknownSizeDoubleStream(a).sorted(), (s, c) -> s.peek(c::accept), i);
+
+ // Find
+ assertEquals(knownSize.apply(1).findFirst(), OptionalDouble.of(1));
+ assertEquals(knownSize.apply(1).findAny(), OptionalDouble.of(1));
+ assertEquals(unknownSize.apply(1).findFirst(), OptionalDouble.of(1));
+ assertEquals(unknownSize.apply(1).findAny(), OptionalDouble.of(1));
+
+ // Match
+ assertEquals(knownSize.apply(2).anyMatch(i -> i == 2.0), true);
+ assertEquals(knownSize.apply(2).noneMatch(i -> i == 2.0), false);
+ assertEquals(knownSize.apply(2).allMatch(i -> i == 2.0), false);
+ assertEquals(unknownSize.apply(2).anyMatch(i -> i == 2.0), true);
+ assertEquals(unknownSize.apply(2).noneMatch(i -> i == 2.0), false);
+ assertEquals(unknownSize.apply(2).allMatch(i -> i == 2.0), false);
+ }
+
+ private DoubleStream unknownSizeDoubleStream(double[] a) {
+ return StreamSupport.doubleStream(Spliterators.spliteratorUnknownSize(Spliterators.iterator(Arrays.spliterator(a)), 0), false);
+ }
+
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testDoubleOps(String name, TestData.OfDouble data) {
+ Collection<Double> result = exerciseOps(data, s -> s.sorted());
+ assertSorted(result);
+ assertContentsUnordered(data, result);
+ }
+
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testDoubleSortSort(String name, TestData.OfDouble data) {
+ // For parallel cases ensure the size is known
+ Collection<Double> result = withData(data)
+ .stream(s -> s.sorted().sorted(), new CollectorOps.TestParallelSizedOp.OfDouble())
+ .exercise();
+
+ assertSorted(result);
+ assertContentsUnordered(data, result);
+ }
+
+ /**
+ * Interpose a consumer that asserts it is called at most N times.
+ */
+ <T, S extends BaseStream<T, S>, R> S assertNCallsOnly(S s, BiFunction<S, Consumer<T>, S> pf, int n) {
+ AtomicInteger boxedInt = new AtomicInteger();
+ return pf.apply(s, i -> {
+ assertFalse(boxedInt.incrementAndGet() > n, "Intermediate op called more than " + n + " time(s)");
+ });
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorTest.java
new file mode 100644
index 0000000..d69c585
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorTest.java
@@ -0,0 +1,64 @@
+/*
+ * 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.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Supplier;
+import java.util.Spliterator;
+import java.util.stream.*;
+
+import static org.testng.Assert.*;
+import static org.testng.Assert.assertEquals;
+
+/**
+ * SpliteratorTest
+ *
+ * @author Brian Goetz
+ */
+@Test
+public class SpliteratorTest {
+
+ @Test(dataProvider = "Spliterator<Integer>", dataProviderClass = StreamTestDataProvider.class )
+ public void testSpliterator(String name, Supplier<Spliterator<Integer>> supplier) {
+ SpliteratorTestHelper.testSpliterator(supplier);
+ }
+
+ @Test(dataProvider = "IntSpliterator", dataProviderClass = IntStreamTestDataProvider.class )
+ public void testIntSpliterator(String name, Supplier<Spliterator.OfInt> supplier) {
+ SpliteratorTestHelper.testIntSpliterator(supplier);
+ }
+
+ @Test(dataProvider = "LongSpliterator", dataProviderClass = LongStreamTestDataProvider.class )
+ public void testLongSpliterator(String name, Supplier<Spliterator.OfLong> supplier) {
+ SpliteratorTestHelper.testLongSpliterator(supplier);
+ }
+
+ @Test(dataProvider = "DoubleSpliterator", dataProviderClass = DoubleStreamTestDataProvider.class )
+ public void testDoubleSpliterator(String name, Supplier<Spliterator.OfDouble> supplier) {
+ SpliteratorTestHelper.testDoubleSpliterator(supplier);
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamBuilderTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamBuilderTest.java
new file mode 100644
index 0000000..d8d46fd
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamBuilderTest.java
@@ -0,0 +1,318 @@
+/*
+ * 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 org.openjdk.tests.java.util.stream;
+
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+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.TestData;
+
+import static java.util.stream.Collectors.toList;
+
+@Test
+public class StreamBuilderTest extends OpTestCase {
+
+ List<Integer> sizes = Arrays.asList(0, 1, 4, 16, 256,
+ 1023, 1024, 1025,
+ 2047, 2048, 2049,
+ 1024 * 32 - 1, 1024 * 32, 1024 * 32 + 1);
+
+ @DataProvider(name = "sizes")
+ public Object[][] createStreamBuilders() {
+ return sizes.stream().map(i -> new Object[] { i }).toArray(Object[][]::new);
+ }
+
+ private void checkException(Class<? extends Exception> ce, Runnable r) {
+ Exception caught = null;
+ try {
+ r.run();
+ } catch (Exception e) {
+ caught = e;
+ }
+
+ assertNotNull(caught);
+ assertTrue(ce.isInstance(caught));
+ }
+
+ private void checkISE(Runnable r) {
+ checkException(IllegalStateException.class, r);
+ }
+
+ //
+
+ @Test
+ public void testSingleton() {
+ TestData.OfRef<Integer> data = TestData.Factory.ofSupplier("[0, 1)",
+ () -> Stream.of(1));
+
+ withData(data).
+ stream(s -> s).
+ expectedResult(Collections.singletonList(1)).
+ exercise();
+
+ withData(data).
+ stream(s -> s.map(LambdaTestHelpers.identity())).
+ expectedResult(Collections.singletonList(1)).
+ exercise();
+ }
+
+ @Test(dataProvider = "sizes")
+ public void testAfterBuilding(int size) {
+ Stream.Builder<Integer> sb = Stream.builder();
+ IntStream.range(0, size).boxed().forEach(sb);
+ sb.build();
+
+ checkISE(() -> sb.accept(1));
+ checkISE(() -> sb.add(1));
+ checkISE(() -> sb.build());
+ }
+
+ @Test(dataProvider = "sizes", groups = { "serialization-hostile" })
+ public void testStreamBuilder(int size) {
+ testStreamBuilder(size, (s) -> {
+ Stream.Builder<Integer> sb = Stream.builder();
+ IntStream.range(0, s).boxed().forEach(sb);
+ return sb.build();
+ });
+
+ testStreamBuilder(size, (s) -> {
+ Stream.Builder<Integer> sb = Stream.builder();
+ IntStream.range(0, s).boxed().forEach(i -> {
+ Stream.Builder<Integer> _sb = sb.add(i);
+ assertTrue(sb == _sb);
+ });
+ return sb.build();
+ });
+ }
+
+ private void testStreamBuilder(int size, Function<Integer, Stream<Integer>> supplier) {
+ TestData.OfRef<Integer> data = TestData.Factory.ofSupplier(String.format("[0, %d)", size),
+ () -> supplier.apply(size));
+
+ withData(data).
+ stream(s -> s).
+ expectedResult(IntStream.range(0, size).boxed().collect(toList())).
+ exercise();
+
+ withData(data).
+ stream(s -> s.map(LambdaTestHelpers.identity())).
+ expectedResult(IntStream.range(0, size).boxed().collect(toList())).
+ exercise();
+ }
+
+ //
+
+ @Test
+ public void testIntSingleton() {
+ TestData.OfInt data = TestData.Factory.ofIntSupplier("[0, 1)",
+ () -> IntStream.of(1));
+
+ withData(data).
+ stream(s -> s).
+ expectedResult(Collections.singletonList(1)).
+ exercise();
+
+ withData(data).
+ stream(s -> s.map(i -> i)).
+ expectedResult(Collections.singletonList(1)).
+ exercise();
+ }
+
+ @Test(dataProvider = "sizes")
+ public void testIntAfterBuilding(int size) {
+ IntStream.Builder sb = IntStream.builder();
+ IntStream.range(0, size).forEach(sb);
+ sb.build();
+
+ checkISE(() -> sb.accept(1));
+ checkISE(() -> sb.add(1));
+ checkISE(() -> sb.build());
+ }
+
+ @Test(dataProvider = "sizes", groups = { "serialization-hostile" })
+ public void testIntStreamBuilder(int size) {
+ testIntStreamBuilder(size, (s) -> {
+ IntStream.Builder sb = IntStream.builder();
+ IntStream.range(0, s).forEach(sb);
+ return sb.build();
+ });
+
+ testIntStreamBuilder(size, (s) -> {
+ IntStream.Builder sb = IntStream.builder();
+ IntStream.range(0, s).forEach(i -> {
+ IntStream.Builder _sb = sb.add(i);
+ assertTrue(sb == _sb);
+ });
+ return sb.build();
+ });
+ }
+
+ private void testIntStreamBuilder(int size, Function<Integer, IntStream> supplier) {
+ TestData.OfInt data = TestData.Factory.ofIntSupplier(String.format("[0, %d)", size),
+ () -> supplier.apply(size));
+
+ withData(data).
+ stream(s -> s).
+ expectedResult(IntStream.range(0, size).toArray()).
+ exercise();
+
+ withData(data).
+ stream(s -> s.map(i -> i)).
+ expectedResult(IntStream.range(0, size).toArray()).
+ exercise();
+ }
+
+ //
+
+ @Test
+ public void testLongSingleton() {
+ TestData.OfLong data = TestData.Factory.ofLongSupplier("[0, 1)",
+ () -> LongStream.of(1));
+
+ withData(data).
+ stream(s -> s).
+ expectedResult(Collections.singletonList(1L)).
+ exercise();
+
+ withData(data).
+ stream(s -> s.map(i -> i)).
+ expectedResult(Collections.singletonList(1L)).
+ exercise();
+ }
+
+ @Test(dataProvider = "sizes")
+ public void testLongAfterBuilding(int size) {
+ LongStream.Builder sb = LongStream.builder();
+ LongStream.range(0, size).forEach(sb);
+ sb.build();
+
+ checkISE(() -> sb.accept(1));
+ checkISE(() -> sb.add(1));
+ checkISE(() -> sb.build());
+ }
+
+ @Test(dataProvider = "sizes", groups = { "serialization-hostile" })
+ public void testLongStreamBuilder(int size) {
+ testLongStreamBuilder(size, (s) -> {
+ LongStream.Builder sb = LongStream.builder();
+ LongStream.range(0, s).forEach(sb);
+ return sb.build();
+ });
+
+ testLongStreamBuilder(size, (s) -> {
+ LongStream.Builder sb = LongStream.builder();
+ LongStream.range(0, s).forEach(i -> {
+ LongStream.Builder _sb = sb.add(i);
+ assertTrue(sb == _sb);
+ });
+ return sb.build();
+ });
+ }
+
+ private void testLongStreamBuilder(int size, Function<Integer, LongStream> supplier) {
+ TestData.OfLong data = TestData.Factory.ofLongSupplier(String.format("[0, %d)", size),
+ () -> supplier.apply(size));
+
+ withData(data).
+ stream(s -> s).
+ expectedResult(LongStream.range(0, size).toArray()).
+ exercise();
+
+ withData(data).
+ stream(s -> s.map(i -> i)).
+ expectedResult(LongStream.range(0, size).toArray()).
+ exercise();
+ }
+
+ //
+
+ @Test
+ public void testDoubleSingleton() {
+ TestData.OfDouble data = TestData.Factory.ofDoubleSupplier("[0, 1)", () -> DoubleStream.of(1));
+
+ withData(data).
+ stream(s -> s).
+ expectedResult(Collections.singletonList(1.0)).
+ exercise();
+
+ withData(data).
+ stream(s -> s.map(i -> i)).
+ expectedResult(Collections.singletonList(1.0)).
+ exercise();
+ }
+
+ @Test(dataProvider = "sizes")
+ public void testDoubleAfterBuilding(int size) {
+ DoubleStream.Builder sb = DoubleStream.builder();
+ IntStream.range(0, size).asDoubleStream().forEach(sb);
+ sb.build();
+
+ checkISE(() -> sb.accept(1));
+ checkISE(() -> sb.add(1));
+ checkISE(() -> sb.build());
+ }
+
+ @Test(dataProvider = "sizes", groups = { "serialization-hostile" })
+ public void testDoubleStreamBuilder(int size) {
+ testDoubleStreamBuilder(size, (s) -> {
+ DoubleStream.Builder sb = DoubleStream.builder();
+ IntStream.range(0, s).asDoubleStream().forEach(sb);
+ return sb.build();
+ });
+
+ testDoubleStreamBuilder(size, (s) -> {
+ DoubleStream.Builder sb = DoubleStream.builder();
+ IntStream.range(0, s).asDoubleStream().forEach(i -> {
+ DoubleStream.Builder _sb = sb.add(i);
+ assertTrue(sb == _sb);
+ });
+ return sb.build();
+ });
+ }
+
+ private void testDoubleStreamBuilder(int size, Function<Integer, DoubleStream> supplier) {
+ TestData.OfDouble data = TestData.Factory.ofDoubleSupplier(String.format("[0, %d)", size),
+ () -> supplier.apply(size));
+
+ withData(data).
+ stream(s -> s).
+ expectedResult(IntStream.range(0, size).asDoubleStream().toArray()).
+ exercise();
+
+ withData(data).
+ stream(s -> s.map(i -> i)).
+ expectedResult(IntStream.range(0, size).asDoubleStream().toArray()).
+ exercise();
+ }
+
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamCloseTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamCloseTest.java
new file mode 100644
index 0000000..51ffd4b
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamCloseTest.java
@@ -0,0 +1,166 @@
+/*
+ * 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 org.openjdk.tests.java.util.stream;
+
+import java.util.Arrays;
+import java.util.stream.OpTestCase;
+import java.util.stream.Stream;
+
+import org.testng.annotations.Test;
+
+import static java.util.stream.LambdaTestHelpers.countTo;
+
+/**
+ * StreamCloseTest
+ *
+ * @author Brian Goetz
+ */
+@Test(groups = { "serialization-hostile" })
+public class StreamCloseTest extends OpTestCase {
+ public void testEmptyCloseHandler() {
+ try (Stream<Integer> ints = countTo(100).stream()) {
+ ints.forEach(i -> {});
+ }
+ }
+
+ public void testOneCloseHandler() {
+ final boolean[] holder = new boolean[1];
+ Runnable closer = () -> { holder[0] = true; };
+
+ try (Stream<Integer> ints = countTo(100).stream()) {
+ ints.onClose(closer);
+ ints.forEach(i -> {});
+ }
+ assertTrue(holder[0]);
+
+ Arrays.fill(holder, false);
+ try (Stream<Integer> ints = countTo(100).stream().onClose(closer)) {
+ ints.forEach(i -> {});
+ }
+ assertTrue(holder[0]);
+
+ Arrays.fill(holder, false);
+ try (Stream<Integer> ints = countTo(100).stream().filter(e -> true).onClose(closer)) {
+ ints.forEach(i -> {});
+ }
+ assertTrue(holder[0]);
+
+ Arrays.fill(holder, false);
+ try (Stream<Integer> ints = countTo(100).stream().filter(e -> true).onClose(closer).filter(e -> true)) {
+ ints.forEach(i -> {});
+ }
+ assertTrue(holder[0]);
+ }
+
+ public void testTwoCloseHandlers() {
+ final boolean[] holder = new boolean[2];
+ Runnable close1 = () -> { holder[0] = true; };
+ Runnable close2 = () -> { holder[1] = true; };
+
+ try (Stream<Integer> ints = countTo(100).stream()) {
+ ints.onClose(close1).onClose(close2);
+ ints.forEach(i -> {});
+ }
+ assertTrue(holder[0] && holder[1]);
+
+ Arrays.fill(holder, false);
+ try (Stream<Integer> ints = countTo(100).stream().onClose(close1).onClose(close2)) {
+ ints.forEach(i -> {});
+ }
+ assertTrue(holder[0] && holder[1]);
+
+ Arrays.fill(holder, false);
+ try (Stream<Integer> ints = countTo(100).stream().filter(e -> true).onClose(close1).onClose(close2)) {
+ ints.forEach(i -> {});
+ }
+ assertTrue(holder[0] && holder[1]);
+
+ Arrays.fill(holder, false);
+ try (Stream<Integer> ints = countTo(100).stream().filter(e -> true).onClose(close1).onClose(close2).filter(e -> true)) {
+ ints.forEach(i -> {});
+ }
+ assertTrue(holder[0] && holder[1]);
+ }
+
+ public void testCascadedExceptions() {
+ final boolean[] holder = new boolean[3];
+ boolean caught = false;
+ Runnable close1 = () -> { holder[0] = true; throw new RuntimeException("1"); };
+ Runnable close2 = () -> { holder[1] = true; throw new RuntimeException("2"); };
+ Runnable close3 = () -> { holder[2] = true; throw new RuntimeException("3"); };
+
+ try (Stream<Integer> ints = countTo(100).stream()) {
+ ints.onClose(close1).onClose(close2).onClose(close3);
+ ints.forEach(i -> {});
+ }
+ catch (RuntimeException e) {
+ assertCascaded(e, 3);
+ assertTrue(holder[0] && holder[1] && holder[2]);
+ caught = true;
+ }
+ assertTrue(caught);
+
+ Arrays.fill(holder, false);
+ caught = false;
+ try (Stream<Integer> ints = countTo(100).stream().onClose(close1).onClose(close2).onClose(close3)) {
+ ints.forEach(i -> {});
+ }
+ catch (RuntimeException e) {
+ assertCascaded(e, 3);
+ assertTrue(holder[0] && holder[1] && holder[2]);
+ caught = true;
+ }
+ assertTrue(caught);
+
+ caught = false;
+ Arrays.fill(holder, false);
+ try (Stream<Integer> ints = countTo(100).stream().filter(e -> true).onClose(close1).onClose(close2).onClose(close3)) {
+ ints.forEach(i -> {});
+ }
+ catch (RuntimeException e) {
+ assertCascaded(e, 3);
+ assertTrue(holder[0] && holder[1] && holder[2]);
+ caught = true;
+ }
+ assertTrue(caught);
+
+ caught = false;
+ Arrays.fill(holder, false);
+ try (Stream<Integer> ints = countTo(100).stream().filter(e -> true).onClose(close1).onClose(close2).filter(e -> true).onClose(close3)) {
+ ints.forEach(i -> {});
+ }
+ catch (RuntimeException e) {
+ assertCascaded(e, 3);
+ assertTrue(holder[0] && holder[1] && holder[2]);
+ caught = true;
+ }
+ assertTrue(caught);
+ }
+
+ private void assertCascaded(RuntimeException e, int n) {
+ assertTrue(e.getMessage().equals("1"));
+ assertTrue(e.getSuppressed().length == n - 1);
+ for (int i=0; i<n-1; i++)
+ assertTrue(e.getSuppressed()[i].getMessage().equals(String.valueOf(i + 2)));
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamLinkTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamLinkTest.java
new file mode 100644
index 0000000..b4cae89
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamLinkTest.java
@@ -0,0 +1,104 @@
+/*
+ * 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 java.util.stream.*;
+
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Function;
+
+@Test
+public class StreamLinkTest extends OpTestCase {
+
+ private <S> Function<S, S> apply(int n, Function<S, S> f) {
+ return s -> {
+ for (int i = 0; i < n; i++) {
+ s = f.apply(s);
+ }
+ return s;
+ };
+ }
+
+ private List<Integer> sizes = Arrays.asList(0, 1, 2, 3, 4, 5, 255, 1000);
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testManyStreams(String name, TestData.OfRef<Integer> data) {
+ for (int n : sizes) {
+ setContext("n", n);
+ List<Integer> expected = data.stream().map(e -> (Integer) (e + n)).collect(Collectors.toList());
+
+ withData(data).
+ stream(apply(n, (Stream<Integer> s) -> s.map(e -> (Integer) (e + 1)))).
+ expectedResult(expected).
+ exercise();
+ }
+ }
+
+ @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).
+ stream(apply(n, (IntStream s) -> s.map(e -> e + 1))).
+ expectedResult(expected).
+ exercise();
+ }
+ }
+
+ @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).
+ stream(apply(n, (LongStream s) -> s.map(e -> e + 1L))).
+ expectedResult(expected).
+ exercise();
+ }
+ }
+
+ @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).
+ stream(apply(n, (DoubleStream s) -> s.map(e -> e + 1.0))).
+ expectedResult(expected).
+ exercise();
+ }
+ }
+ private double accumulate(double e, int n) {
+ while (n-- > 0) {
+ e = e + 1.0;
+ }
+ return e;
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamParSeqTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamParSeqTest.java
new file mode 100644
index 0000000..650edc1
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamParSeqTest.java
@@ -0,0 +1,52 @@
+/*
+ * 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 org.openjdk.tests.java.util.stream;
+
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.stream.Stream;
+
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertTrue;
+
+@Test
+public class StreamParSeqTest {
+
+ public void testParSeq() {
+ Stream<Integer> s = Arrays.asList(1, 2, 3, 4).stream().parallel();
+ assertTrue(s.isParallel());
+
+ s = s.sequential();
+ assertFalse(s.isParallel());
+
+ s = s.sequential();
+ assertFalse(s.isParallel());
+
+ s = s.parallel();
+ assertTrue(s.isParallel());
+
+ s = s.parallel();
+ assertTrue(s.isParallel());
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamSpliteratorTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamSpliteratorTest.java
new file mode 100644
index 0000000..f373978
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamSpliteratorTest.java
@@ -0,0 +1,616 @@
+/*
+ * 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 java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+import java.util.function.DoubleConsumer;
+import java.util.function.Function;
+import java.util.function.IntConsumer;
+import java.util.function.LongConsumer;
+import java.util.function.UnaryOperator;
+import java.util.stream.DoubleStream;
+import java.util.stream.DoubleStreamTestDataProvider;
+import java.util.stream.IntStream;
+import java.util.stream.IntStreamTestDataProvider;
+import java.util.stream.LambdaTestHelpers;
+import java.util.stream.LongStream;
+import java.util.stream.LongStreamTestDataProvider;
+import java.util.stream.OpTestCase;
+import java.util.stream.SpliteratorTestHelper;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+import java.util.stream.StreamTestDataProvider;
+import java.util.stream.TestData;
+
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import static java.util.stream.LambdaTestHelpers.countTo;
+import static java.util.stream.LambdaTestHelpers.dpEven;
+import static java.util.stream.LambdaTestHelpers.ipEven;
+import static java.util.stream.LambdaTestHelpers.irDoubler;
+import static java.util.stream.LambdaTestHelpers.lpEven;
+import static java.util.stream.LambdaTestHelpers.mDoubler;
+import static java.util.stream.LambdaTestHelpers.pEven;
+import static java.util.stream.LambdaTestHelpers.permuteStreamFunctions;
+
+@Test
+public class StreamSpliteratorTest extends OpTestCase {
+
+ private static class ProxyNoExactSizeSpliterator<T> implements Spliterator<T> {
+ final Spliterator<T> sp;
+ final boolean proxyEstimateSize;
+ int splits = 0;
+ int prefixSplits = 0;
+
+ long sizeOnTraversal = -1;
+
+ ProxyNoExactSizeSpliterator(Spliterator<T> sp, boolean proxyEstimateSize) {
+ this.sp = sp;
+ this.proxyEstimateSize = proxyEstimateSize;
+ }
+
+ @Override
+ public Spliterator<T> trySplit() {
+ splits++;
+ Spliterator<T> prefix = sp.trySplit();
+ if (prefix != null)
+ prefixSplits++;
+ return prefix;
+ }
+
+ @Override
+ public boolean tryAdvance(Consumer<? super T> consumer) {
+ if (sizeOnTraversal == -1)
+ sizeOnTraversal = sp.getExactSizeIfKnown();
+ return sp.tryAdvance(consumer);
+ }
+
+ @Override
+ public void forEachRemaining(Consumer<? super T> consumer) {
+ sizeOnTraversal = sp.getExactSizeIfKnown();
+ sp.forEachRemaining(consumer);
+ }
+
+ @Override
+ public long estimateSize() {
+ return proxyEstimateSize ? sp.estimateSize() : Long.MAX_VALUE;
+ }
+
+ @Override
+ public Comparator<? super T> getComparator() {
+ return sp.getComparator();
+ }
+
+ @Override
+ public int characteristics() {
+ if (proxyEstimateSize)
+ return sp.characteristics();
+ else
+ return sp.characteristics() & ~(Spliterator.SUBSIZED | Spliterator.SIZED);
+ }
+
+ private static class OfInt extends ProxyNoExactSizeSpliterator<Integer> implements Spliterator.OfInt {
+ final Spliterator.OfInt psp;
+
+ private OfInt(Spliterator.OfInt sp, boolean proxyEstimateSize) {
+ super(sp, proxyEstimateSize);
+ this.psp = sp;
+ }
+
+ @Override
+ public Spliterator.OfInt trySplit() {
+ splits++;
+ Spliterator.OfInt prefix = psp.trySplit();
+ if (prefix != null)
+ prefixSplits++;
+ return prefix;
+ }
+
+ @Override
+ public boolean tryAdvance(Consumer<? super Integer> consumer) {
+ return Spliterator.OfInt.super.tryAdvance(consumer);
+ }
+
+ @Override
+ public void forEachRemaining(Consumer<? super Integer> consumer) {
+ Spliterator.OfInt.super.forEachRemaining(consumer);
+ }
+
+ @Override
+ public boolean tryAdvance(IntConsumer consumer) {
+ if (sizeOnTraversal == -1)
+ sizeOnTraversal = sp.getExactSizeIfKnown();
+ return psp.tryAdvance(consumer);
+ }
+
+ @Override
+ public void forEachRemaining(IntConsumer consumer) {
+ sizeOnTraversal = sp.getExactSizeIfKnown();
+ psp.forEachRemaining(consumer);
+ }
+ }
+
+ private static class OfLong extends ProxyNoExactSizeSpliterator<Long> implements Spliterator.OfLong {
+ final Spliterator.OfLong psp;
+
+ private OfLong(Spliterator.OfLong sp, boolean proxyEstimateSize) {
+ super(sp, proxyEstimateSize);
+ this.psp = sp;
+ }
+
+ @Override
+ public Spliterator.OfLong trySplit() {
+ splits++;
+ Spliterator.OfLong prefix = psp.trySplit();
+ if (prefix != null)
+ prefixSplits++;
+ return prefix;
+ }
+
+ @Override
+ public boolean tryAdvance(Consumer<? super Long> consumer) {
+ return Spliterator.OfLong.super.tryAdvance(consumer);
+ }
+
+ @Override
+ public void forEachRemaining(Consumer<? super Long> consumer) {
+ Spliterator.OfLong.super.forEachRemaining(consumer);
+ }
+
+ @Override
+ public boolean tryAdvance(LongConsumer consumer) {
+ if (sizeOnTraversal == -1)
+ sizeOnTraversal = sp.getExactSizeIfKnown();
+ return psp.tryAdvance(consumer);
+ }
+
+ @Override
+ public void forEachRemaining(LongConsumer consumer) {
+ sizeOnTraversal = sp.getExactSizeIfKnown();
+ psp.forEachRemaining(consumer);
+ }
+ }
+
+ private static class OfDouble extends ProxyNoExactSizeSpliterator<Double>
+ implements Spliterator.OfDouble {
+ final Spliterator.OfDouble psp;
+
+ private OfDouble(Spliterator.OfDouble sp, boolean proxyEstimateSize) {
+ super(sp, proxyEstimateSize);
+ this.psp = sp;
+ }
+
+ @Override
+ public Spliterator.OfDouble trySplit() {
+ splits++;
+ Spliterator.OfDouble prefix = psp.trySplit();
+ if (prefix != null)
+ prefixSplits++;
+ return prefix;
+ }
+
+ @Override
+ public boolean tryAdvance(Consumer<? super Double> consumer) {
+ return Spliterator.OfDouble.super.tryAdvance(consumer);
+ }
+
+ @Override
+ public void forEachRemaining(Consumer<? super Double> consumer) {
+ Spliterator.OfDouble.super.forEachRemaining(consumer);
+ }
+
+ @Override
+ public boolean tryAdvance(DoubleConsumer consumer) {
+ if (sizeOnTraversal == -1)
+ sizeOnTraversal = sp.getExactSizeIfKnown();
+ return psp.tryAdvance(consumer);
+ }
+
+ @Override
+ public void forEachRemaining(DoubleConsumer consumer) {
+ sizeOnTraversal = sp.getExactSizeIfKnown();
+ psp.forEachRemaining(consumer);
+ }
+ }
+ }
+
+ public void testSplitting() {
+ // Size is assumed to be larger than the target size for no splitting
+ // @@@ Need way to obtain the target size
+ List<Integer> l = countTo(1000);
+
+ List<Consumer<Stream<Integer>>> terminalOps = Arrays.asList(
+ s -> s.toArray(),
+ s -> s.forEach(e -> { }),
+ s -> s.reduce(Integer::sum)
+ );
+
+ List<UnaryOperator<Stream<Integer>>> intermediateOps = Arrays.asList(
+ s -> s.parallel(),
+ // The following ensures the wrapping spliterator is tested
+ s -> s.map(LambdaTestHelpers.identity()).parallel()
+ );
+
+ for (int i = 0; i < terminalOps.size(); i++) {
+ setContext("termOpIndex", i);
+ Consumer<Stream<Integer>> terminalOp = terminalOps.get(i);
+ for (int j = 0; j < intermediateOps.size(); j++) {
+ setContext("intOpIndex", j);
+ UnaryOperator<Stream<Integer>> intermediateOp = intermediateOps.get(j);
+ for (boolean proxyEstimateSize : new boolean[] {false, true}) {
+ setContext("proxyEstimateSize", proxyEstimateSize);
+ Spliterator<Integer> sp = intermediateOp.apply(l.stream()).spliterator();
+ ProxyNoExactSizeSpliterator<Integer> psp = new ProxyNoExactSizeSpliterator<>(sp, proxyEstimateSize);
+ Stream<Integer> s = StreamSupport.stream(psp, true);
+ terminalOp.accept(s);
+ Assert.assertTrue(psp.splits > 0,
+ String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
+ proxyEstimateSize));
+ Assert.assertTrue(psp.prefixSplits > 0,
+ String.format("Number of non-null prefix splits should be greater that zero when proxyEstimateSize is %s",
+ proxyEstimateSize));
+ Assert.assertTrue(psp.sizeOnTraversal < l.size(),
+ String.format("Size on traversal of last split should be less than the size of the list, %d, when proxyEstimateSize is %s",
+ l.size(), proxyEstimateSize));
+ }
+ }
+ }
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>",
+ dataProviderClass = StreamTestDataProvider.class,
+ groups = { "serialization-hostile" })
+ public void testStreamSpliterators(String name, TestData.OfRef<Integer> data) {
+ for (Function<Stream<Integer>, Stream<Integer>> f : streamFunctions()) {
+ withData(data).
+ stream((Stream<Integer> in) -> {
+ Stream<Integer> out = f.apply(in);
+ return StreamSupport.stream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
+ }).
+ exercise();
+
+ withData(data).
+ stream((Stream<Integer> in) -> {
+ Stream<Integer> out = f.apply(in);
+ return StreamSupport.stream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
+ }).
+ exercise();
+ }
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testSpliterators(String name, TestData.OfRef<Integer> data) {
+ for (Function<Stream<Integer>, Stream<Integer>> f : streamFunctions()) {
+ SpliteratorTestHelper.testSpliterator(() -> f.apply(data.stream()).spliterator());
+ }
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testParSpliterators(String name, TestData.OfRef<Integer> data) {
+ for (Function<Stream<Integer>, Stream<Integer>> f : streamFunctions()) {
+ SpliteratorTestHelper.testSpliterator(() -> f.apply(data.parallelStream()).spliterator());
+ }
+ }
+
+ private List<Function<Stream<Integer>, Stream<Integer>>> streamFunctions;
+
+ List<Function<Stream<Integer>, Stream<Integer>>> streamFunctions() {
+ if (streamFunctions == null) {
+ List<Function<Stream<Integer>, Stream<Integer>>> opFunctions = Arrays.asList(
+ s -> s.filter(pEven),
+ s -> s.map(mDoubler),
+ // @@@ Add distinct once asserting results with or without order
+ // is correctly supported
+// s -> s.distinct(),
+ s -> s.sorted());
+
+ streamFunctions = permuteStreamFunctions(opFunctions);
+ }
+
+ return streamFunctions;
+ }
+
+ //
+
+ public void testIntSplitting() {
+ List<Consumer<IntStream>> terminalOps = Arrays.asList(
+ s -> s.toArray(),
+ s -> s.forEach(e -> {}),
+ s -> s.reduce(Integer::sum)
+ );
+
+ List<UnaryOperator<IntStream>> intermediateOps = Arrays.asList(
+ s -> s.parallel(),
+ // The following ensures the wrapping spliterator is tested
+ s -> s.map(i -> i).parallel()
+ );
+
+ for (int i = 0; i < terminalOps.size(); i++) {
+ setContext("termOpIndex", i);
+ Consumer<IntStream> terminalOp = terminalOps.get(i);
+ for (int j = 0; j < intermediateOps.size(); j++) {
+ setContext("intOpIndex", j);
+ UnaryOperator<IntStream> 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();
+ ProxyNoExactSizeSpliterator.OfInt psp = new ProxyNoExactSizeSpliterator.OfInt(sp, proxyEstimateSize);
+ IntStream s = StreamSupport.intStream(psp, true);
+ terminalOp.accept(s);
+ Assert.assertTrue(psp.splits > 0,
+ String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
+ proxyEstimateSize));
+ Assert.assertTrue(psp.prefixSplits > 0,
+ String.format("Number of non-null prefix splits should be greater that zero when proxyEstimateSize is %s",
+ proxyEstimateSize));
+ Assert.assertTrue(psp.sizeOnTraversal < 1000,
+ String.format("Size on traversal of last split should be less than the size of the list, %d, when proxyEstimateSize is %s",
+ 1000, proxyEstimateSize));
+ }
+ }
+ }
+ }
+
+ @Test(dataProvider = "IntStreamTestData",
+ dataProviderClass = IntStreamTestDataProvider.class,
+ groups = { "serialization-hostile" })
+ public void testIntStreamSpliterators(String name, TestData.OfInt data) {
+ for (Function<IntStream, IntStream> f : intStreamFunctions()) {
+ withData(data).
+ stream(in -> {
+ IntStream out = f.apply(in);
+ return StreamSupport.intStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
+ }).
+ exercise();
+
+ withData(data).
+ stream((in) -> {
+ IntStream out = f.apply(in);
+ return StreamSupport.intStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
+ }).
+ exercise();
+ }
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testIntSpliterators(String name, TestData.OfInt data) {
+ for (Function<IntStream, IntStream> f : intStreamFunctions()) {
+ SpliteratorTestHelper.testIntSpliterator(() -> f.apply(data.stream()).spliterator());
+ }
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testIntParSpliterators(String name, TestData.OfInt data) {
+ for (Function<IntStream, IntStream> f : intStreamFunctions()) {
+ SpliteratorTestHelper.testIntSpliterator(() -> f.apply(data.parallelStream()).spliterator());
+ }
+ }
+
+ private List<Function<IntStream, IntStream>> intStreamFunctions;
+
+ List<Function<IntStream, IntStream>> intStreamFunctions() {
+ if (intStreamFunctions == null) {
+ List<Function<IntStream, IntStream>> opFunctions = Arrays.asList(
+ s -> s.filter(ipEven),
+ s -> s.map(irDoubler),
+ s -> s.sorted());
+
+ intStreamFunctions = permuteStreamFunctions(opFunctions);
+ }
+
+ return intStreamFunctions;
+ }
+
+ //
+
+ public void testLongSplitting() {
+ List<Consumer<LongStream>> terminalOps = Arrays.asList(
+ s -> s.toArray(),
+ s -> s.forEach(e -> {}),
+ s -> s.reduce(Long::sum)
+ );
+
+ List<UnaryOperator<LongStream>> intermediateOps = Arrays.asList(
+ s -> s.parallel(),
+ // The following ensures the wrapping spliterator is tested
+ s -> s.map(i -> i).parallel()
+ );
+
+ for (int i = 0; i < terminalOps.size(); i++) {
+ Consumer<LongStream> terminalOp = terminalOps.get(i);
+ setContext("termOpIndex", i);
+ for (int j = 0; j < intermediateOps.size(); j++) {
+ setContext("intOpIndex", j);
+ UnaryOperator<LongStream> 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();
+ ProxyNoExactSizeSpliterator.OfLong psp = new ProxyNoExactSizeSpliterator.OfLong(sp, proxyEstimateSize);
+ LongStream s = StreamSupport.longStream(psp, true);
+ terminalOp.accept(s);
+ Assert.assertTrue(psp.splits > 0,
+ String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
+ proxyEstimateSize));
+ Assert.assertTrue(psp.prefixSplits > 0,
+ String.format("Number of non-null prefix splits should be greater that zero when proxyEstimateSize is %s",
+ proxyEstimateSize));
+ Assert.assertTrue(psp.sizeOnTraversal < 1000,
+ String.format("Size on traversal of last split should be less than the size of the list, %d, when proxyEstimateSize is %s",
+ 1000, proxyEstimateSize));
+ }
+ }
+ }
+ }
+
+ @Test(dataProvider = "LongStreamTestData",
+ dataProviderClass = LongStreamTestDataProvider.class,
+ groups = { "serialization-hostile" })
+ public void testLongStreamSpliterators(String name, TestData.OfLong data) {
+ for (Function<LongStream, LongStream> f : longStreamFunctions()) {
+ withData(data).
+ stream(in -> {
+ LongStream out = f.apply(in);
+ return StreamSupport.longStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
+ }).
+ exercise();
+
+ withData(data).
+ stream((in) -> {
+ LongStream out = f.apply(in);
+ return StreamSupport.longStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
+ }).
+ exercise();
+ }
+ }
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testLongSpliterators(String name, TestData.OfLong data) {
+ for (Function<LongStream, LongStream> f : longStreamFunctions()) {
+ SpliteratorTestHelper.testLongSpliterator(() -> f.apply(data.stream()).spliterator());
+ }
+ }
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testLongParSpliterators(String name, TestData.OfLong data) {
+ for (Function<LongStream, LongStream> f : longStreamFunctions()) {
+ SpliteratorTestHelper.testLongSpliterator(() -> f.apply(data.parallelStream()).spliterator());
+ }
+ }
+
+ private List<Function<LongStream, LongStream>> longStreamFunctions;
+
+ List<Function<LongStream, LongStream>> longStreamFunctions() {
+ if (longStreamFunctions == null) {
+ List<Function<LongStream, LongStream>> opFunctions = Arrays.asList(
+ s -> s.filter(lpEven),
+ s -> s.map(x -> x * 2L),
+ s -> s.sorted());
+
+ longStreamFunctions = permuteStreamFunctions(opFunctions);
+ }
+
+ return longStreamFunctions;
+ }
+
+ //
+
+ public void testDoubleSplitting() {
+ List<Consumer<DoubleStream>> terminalOps = Arrays.asList(
+ s -> s.toArray(),
+ s -> s.forEach(e -> {}),
+ s -> s.reduce(Double::sum)
+ );
+
+ List<UnaryOperator<DoubleStream>> intermediateOps = Arrays.asList(
+ s -> s.parallel(),
+ // The following ensures the wrapping spliterator is tested
+ s -> s.map(i -> i).parallel()
+ );
+
+ for (int i = 0; i < terminalOps.size(); i++) {
+ Consumer<DoubleStream> terminalOp = terminalOps.get(i);
+ setContext("termOpIndex", i);
+ for (int j = 0; j < intermediateOps.size(); j++) {
+ UnaryOperator<DoubleStream> 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();
+ ProxyNoExactSizeSpliterator.OfDouble psp = new ProxyNoExactSizeSpliterator.OfDouble(sp, proxyEstimateSize);
+ DoubleStream s = StreamSupport.doubleStream(psp, true);
+ terminalOp.accept(s);
+ Assert.assertTrue(psp.splits > 0,
+ String.format("Number of splits should be greater that zero when proxyEstimateSize is %s",
+ proxyEstimateSize));
+ Assert.assertTrue(psp.prefixSplits > 0,
+ String.format("Number of non-null prefix splits should be greater that zero when proxyEstimateSize is %s",
+ proxyEstimateSize));
+ Assert.assertTrue(psp.sizeOnTraversal < 1000,
+ String.format("Size on traversal of last split should be less than the size of the list, %d, when proxyEstimateSize is %s",
+ 1000, proxyEstimateSize));
+ }
+ }
+ }
+ }
+
+ @Test(dataProvider = "DoubleStreamTestData",
+ dataProviderClass = DoubleStreamTestDataProvider.class,
+ groups = { "serialization-hostile" })
+ public void testDoubleStreamSpliterators(String name, TestData.OfDouble data) {
+ for (Function<DoubleStream, DoubleStream> f : doubleStreamFunctions()) {
+ withData(data).
+ stream(in -> {
+ DoubleStream out = f.apply(in);
+ return StreamSupport.doubleStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false);
+ }).
+ exercise();
+
+ withData(data).
+ stream((in) -> {
+ DoubleStream out = f.apply(in);
+ return StreamSupport.doubleStream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true);
+ }).
+ exercise();
+ }
+ }
+
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testDoubleSpliterators(String name, TestData.OfDouble data) {
+ for (Function<DoubleStream, DoubleStream> f : doubleStreamFunctions()) {
+ SpliteratorTestHelper.testDoubleSpliterator(() -> f.apply(data.stream()).spliterator());
+ }
+ }
+
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testDoubleParSpliterators(String name, TestData.OfDouble data) {
+ for (Function<DoubleStream, DoubleStream> f : doubleStreamFunctions()) {
+ SpliteratorTestHelper.testDoubleSpliterator(() -> f.apply(data.parallelStream()).spliterator());
+ }
+ }
+
+ private List<Function<DoubleStream, DoubleStream>> doubleStreamFunctions;
+
+ List<Function<DoubleStream, DoubleStream>> doubleStreamFunctions() {
+ if (doubleStreamFunctions == null) {
+ List<Function<DoubleStream, DoubleStream>> opFunctions = Arrays.asList(
+ s -> s.filter(dpEven),
+ s -> s.map(x -> x * 2.0),
+ s -> s.sorted());
+
+ doubleStreamFunctions = permuteStreamFunctions(opFunctions);
+ }
+
+ return doubleStreamFunctions;
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SummaryStatisticsTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SummaryStatisticsTest.java
new file mode 100644
index 0000000..3850b83
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SummaryStatisticsTest.java
@@ -0,0 +1,88 @@
+/*
+ * 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 java.util.ArrayList;
+import java.util.DoubleSummaryStatistics;
+import java.util.IntSummaryStatistics;
+import java.util.List;
+import java.util.LongSummaryStatistics;
+import java.util.stream.Collectors;
+import java.util.stream.OpTestCase;
+
+import org.testng.annotations.Test;
+
+import static java.util.stream.LambdaTestHelpers.countTo;
+
+/**
+ * TestSummaryStatistics
+ *
+ * @author Brian Goetz
+ */
+@Test
+public class SummaryStatisticsTest extends OpTestCase {
+ public void testIntStatistics() {
+ List<IntSummaryStatistics> instances = new ArrayList<>();
+ instances.add(countTo(1000).stream().collect(Collectors.summarizingInt(i -> i)));
+ instances.add(countTo(1000).stream().mapToInt(i -> i).summaryStatistics());
+ instances.add(countTo(1000).parallelStream().collect(Collectors.summarizingInt(i -> i)));
+ instances.add(countTo(1000).parallelStream().mapToInt(i -> i).summaryStatistics());
+
+ for (IntSummaryStatistics stats : instances) {
+ assertEquals(stats.getCount(), 1000);
+ assertEquals(stats.getSum(), countTo(1000).stream().mapToInt(i -> i).sum());
+ assertEquals(stats.getMax(), 1000);
+ assertEquals(stats.getMin(), 1);
+ }
+ }
+
+ public void testLongStatistics() {
+ List<LongSummaryStatistics> instances = new ArrayList<>();
+ instances.add(countTo(1000).stream().collect(Collectors.summarizingLong(i -> i)));
+ instances.add(countTo(1000).stream().mapToLong(i -> i).summaryStatistics());
+ instances.add(countTo(1000).parallelStream().collect(Collectors.summarizingLong(i -> i)));
+ instances.add(countTo(1000).parallelStream().mapToLong(i -> i).summaryStatistics());
+
+ for (LongSummaryStatistics stats : instances) {
+ assertEquals(stats.getCount(), 1000);
+ assertEquals(stats.getSum(), (long) countTo(1000).stream().mapToInt(i -> i).sum());
+ assertEquals(stats.getMax(), 1000L);
+ assertEquals(stats.getMin(), 1L);
+ }
+ }
+
+ public void testDoubleStatistics() {
+ List<DoubleSummaryStatistics> instances = new ArrayList<>();
+ instances.add(countTo(1000).stream().collect(Collectors.summarizingDouble(i -> i)));
+ instances.add(countTo(1000).stream().mapToDouble(i -> i).summaryStatistics());
+ instances.add(countTo(1000).parallelStream().collect(Collectors.summarizingDouble(i -> i)));
+ instances.add(countTo(1000).parallelStream().mapToDouble(i -> i).summaryStatistics());
+
+ for (DoubleSummaryStatistics stats : instances) {
+ assertEquals(stats.getCount(), 1000);
+ assertEquals(stats.getSum(), (double) countTo(1000).stream().mapToInt(i -> i).sum());
+ assertEquals(stats.getMax(), 1000.0);
+ assertEquals(stats.getMin(), 1.0);
+ }
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java
new file mode 100644
index 0000000..f539df5
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java
@@ -0,0 +1,621 @@
+/*
+ * 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 java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.StringJoiner;
+import java.util.TreeMap;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentSkipListMap;
+import java.util.function.BinaryOperator;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
+import java.util.stream.LambdaTestHelpers;
+import java.util.stream.OpTestCase;
+import java.util.stream.Stream;
+import java.util.stream.StreamOpFlagTestHelper;
+import java.util.stream.StreamTestDataProvider;
+import java.util.stream.TestData;
+
+import org.testng.annotations.Test;
+
+import static java.util.stream.Collectors.collectingAndThen;
+import static java.util.stream.Collectors.groupingBy;
+import static java.util.stream.Collectors.groupingByConcurrent;
+import static java.util.stream.Collectors.partitioningBy;
+import static java.util.stream.Collectors.reducing;
+import static java.util.stream.Collectors.toCollection;
+import static java.util.stream.Collectors.toConcurrentMap;
+import static java.util.stream.Collectors.toList;
+import static java.util.stream.Collectors.toMap;
+import static java.util.stream.Collectors.toSet;
+import static java.util.stream.LambdaTestHelpers.assertContents;
+import static java.util.stream.LambdaTestHelpers.assertContentsUnordered;
+import static java.util.stream.LambdaTestHelpers.mDoubler;
+
+/**
+ * TabulatorsTest
+ *
+ * @author Brian Goetz
+ */
+@SuppressWarnings({"rawtypes", "unchecked"})
+public class TabulatorsTest extends OpTestCase {
+
+ private static abstract class TabulationAssertion<T, U> {
+ abstract void assertValue(U value,
+ Supplier<Stream<T>> source,
+ boolean ordered) throws ReflectiveOperationException;
+ }
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ static class GroupedMapAssertion<T, K, V, M extends Map<K, ? extends V>> extends TabulationAssertion<T, M> {
+ private final Class<? extends Map> clazz;
+ private final Function<T, K> classifier;
+ private final TabulationAssertion<T,V> downstream;
+
+ protected GroupedMapAssertion(Function<T, K> classifier,
+ Class<? extends Map> clazz,
+ TabulationAssertion<T, V> downstream) {
+ this.clazz = clazz;
+ this.classifier = classifier;
+ this.downstream = downstream;
+ }
+
+ void assertValue(M map,
+ Supplier<Stream<T>> source,
+ boolean ordered) throws ReflectiveOperationException {
+ if (!clazz.isAssignableFrom(map.getClass()))
+ fail(String.format("Class mismatch in GroupedMapAssertion: %s, %s", clazz, map.getClass()));
+ assertContentsUnordered(map.keySet(), source.get().map(classifier).collect(toSet()));
+ for (Map.Entry<K, ? extends V> entry : map.entrySet()) {
+ K key = entry.getKey();
+ downstream.assertValue(entry.getValue(),
+ () -> source.get().filter(e -> classifier.apply(e).equals(key)),
+ ordered);
+ }
+ }
+ }
+
+ static class ToMapAssertion<T, K, V, M extends Map<K,V>> extends TabulationAssertion<T, M> {
+ private final Class<? extends Map> clazz;
+ private final Function<T, K> keyFn;
+ private final Function<T, V> valueFn;
+ private final BinaryOperator<V> mergeFn;
+
+ ToMapAssertion(Function<T, K> keyFn,
+ Function<T, V> valueFn,
+ BinaryOperator<V> mergeFn,
+ Class<? extends Map> clazz) {
+ this.clazz = clazz;
+ this.keyFn = keyFn;
+ this.valueFn = valueFn;
+ this.mergeFn = mergeFn;
+ }
+
+ @Override
+ void assertValue(M map, Supplier<Stream<T>> source, boolean ordered) throws ReflectiveOperationException {
+ Set<K> uniqueKeys = source.get().map(keyFn).collect(toSet());
+ assertTrue(clazz.isAssignableFrom(map.getClass()));
+ assertEquals(uniqueKeys, map.keySet());
+ source.get().forEach(t -> {
+ K key = keyFn.apply(t);
+ V v = source.get()
+ .filter(e -> key.equals(keyFn.apply(e)))
+ .map(valueFn)
+ .reduce(mergeFn)
+ .get();
+ assertEquals(map.get(key), v);
+ });
+ }
+ }
+
+ static class PartitionAssertion<T, D> extends TabulationAssertion<T, Map<Boolean,D>> {
+ private final Predicate<T> predicate;
+ private final TabulationAssertion<T,D> downstream;
+
+ protected PartitionAssertion(Predicate<T> predicate,
+ TabulationAssertion<T, D> downstream) {
+ this.predicate = predicate;
+ this.downstream = downstream;
+ }
+
+ void assertValue(Map<Boolean, D> map,
+ Supplier<Stream<T>> source,
+ boolean ordered) throws ReflectiveOperationException {
+ if (!Map.class.isAssignableFrom(map.getClass()))
+ fail(String.format("Class mismatch in PartitionAssertion: %s", map.getClass()));
+ assertEquals(2, map.size());
+ downstream.assertValue(map.get(true), () -> source.get().filter(predicate), ordered);
+ downstream.assertValue(map.get(false), () -> source.get().filter(predicate.negate()), ordered);
+ }
+ }
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ static class ListAssertion<T> extends TabulationAssertion<T, List<T>> {
+ @Override
+ void assertValue(List<T> value, Supplier<Stream<T>> source, boolean ordered)
+ throws ReflectiveOperationException {
+ if (!List.class.isAssignableFrom(value.getClass()))
+ fail(String.format("Class mismatch in ListAssertion: %s", value.getClass()));
+ Stream<T> stream = source.get();
+ List<T> result = new ArrayList<>();
+ for (Iterator<T> it = stream.iterator(); it.hasNext(); ) // avoid capturing result::add
+ result.add(it.next());
+ if (StreamOpFlagTestHelper.isStreamOrdered(stream) && ordered)
+ assertContents(value, result);
+ else
+ assertContentsUnordered(value, result);
+ }
+ }
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ static class CollectionAssertion<T> extends TabulationAssertion<T, Collection<T>> {
+ private final Class<? extends Collection> clazz;
+ private final boolean targetOrdered;
+
+ protected CollectionAssertion(Class<? extends Collection> clazz, boolean targetOrdered) {
+ this.clazz = clazz;
+ this.targetOrdered = targetOrdered;
+ }
+
+ @Override
+ void assertValue(Collection<T> value, Supplier<Stream<T>> source, boolean ordered)
+ throws ReflectiveOperationException {
+ if (!clazz.isAssignableFrom(value.getClass()))
+ fail(String.format("Class mismatch in CollectionAssertion: %s, %s", clazz, value.getClass()));
+ Stream<T> stream = source.get();
+ Collection<T> result = clazz.newInstance();
+ for (Iterator<T> it = stream.iterator(); it.hasNext(); ) // avoid capturing result::add
+ result.add(it.next());
+ if (StreamOpFlagTestHelper.isStreamOrdered(stream) && targetOrdered && ordered)
+ assertContents(value, result);
+ else
+ assertContentsUnordered(value, result);
+ }
+ }
+
+ static class ReduceAssertion<T, U> extends TabulationAssertion<T, U> {
+ private final U identity;
+ private final Function<T, U> mapper;
+ private final BinaryOperator<U> reducer;
+
+ ReduceAssertion(U identity, Function<T, U> mapper, BinaryOperator<U> reducer) {
+ this.identity = identity;
+ this.mapper = mapper;
+ this.reducer = reducer;
+ }
+
+ @Override
+ void assertValue(U value, Supplier<Stream<T>> source, boolean ordered)
+ throws ReflectiveOperationException {
+ Optional<U> reduced = source.get().map(mapper).reduce(reducer);
+ if (value == null)
+ assertTrue(!reduced.isPresent());
+ else if (!reduced.isPresent()) {
+ assertEquals(value, identity);
+ }
+ else {
+ assertEquals(value, reduced.get());
+ }
+ }
+ }
+
+ private <T> ResultAsserter<T> mapTabulationAsserter(boolean ordered) {
+ return (act, exp, ord, par) -> {
+ if (par && (!ordered || !ord)) {
+ TabulatorsTest.nestedMapEqualityAssertion(act, exp);
+ }
+ else {
+ LambdaTestHelpers.assertContentsEqual(act, exp);
+ }
+ };
+ }
+
+ private<T, M extends Map>
+ void exerciseMapTabulation(TestData<T, Stream<T>> data,
+ Collector<T, ?, ? extends M> collector,
+ TabulationAssertion<T, M> assertion)
+ throws ReflectiveOperationException {
+ boolean ordered = !collector.characteristics().contains(Collector.Characteristics.UNORDERED);
+
+ M m = withData(data)
+ .terminal(s -> s.collect(collector))
+ .resultAsserter(mapTabulationAsserter(ordered))
+ .exercise();
+ assertion.assertValue(m, () -> data.stream(), ordered);
+
+ m = withData(data)
+ .terminal(s -> s.unordered().collect(collector))
+ .resultAsserter(mapTabulationAsserter(ordered))
+ .exercise();
+ assertion.assertValue(m, () -> data.stream(), false);
+ }
+
+ private static void nestedMapEqualityAssertion(Object o1, Object o2) {
+ if (o1 instanceof Map) {
+ Map m1 = (Map) o1;
+ Map m2 = (Map) o2;
+ assertContentsUnordered(m1.keySet(), m2.keySet());
+ for (Object k : m1.keySet())
+ nestedMapEqualityAssertion(m1.get(k), m2.get(k));
+ }
+ else if (o1 instanceof Collection) {
+ assertContentsUnordered(((Collection) o1), ((Collection) o2));
+ }
+ else
+ assertEquals(o1, o2);
+ }
+
+ private<T, R> void assertCollect(TestData.OfRef<T> data,
+ Collector<T, ?, R> collector,
+ Function<Stream<T>, R> streamReduction) {
+ R check = streamReduction.apply(data.stream());
+ withData(data).terminal(s -> s.collect(collector)).expectedResult(check).exercise();
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testReduce(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException {
+ assertCollect(data, Collectors.reducing(0, Integer::sum),
+ s -> s.reduce(0, Integer::sum));
+ assertCollect(data, Collectors.reducing(Integer.MAX_VALUE, Integer::min),
+ s -> s.min(Integer::compare).orElse(Integer.MAX_VALUE));
+ assertCollect(data, Collectors.reducing(Integer.MIN_VALUE, Integer::max),
+ s -> s.max(Integer::compare).orElse(Integer.MIN_VALUE));
+
+ assertCollect(data, Collectors.reducing(Integer::sum),
+ s -> s.reduce(Integer::sum));
+ assertCollect(data, Collectors.minBy(Comparator.naturalOrder()),
+ s -> s.min(Integer::compare));
+ assertCollect(data, Collectors.maxBy(Comparator.naturalOrder()),
+ s -> s.max(Integer::compare));
+
+ assertCollect(data, Collectors.reducing(0, x -> x*2, Integer::sum),
+ s -> s.map(x -> x*2).reduce(0, Integer::sum));
+
+ assertCollect(data, Collectors.summingLong(x -> x * 2L),
+ s -> s.map(x -> x*2L).reduce(0L, Long::sum));
+ assertCollect(data, Collectors.summingInt(x -> x * 2),
+ s -> s.map(x -> x*2).reduce(0, Integer::sum));
+ assertCollect(data, Collectors.summingDouble(x -> x * 2.0d),
+ s -> s.map(x -> x * 2.0d).reduce(0.0d, Double::sum));
+
+ assertCollect(data, Collectors.averagingInt(x -> x * 2),
+ s -> s.mapToInt(x -> x * 2).average().orElse(0));
+ assertCollect(data, Collectors.averagingLong(x -> x * 2),
+ s -> s.mapToLong(x -> x * 2).average().orElse(0));
+ assertCollect(data, Collectors.averagingDouble(x -> x * 2),
+ s -> s.mapToDouble(x -> x * 2).average().orElse(0));
+
+ // Test explicit Collector.of
+ Collector<Integer, long[], Double> avg2xint = Collector.of(() -> new long[2],
+ (a, b) -> {
+ a[0] += b * 2;
+ a[1]++;
+ },
+ (a, b) -> {
+ a[0] += b[0];
+ a[1] += b[1];
+ return a;
+ },
+ a -> a[1] == 0 ? 0.0d : (double) a[0] / a[1]);
+ assertCollect(data, avg2xint,
+ s -> s.mapToInt(x -> x * 2).average().orElse(0));
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testJoin(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException {
+ withData(data)
+ .terminal(s -> s.map(Object::toString).collect(Collectors.joining()))
+ .expectedResult(join(data, ""))
+ .exercise();
+
+ Collector<String, StringBuilder, String> likeJoining = Collector.of(StringBuilder::new, StringBuilder::append, (sb1, sb2) -> sb1.append(sb2.toString()), StringBuilder::toString);
+ withData(data)
+ .terminal(s -> s.map(Object::toString).collect(likeJoining))
+ .expectedResult(join(data, ""))
+ .exercise();
+
+ withData(data)
+ .terminal(s -> s.map(Object::toString).collect(Collectors.joining(",")))
+ .expectedResult(join(data, ","))
+ .exercise();
+
+ withData(data)
+ .terminal(s -> s.map(Object::toString).collect(Collectors.joining(",", "[", "]")))
+ .expectedResult("[" + join(data, ",") + "]")
+ .exercise();
+
+ withData(data)
+ .terminal(s -> s.map(Object::toString)
+ .collect(StringBuilder::new, StringBuilder::append, StringBuilder::append)
+ .toString())
+ .expectedResult(join(data, ""))
+ .exercise();
+
+ withData(data)
+ .terminal(s -> s.map(Object::toString)
+ .collect(() -> new StringJoiner(","),
+ (sj, cs) -> sj.add(cs),
+ (j1, j2) -> j1.merge(j2))
+ .toString())
+ .expectedResult(join(data, ","))
+ .exercise();
+
+ withData(data)
+ .terminal(s -> s.map(Object::toString)
+ .collect(() -> new StringJoiner(",", "[", "]"),
+ (sj, cs) -> sj.add(cs),
+ (j1, j2) -> j1.merge(j2))
+ .toString())
+ .expectedResult("[" + join(data, ",") + "]")
+ .exercise();
+ }
+
+ private<T> String join(TestData.OfRef<T> data, String delim) {
+ StringBuilder sb = new StringBuilder();
+ boolean first = true;
+ for (T i : data) {
+ if (!first)
+ sb.append(delim);
+ sb.append(i.toString());
+ first = false;
+ }
+ return sb.toString();
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testSimpleToMap(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException {
+ Function<Integer, Integer> keyFn = i -> i * 2;
+ Function<Integer, Integer> valueFn = i -> i * 4;
+
+ List<Integer> dataAsList = Arrays.asList(data.stream().toArray(Integer[]::new));
+ Set<Integer> dataAsSet = new HashSet<>(dataAsList);
+
+ BinaryOperator<Integer> sum = Integer::sum;
+ for (BinaryOperator<Integer> op : Arrays.asList((u, v) -> u,
+ (u, v) -> v,
+ sum)) {
+ try {
+ exerciseMapTabulation(data, toMap(keyFn, valueFn),
+ new ToMapAssertion<>(keyFn, valueFn, op, HashMap.class));
+ if (dataAsList.size() != dataAsSet.size())
+ fail("Expected ISE on input with duplicates");
+ }
+ catch (IllegalStateException e) {
+ if (dataAsList.size() == dataAsSet.size())
+ fail("Expected no ISE on input without duplicates");
+ }
+
+ exerciseMapTabulation(data, toMap(keyFn, valueFn, op),
+ new ToMapAssertion<>(keyFn, valueFn, op, HashMap.class));
+
+ exerciseMapTabulation(data, toMap(keyFn, valueFn, op, TreeMap::new),
+ new ToMapAssertion<>(keyFn, valueFn, op, TreeMap.class));
+ }
+
+ // For concurrent maps, only use commutative merge functions
+ try {
+ exerciseMapTabulation(data, toConcurrentMap(keyFn, valueFn),
+ new ToMapAssertion<>(keyFn, valueFn, sum, ConcurrentHashMap.class));
+ if (dataAsList.size() != dataAsSet.size())
+ fail("Expected ISE on input with duplicates");
+ }
+ catch (IllegalStateException e) {
+ if (dataAsList.size() == dataAsSet.size())
+ fail("Expected no ISE on input without duplicates");
+ }
+
+ exerciseMapTabulation(data, toConcurrentMap(keyFn, valueFn, sum),
+ new ToMapAssertion<>(keyFn, valueFn, sum, ConcurrentHashMap.class));
+
+ exerciseMapTabulation(data, toConcurrentMap(keyFn, valueFn, sum, ConcurrentSkipListMap::new),
+ new ToMapAssertion<>(keyFn, valueFn, sum, ConcurrentSkipListMap.class));
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testSimpleGroupBy(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException {
+ Function<Integer, Integer> classifier = i -> i % 3;
+
+ // Single-level groupBy
+ exerciseMapTabulation(data, groupingBy(classifier),
+ new GroupedMapAssertion<>(classifier, HashMap.class,
+ new ListAssertion<>()));
+ exerciseMapTabulation(data, groupingByConcurrent(classifier),
+ new GroupedMapAssertion<>(classifier, ConcurrentHashMap.class,
+ new ListAssertion<>()));
+
+ // With explicit constructors
+ exerciseMapTabulation(data,
+ groupingBy(classifier, TreeMap::new, toCollection(HashSet::new)),
+ new GroupedMapAssertion<>(classifier, TreeMap.class,
+ new CollectionAssertion<Integer>(HashSet.class, false)));
+ exerciseMapTabulation(data,
+ groupingByConcurrent(classifier, ConcurrentSkipListMap::new,
+ toCollection(HashSet::new)),
+ new GroupedMapAssertion<>(classifier, ConcurrentSkipListMap.class,
+ new CollectionAssertion<Integer>(HashSet.class, false)));
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testTwoLevelGroupBy(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException {
+ Function<Integer, Integer> classifier = i -> i % 6;
+ Function<Integer, Integer> classifier2 = i -> i % 23;
+
+ // Two-level groupBy
+ exerciseMapTabulation(data,
+ groupingBy(classifier, groupingBy(classifier2)),
+ new GroupedMapAssertion<>(classifier, HashMap.class,
+ new GroupedMapAssertion<>(classifier2, HashMap.class,
+ new ListAssertion<>())));
+ // with concurrent as upstream
+ exerciseMapTabulation(data,
+ groupingByConcurrent(classifier, groupingBy(classifier2)),
+ new GroupedMapAssertion<>(classifier, ConcurrentHashMap.class,
+ new GroupedMapAssertion<>(classifier2, HashMap.class,
+ new ListAssertion<>())));
+ // with concurrent as downstream
+ exerciseMapTabulation(data,
+ groupingBy(classifier, groupingByConcurrent(classifier2)),
+ new GroupedMapAssertion<>(classifier, HashMap.class,
+ new GroupedMapAssertion<>(classifier2, ConcurrentHashMap.class,
+ new ListAssertion<>())));
+ // with concurrent as upstream and downstream
+ exerciseMapTabulation(data,
+ groupingByConcurrent(classifier, groupingByConcurrent(classifier2)),
+ new GroupedMapAssertion<>(classifier, ConcurrentHashMap.class,
+ new GroupedMapAssertion<>(classifier2, ConcurrentHashMap.class,
+ new ListAssertion<>())));
+
+ // With explicit constructors
+ exerciseMapTabulation(data,
+ groupingBy(classifier, TreeMap::new, groupingBy(classifier2, TreeMap::new, toCollection(HashSet::new))),
+ new GroupedMapAssertion<>(classifier, TreeMap.class,
+ new GroupedMapAssertion<>(classifier2, TreeMap.class,
+ new CollectionAssertion<Integer>(HashSet.class, false))));
+ // with concurrent as upstream
+ exerciseMapTabulation(data,
+ groupingByConcurrent(classifier, ConcurrentSkipListMap::new, groupingBy(classifier2, TreeMap::new, toList())),
+ new GroupedMapAssertion<>(classifier, ConcurrentSkipListMap.class,
+ new GroupedMapAssertion<>(classifier2, TreeMap.class,
+ new ListAssertion<>())));
+ // with concurrent as downstream
+ exerciseMapTabulation(data,
+ groupingBy(classifier, TreeMap::new, groupingByConcurrent(classifier2, ConcurrentSkipListMap::new, toList())),
+ new GroupedMapAssertion<>(classifier, TreeMap.class,
+ new GroupedMapAssertion<>(classifier2, ConcurrentSkipListMap.class,
+ new ListAssertion<>())));
+ // with concurrent as upstream and downstream
+ exerciseMapTabulation(data,
+ groupingByConcurrent(classifier, ConcurrentSkipListMap::new, groupingByConcurrent(classifier2, ConcurrentSkipListMap::new, toList())),
+ new GroupedMapAssertion<>(classifier, ConcurrentSkipListMap.class,
+ new GroupedMapAssertion<>(classifier2, ConcurrentSkipListMap.class,
+ new ListAssertion<>())));
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testGroupedReduce(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException {
+ Function<Integer, Integer> classifier = i -> i % 3;
+
+ // Single-level simple reduce
+ exerciseMapTabulation(data,
+ groupingBy(classifier, reducing(0, Integer::sum)),
+ new GroupedMapAssertion<>(classifier, HashMap.class,
+ new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum)));
+ // with concurrent
+ exerciseMapTabulation(data,
+ groupingByConcurrent(classifier, reducing(0, Integer::sum)),
+ new GroupedMapAssertion<>(classifier, ConcurrentHashMap.class,
+ new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum)));
+
+ // With explicit constructors
+ exerciseMapTabulation(data,
+ groupingBy(classifier, TreeMap::new, reducing(0, Integer::sum)),
+ new GroupedMapAssertion<>(classifier, TreeMap.class,
+ new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum)));
+ // with concurrent
+ exerciseMapTabulation(data,
+ groupingByConcurrent(classifier, ConcurrentSkipListMap::new, reducing(0, Integer::sum)),
+ new GroupedMapAssertion<>(classifier, ConcurrentSkipListMap.class,
+ new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum)));
+
+ // Single-level map-reduce
+ exerciseMapTabulation(data,
+ groupingBy(classifier, reducing(0, mDoubler, Integer::sum)),
+ new GroupedMapAssertion<>(classifier, HashMap.class,
+ new ReduceAssertion<>(0, mDoubler, Integer::sum)));
+ // with concurrent
+ exerciseMapTabulation(data,
+ groupingByConcurrent(classifier, reducing(0, mDoubler, Integer::sum)),
+ new GroupedMapAssertion<>(classifier, ConcurrentHashMap.class,
+ new ReduceAssertion<>(0, mDoubler, Integer::sum)));
+
+ // With explicit constructors
+ exerciseMapTabulation(data,
+ groupingBy(classifier, TreeMap::new, reducing(0, mDoubler, Integer::sum)),
+ new GroupedMapAssertion<>(classifier, TreeMap.class,
+ new ReduceAssertion<>(0, mDoubler, Integer::sum)));
+ // with concurrent
+ exerciseMapTabulation(data,
+ groupingByConcurrent(classifier, ConcurrentSkipListMap::new, reducing(0, mDoubler, Integer::sum)),
+ new GroupedMapAssertion<>(classifier, ConcurrentSkipListMap.class,
+ new ReduceAssertion<>(0, mDoubler, Integer::sum)));
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testSimplePartition(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException {
+ Predicate<Integer> classifier = i -> i % 3 == 0;
+
+ // Single-level partition to downstream List
+ exerciseMapTabulation(data,
+ partitioningBy(classifier),
+ new PartitionAssertion<>(classifier, new ListAssertion<>()));
+ exerciseMapTabulation(data,
+ partitioningBy(classifier, toList()),
+ new PartitionAssertion<>(classifier, new ListAssertion<>()));
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testTwoLevelPartition(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException {
+ Predicate<Integer> classifier = i -> i % 3 == 0;
+ Predicate<Integer> classifier2 = i -> i % 7 == 0;
+
+ // Two level partition
+ exerciseMapTabulation(data,
+ partitioningBy(classifier, partitioningBy(classifier2)),
+ new PartitionAssertion<>(classifier,
+ new PartitionAssertion(classifier2, new ListAssertion<>())));
+
+ // Two level partition with reduce
+ exerciseMapTabulation(data,
+ partitioningBy(classifier, reducing(0, Integer::sum)),
+ new PartitionAssertion<>(classifier,
+ new ReduceAssertion<>(0, LambdaTestHelpers.identity(), Integer::sum)));
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testComposeFinisher(String name, TestData.OfRef<Integer> data) throws ReflectiveOperationException {
+ List<Integer> asList = exerciseTerminalOps(data, s -> s.collect(toList()));
+ List<Integer> asImmutableList = exerciseTerminalOps(data, s -> s.collect(collectingAndThen(toList(), Collections::unmodifiableList)));
+ assertEquals(asList, asImmutableList);
+ try {
+ asImmutableList.add(0);
+ fail("Expecting immutable result");
+ }
+ catch (UnsupportedOperationException ignored) { }
+ }
+
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/TeeOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/TeeOpTest.java
new file mode 100644
index 0000000..777158f
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/TeeOpTest.java
@@ -0,0 +1,139 @@
+/*
+ * 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 java.util.function.Consumer;
+import java.util.function.DoubleConsumer;
+import java.util.function.IntConsumer;
+import java.util.function.LongConsumer;
+import java.util.stream.*;
+
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import static java.util.stream.LambdaTestHelpers.*;
+
+/**
+ * TeeOpTest
+ */
+@Test(groups = { "serialization-hostile" })
+public class TeeOpTest extends OpTestCase {
+
+ public void testTee() {
+ List<Integer> copy = new ArrayList<>();
+
+ assertCountSum(countTo(0).stream().peek(copy::add), 0, 0);
+ assertCountSum(copy.iterator(), 0, 0);
+
+ copy.clear();
+ assertCountSum(countTo(10).stream().peek(copy::add), 10, 55);
+ assertCountSum(copy.iterator(), 10, 55);
+
+ copy.clear();
+ assertCountSum(countTo(10).stream().map(mDoubler).peek(copy::add), 10, 110);
+ assertCountSum(copy.iterator(), 10, 110);
+ }
+
+ static class AbstractRecordingConsumer<T> {
+ List<T> list;
+
+ void before(TestData<T, ?> td) {
+ // Tee block can be called concurrently
+ list = Collections.synchronizedList(new ArrayList<>());
+ }
+
+ void after(TestData<T, ?> td) {
+ // No guarantees in parallel tests that calls to tee block will
+ // be in the encounter order, if defined, of the data
+ // @@@ Consider passing more meta-data about evaluation
+ assertContentsUnordered(list, td.into(new ArrayList<T>()));
+ }
+ }
+
+ @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
+ public void testOps(String name, final TestData.OfRef<Integer> data) {
+ class RecordingConsumer extends AbstractRecordingConsumer<Integer> implements Consumer<Integer> {
+ public void accept(Integer t) {
+ list.add(t);
+ }
+ }
+ final RecordingConsumer b = new RecordingConsumer();
+
+ withData(data)
+ .stream(s -> s.peek(b))
+ .before(b::before)
+ .after(b::after)
+ .exercise();
+ }
+
+ @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class)
+ public void testIntOps(String name, final TestData.OfInt data) {
+ class RecordingConsumer extends AbstractRecordingConsumer<Integer> implements IntConsumer {
+ public void accept(int t) {
+ list.add(t);
+ }
+ }
+ final RecordingConsumer b = new RecordingConsumer();
+
+ withData(data)
+ .stream(s -> s.peek(b))
+ .before(b::before)
+ .after(b::after)
+ .exercise();
+ }
+
+ @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class)
+ public void testLongOps(String name, final TestData.OfLong data) {
+ class RecordingConsumer extends AbstractRecordingConsumer<Long> implements LongConsumer {
+ public void accept(long t) {
+ list.add(t);
+ }
+ }
+ final RecordingConsumer b = new RecordingConsumer();
+
+ withData(data)
+ .stream(s -> s.peek(b))
+ .before(b::before)
+ .after(b::after)
+ .exercise();
+ }
+
+ @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
+ public void testDoubleOps(String name, final TestData.OfDouble data) {
+ class RecordingConsumer extends AbstractRecordingConsumer<Double> implements DoubleConsumer {
+ public void accept(double t) {
+ list.add(t);
+ }
+ }
+ final RecordingConsumer b = new RecordingConsumer();
+
+ withData(data)
+ .stream(s -> s.peek(b))
+ .before(b::before)
+ .after(b::after)
+ .exercise();
+ }
+}
diff --git a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ToArrayOpTest.java b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ToArrayOpTest.java
new file mode 100644
index 0000000..5132d9d
--- /dev/null
+++ b/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ToArrayOpTest.java
@@ -0,0 +1,417 @@
+/*
+ * 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());
+ }
+ }
+}
diff --git a/ojluni/src/test/test-output/emailable-report.html b/ojluni/src/test/test-output/emailable-report.html
new file mode 100644
index 0000000..ea52d70
--- /dev/null
+++ b/ojluni/src/test/test-output/emailable-report.html
@@ -0,0 +1,2 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head><title>TestNG Report</title><style type="text/css">table {margin-bottom:10px;border-collapse:collapse;empty-cells:show}th,td {border:1px solid #009;padding:.25em .5em}th {vertical-align:bottom}td {vertical-align:top}table a {font-weight:bold}.stripe td {background-color: #E6EBF9}.num {text-align:right}.passedodd td {background-color: #3F3}.passedeven td {background-color: #0A0}.skippedodd td {background-color: #DDD}.skippedeven td {background-color: #CCC}.failedodd td,.attn {background-color: #F33}.failedeven td,.stripe .attn {background-color: #D00}.stacktrace {white-space:pre;font-family:monospace}.totop {font-size:85%;text-align:center;border-bottom:2px solid #000}</style></head><body><table><tr><th>Test</th><th># Passed</th><th># Skipped</th><th># Failed</th><th>Time (ms)</th><th>Included Groups</th><th>Excluded Groups</th></tr></table><table><thead><tr><th>Class</th><th>Method</th><th>Start</th><th>Time (ms)</th></tr></thead></table></body></html>
\ No newline at end of file
diff --git a/ojluni/src/test/test-output/old/index.html b/ojluni/src/test/test-output/old/index.html
new file mode 100644
index 0000000..981b559
--- /dev/null
+++ b/ojluni/src/test/test-output/old/index.html
@@ -0,0 +1,8 @@
+<html>
+<head><title>Test results</title><link href="./testng.css" rel="stylesheet" type="text/css" />
+<link href="./my-testng.css" rel="stylesheet" type="text/css" />
+</head><body>
+<h2><p align='center'>Test results</p></h2>
+<table border='1' width='100%' class='main-page'><tr><th>Suite</th><th>Passed</th><th>Failed</th><th>Skipped</th><th>testng.xml</th></tr>
+<tr align='center' class='invocation-failed'><td><em>Total</em></td><td><em>0</em></td><td><em>0</em></td><td><em>0</em></td><td> </td></tr>
+</table></body></html>
diff --git a/ojluni/src/test/test-output/testng-results.xml b/ojluni/src/test/test-output/testng-results.xml
new file mode 100644
index 0000000..1c245d8
--- /dev/null
+++ b/ojluni/src/test/test-output/testng-results.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<testng-results skipped="0" failed="0" total="0" passed="0">
+ <reporter-output>
+ </reporter-output>
+</testng-results>
diff --git a/ojluni/src/test/testng.xml b/ojluni/src/test/testng.xml
new file mode 100644
index 0000000..851461a
--- /dev/null
+++ b/ojluni/src/test/testng.xml
@@ -0,0 +1,72 @@
+<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
+
+<suite name="OpenJDK8 java.util.stream test suite" verbose="1" >
+ <test name="java util stream test">
+ <!-- classes have to be provided one at a time because "packages" doesn't work on Android
+ -->
+
+ <classes>
+ <!--
+ <class name="org.openjdk.tests.java.lang.invoke.DeserializeMethodTest" />
+ <class name="org.openjdk.tests.java.lang.invoke.SerializedLambdaTest" />
+ -->
+
+ <class name="org.openjdk.tests.java.util.FillableStringTest" />
+ <class name="org.openjdk.tests.java.util.MapTest" />
+ <class name="org.openjdk.tests.java.util.NullArgsTestCase" />
+ <class name="org.openjdk.tests.java.util.stream.GroupByOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.SequentialOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.SummaryStatisticsTest" />
+ <class name="org.openjdk.tests.java.util.stream.StreamBuilderTest" />
+ <class name="org.openjdk.tests.java.util.stream.CollectionAndMapModifyStreamTest" />
+ <class name="org.openjdk.tests.java.util.stream.CountLargeTest" />
+ <class name="org.openjdk.tests.java.util.stream.StreamCloseTest" />
+ <class name="org.openjdk.tests.java.util.stream.MinMaxTest" />
+ <class name="org.openjdk.tests.java.util.stream.StreamLinkTest" />
+ <class name="org.openjdk.tests.java.util.stream.ForEachOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.CountTest" />
+ <class name="org.openjdk.tests.java.util.stream.ConcatTest" />
+ <class name="org.openjdk.tests.java.util.stream.ReduceTest" />
+ <class name="org.openjdk.tests.java.util.stream.DoublePrimitiveOpsTests" />
+ <class name="org.openjdk.tests.java.util.stream.IntUniqOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.SpliteratorTest" />
+ <class name="org.openjdk.tests.java.util.stream.ReduceByOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.FindFirstOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.SortedOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.ToArrayOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.TeeOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.IntPrimitiveOpsTests" />
+ <class name="org.openjdk.tests.java.util.stream.LongPrimitiveOpsTests" />
+ <class name="org.openjdk.tests.java.util.stream.SliceOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.InfiniteStreamWithLimitOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.DistinctOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.ConcatOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.TabulatorsTest" />
+ <class name="org.openjdk.tests.java.util.stream.StreamParSeqTest" />
+ <class name="org.openjdk.tests.java.util.stream.FindAnyOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.PrimitiveAverageOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.IntReduceTest" />
+ <class name="org.openjdk.tests.java.util.stream.FilterOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.IntSliceOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.StreamSpliteratorTest" />
+ <class name="org.openjdk.tests.java.util.stream.RangeTest" />
+ <class name="org.openjdk.tests.java.util.stream.MatchOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.ExplodeOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.MapOpTest" />
+ <class name="org.openjdk.tests.java.util.stream.PrimitiveSumTest" />
+ <class name="java.util.stream.SpinedBufferTest" />
+ <class name="java.util.stream.NodeTest" />
+ <class name="java.util.stream.FlagOpTest" />
+ <class name="java.util.stream.SliceSpliteratorTest" />
+ <class name="java.util.stream.LongNodeTest" />
+ <class name="java.util.stream.StreamFlagsTest" />
+ <class name="java.util.stream.StreamReuseTest" />
+ <class name="java.util.stream.DoubleNodeTest" />
+ <class name="java.util.stream.NodeBuilderTest" />
+ <class name="java.util.stream.IntNodeTest" />
+ <class name="java.util.stream.StreamOpFlagsTest" />
+ </classes>
+ </test>
+
+</suite>
+