From 6b74f4120861ee30b76507f158499cf01c1196e8 Mon Sep 17 00:00:00 2001 From: Igor Murashkin Date: Wed, 23 Mar 2016 03:22:16 +0000 Subject: [PATCH] Revert "ojluni: Downstream OJ tests" This reverts commit 20277d1ac2307c1137d40330322b35e8236551a7. Change-Id: Icf8693bd760c39ea7d24756d49932c20881458a1 --- JavaLibrary.mk | 19 - ojluni/src/test/artrun | 126 --- ojluni/src/test/artrun-testng | 17 - ojluni/src/test/gen-test-list | 86 --- .../util/stream/TestDoubleSumAverage.java | 169 ---- .../java/util/stream/bootlib/TEST.properties | 3 - .../java/util/stream/CollectorOps.java | 113 --- .../stream/DoubleStreamTestDataProvider.java | 144 ---- .../util/stream/DoubleStreamTestScenario.java | 231 ------ .../java/util/stream/FlagDeclaringOp.java | 61 -- .../stream/IntStreamTestDataProvider.java | 158 ---- .../util/stream/IntStreamTestScenario.java | 232 ------ .../java/util/stream/IntermediateTestOp.java | 41 - .../java/util/stream/LambdaTestHelpers.java | 462 ----------- .../java/util/stream/LambdaTestMode.java | 71 -- .../java/util/stream/LoggingTestCase.java | 67 -- .../stream/LongStreamTestDataProvider.java | 158 ---- .../util/stream/LongStreamTestScenario.java | 231 ------ .../bootlib/java/util/stream/OpTestCase.java | 667 ---------------- .../util/stream/SpliteratorTestHelper.java | 727 ------------------ .../java/util/stream/StatefulTestOp.java | 138 ---- .../java/util/stream/StatelessTestOp.java | 73 -- .../util/stream/StreamOpFlagTestHelper.java | 48 -- .../util/stream/StreamTestDataProvider.java | 205 ----- .../java/util/stream/StreamTestScenario.java | 270 ------- .../bootlib/java/util/stream/TestData.java | 355 --------- .../java/util/stream/TestFlagExpectedOp.java | 125 --- .../java/util/stream/boottest/TEST.properties | 5 - .../java/util/stream/DoubleNodeTest.java | 179 ----- .../boottest/java/util/stream/FlagOpTest.java | 283 ------- .../java/util/stream/IntNodeTest.java | 177 ----- .../java/util/stream/LongNodeTest.java | 178 ----- .../java/util/stream/NodeBuilderTest.java | 236 ------ .../boottest/java/util/stream/NodeTest.java | 154 ---- .../util/stream/SliceSpliteratorTest.java | 201 ----- .../java/util/stream/SpinedBufferTest.java | 370 --------- .../java/util/stream/StreamFlagsTest.java | 96 --- .../java/util/stream/StreamOpFlagsTest.java | 381 --------- .../java/util/stream/StreamReuseTest.java | 441 ----------- .../java/util/stream/test/TEST.properties | 8 - .../lang/invoke/DeserializeMethodTest.java | 87 --- .../lang/invoke/SerializedLambdaTest.java | 357 --------- .../tests/java/util/FillableStringTest.java | 56 -- .../org/openjdk/tests/java/util/MapTest.java | 93 --- .../tests/java/util/NullArgsTestCase.java | 70 -- .../CollectionAndMapModifyStreamTest.java | 167 ---- .../tests/java/util/stream/ConcatOpTest.java | 142 ---- .../tests/java/util/stream/ConcatTest.java | 238 ------ .../java/util/stream/CountLargeTest.java | 70 -- .../tests/java/util/stream/CountTest.java | 91 --- .../java/util/stream/DistinctOpTest.java | 200 ----- .../util/stream/DoublePrimitiveOpsTests.java | 106 --- .../tests/java/util/stream/ExplodeOpTest.java | 119 --- .../tests/java/util/stream/FilterOpTest.java | 109 --- .../tests/java/util/stream/FindAnyOpTest.java | 157 ---- .../java/util/stream/FindFirstOpTest.java | 132 ---- .../tests/java/util/stream/ForEachOpTest.java | 261 ------- .../tests/java/util/stream/GroupByOpTest.java | 173 ----- .../stream/InfiniteStreamWithLimitOpTest.java | 453 ----------- .../util/stream/IntPrimitiveOpsTests.java | 183 ----- .../tests/java/util/stream/IntReduceTest.java | 81 -- .../java/util/stream/IntSliceOpTest.java | 208 ----- .../tests/java/util/stream/IntUniqOpTest.java | 72 -- .../util/stream/LongPrimitiveOpsTests.java | 183 ----- .../tests/java/util/stream/MapOpTest.java | 125 --- .../tests/java/util/stream/MatchOpTest.java | 422 ---------- .../tests/java/util/stream/MinMaxTest.java | 92 --- .../util/stream/PrimitiveAverageOpTest.java | 50 -- .../java/util/stream/PrimitiveSumTest.java | 65 -- .../tests/java/util/stream/RangeTest.java | 339 -------- .../java/util/stream/ReduceByOpTest.java | 68 -- .../tests/java/util/stream/ReduceTest.java | 87 --- .../java/util/stream/SequentialOpTest.java | 135 ---- .../tests/java/util/stream/SliceOpTest.java | 343 --------- .../tests/java/util/stream/SortedOpTest.java | 361 --------- .../java/util/stream/SpliteratorTest.java | 64 -- .../java/util/stream/StreamBuilderTest.java | 318 -------- .../java/util/stream/StreamCloseTest.java | 166 ---- .../java/util/stream/StreamLinkTest.java | 104 --- .../java/util/stream/StreamParSeqTest.java | 52 -- .../util/stream/StreamSpliteratorTest.java | 616 --------------- .../util/stream/SummaryStatisticsTest.java | 88 --- .../java/util/stream/TabulatorsTest.java | 621 --------------- .../tests/java/util/stream/TeeOpTest.java | 139 ---- .../tests/java/util/stream/ToArrayOpTest.java | 417 ---------- .../test/test-output/emailable-report.html | 2 - ojluni/src/test/test-output/old/index.html | 8 - .../src/test/test-output/testng-results.xml | 5 - ojluni/src/test/testng.xml | 72 -- 89 files changed, 16273 deletions(-) delete mode 100755 ojluni/src/test/artrun delete mode 100755 ojluni/src/test/artrun-testng delete mode 100755 ojluni/src/test/gen-test-list delete mode 100644 ojluni/src/test/java/util/stream/TestDoubleSumAverage.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/TEST.properties delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/CollectorOps.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestDataProvider.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/FlagDeclaringOp.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/IntStreamTestDataProvider.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/IntermediateTestOp.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/LambdaTestHelpers.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/LambdaTestMode.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/LoggingTestCase.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/LongStreamTestDataProvider.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/OpTestCase.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/SpliteratorTestHelper.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/StatefulTestOp.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/StatelessTestOp.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/StreamOpFlagTestHelper.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/StreamTestDataProvider.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/TestData.java delete mode 100644 ojluni/src/test/java/util/stream/bootlib/java/util/stream/TestFlagExpectedOp.java delete mode 100644 ojluni/src/test/java/util/stream/boottest/TEST.properties delete mode 100644 ojluni/src/test/java/util/stream/boottest/java/util/stream/DoubleNodeTest.java delete mode 100644 ojluni/src/test/java/util/stream/boottest/java/util/stream/FlagOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/boottest/java/util/stream/IntNodeTest.java delete mode 100644 ojluni/src/test/java/util/stream/boottest/java/util/stream/LongNodeTest.java delete mode 100644 ojluni/src/test/java/util/stream/boottest/java/util/stream/NodeBuilderTest.java delete mode 100644 ojluni/src/test/java/util/stream/boottest/java/util/stream/NodeTest.java delete mode 100644 ojluni/src/test/java/util/stream/boottest/java/util/stream/SliceSpliteratorTest.java delete mode 100644 ojluni/src/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java delete mode 100644 ojluni/src/test/java/util/stream/boottest/java/util/stream/StreamFlagsTest.java delete mode 100644 ojluni/src/test/java/util/stream/boottest/java/util/stream/StreamOpFlagsTest.java delete mode 100644 ojluni/src/test/java/util/stream/boottest/java/util/stream/StreamReuseTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/TEST.properties delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/lang/invoke/DeserializeMethodTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/lang/invoke/SerializedLambdaTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/FillableStringTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/MapTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/NullArgsTestCase.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CollectionAndMapModifyStreamTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ConcatOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ConcatTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountLargeTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/DistinctOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/DoublePrimitiveOpsTests.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ExplodeOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/FilterOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/FindAnyOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/FindFirstOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ForEachOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/GroupByOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntPrimitiveOpsTests.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntReduceTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntSliceOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntUniqOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/LongPrimitiveOpsTests.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MapOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MatchOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MinMaxTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/PrimitiveAverageOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/PrimitiveSumTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/RangeTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ReduceByOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ReduceTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SequentialOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SortedOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamBuilderTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamCloseTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamLinkTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamParSeqTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamSpliteratorTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SummaryStatisticsTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/TeeOpTest.java delete mode 100644 ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ToArrayOpTest.java delete mode 100644 ojluni/src/test/test-output/emailable-report.html delete mode 100644 ojluni/src/test/test-output/old/index.html delete mode 100644 ojluni/src/test/test-output/testng-results.xml delete mode 100644 ojluni/src/test/testng.xml diff --git a/JavaLibrary.mk b/JavaLibrary.mk index fb7d37d91..c9f2bc468 100644 --- a/JavaLibrary.mk +++ b/JavaLibrary.mk @@ -54,7 +54,6 @@ core_resource_dirs := \ 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) @@ -256,9 +255,6 @@ LOCAL_SRC_FILES := $(openjdk_java_files) LOCAL_JAVA_RESOURCE_DIRS := $(core_resource_dirs) LOCAL_NO_STANDARD_LIBRARIES := true LOCAL_JAVACFLAGS := $(local_javac_flags) -# Force jack to emit co(ntra)variant bridge synthetic methods on interfaces, see b/27410968 -# TODO: revisit removing these flags, the build system should do it automatically -LOCAL_JACK_FLAGS += -D jack.frontend.bridge.interface=true LOCAL_DX_FLAGS := --core-library LOCAL_MODULE_TAGS := optional LOCAL_JAVA_LANGUAGE_VERSION := 1.8 @@ -330,21 +326,6 @@ ifeq ($(LIBCORE_SKIP_TESTS),) 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/ojluni/src/test/artrun b/ojluni/src/test/artrun deleted file mode 100755 index 5315eb7c0..000000000 --- a/ojluni/src/test/artrun +++ /dev/null @@ -1,126 +0,0 @@ -#!/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 deleted file mode 100755 index 93c9b3d0c..000000000 --- a/ojluni/src/test/artrun-testng +++ /dev/null @@ -1,17 +0,0 @@ -#!/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 deleted file mode 100755 index b7f3f749b..000000000 --- a/ojluni/src/test/gen-test-list +++ /dev/null @@ -1,86 +0,0 @@ -#!/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 "" - 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 deleted file mode 100644 index e8df2e995..000000000 --- a/ojluni/src/test/java/util/stream/TestDoubleSumAverage.java +++ /dev/null @@ -1,169 +0,0 @@ -/* - * 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 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 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, 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, Double> testCase : testCases.entrySet()) { - Supplier 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 deleted file mode 100644 index a50c2e89a..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/TEST.properties +++ /dev/null @@ -1,3 +0,0 @@ -# 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 deleted file mode 100644 index c8494150e..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/CollectorOps.java +++ /dev/null @@ -1,113 +0,0 @@ -/* - * 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 StatefulTestOp collector() { - return new StatefulCollector<>(0, StreamShape.REFERENCE); - } - - /* Utility classes for collecting output of intermediate pipeline stages */ - public static class StatefulCollector implements StatefulTestOp { - 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 opWrapSink(int flags, boolean parallel, Sink sink) { - return sink; - } - - @Override - public Node opEvaluateParallel(PipelineHelper helper, - Spliterator spliterator, - IntFunction generator) { - return helper.evaluate(spliterator, false, generator); - } - } - - public static class TestParallelSizedOp extends StatefulCollector { - public TestParallelSizedOp() { - this(StreamShape.REFERENCE); - } - - protected TestParallelSizedOp(StreamShape shape) { - super(0, shape); - } - - @Override - public Node opEvaluateParallel(PipelineHelper helper, - Spliterator spliterator, - IntFunction generator) { - int flags = helper.getStreamAndOpFlags(); - - Assert.assertTrue(StreamOpFlag.SIZED.isKnown(flags)); - return super.opEvaluateParallel(helper, spliterator, generator); - } - - public static class OfInt extends TestParallelSizedOp { - public OfInt() { - super(StreamShape.INT_VALUE); - } - } - - public static class OfLong extends TestParallelSizedOp { - public OfLong() { - super(StreamShape.LONG_VALUE); - } - } - - public static class OfDouble extends TestParallelSizedOp { - 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 deleted file mode 100644 index 0eb7c8742..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestDataProvider.java +++ /dev/null @@ -1,144 +0,0 @@ -/* - * 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 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 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 Object[] splitDescr(String description, Supplier 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>) - @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 deleted file mode 100644 index 1811a4ba5..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java +++ /dev/null @@ -1,231 +0,0 @@ -/* - * 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) { - > - void _run(TestData data, DoubleConsumer b, Function m) { - DoubleStream s = m.apply(data.stream()); - if (s.isParallel()) { - s = s.sequential(); - } - s.forEach(b); - s.close(); - } - }, - - STREAM_TO_ARRAY(false) { - > - void _run(TestData data, DoubleConsumer b, Function m) { - for (double t : m.apply(data.stream()).toArray()) { - b.accept(t); - } - } - }, - - STREAM_ITERATOR(false) { - > - void _run(TestData data, DoubleConsumer b, Function 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) { - > - void _run(TestData data, DoubleConsumer b, Function 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) { - > - void _run(TestData data, DoubleConsumer b, Function m) { - SpliteratorTestHelper.mixedTraverseAndSplit(b, m.apply(data.stream()).spliterator()); - } - }, - - // Wrap as stream, and spliterate then iterate in pull mode - STREAM_SPLITERATOR_FOREACH(false) { - > - void _run(TestData data, DoubleConsumer b, Function m) { - m.apply(data.stream()).spliterator().forEachRemaining(b); - } - }, - - PAR_STREAM_SEQUENTIAL_FOR_EACH(true) { - > - void _run(TestData data, DoubleConsumer b, Function m) { - m.apply(data.parallelStream()).sequential().forEach(b); - } - }, - - // Wrap as parallel stream + forEachOrdered - PAR_STREAM_FOR_EACH_ORDERED(true) { - > - void _run(TestData data, DoubleConsumer b, Function 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) { - > - void _run(TestData data, DoubleConsumer b, Function 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) { - > - void _run(TestData data, DoubleConsumer b, Function m) { - m.apply(data.parallelStream()).spliterator().forEachRemaining(b); - } - }, - - PAR_STREAM_TO_ARRAY(true) { - > - void _run(TestData data, DoubleConsumer b, Function 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) { - > - void _run(TestData data, DoubleConsumer b, Function 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) { - > - void _run(TestData data, DoubleConsumer b, Function 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) { - > - void _run(TestData data, DoubleConsumer b, Function 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) { - > - void _run(TestData data, DoubleConsumer b, Function 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 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 , S_OUT extends BaseStream> - void run(TestData data, Consumer b, Function m) { - _run(data, (DoubleConsumer) b, (Function) m); - } - - abstract > - void _run(TestData data, DoubleConsumer b, Function 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 deleted file mode 100644 index a9882c8b6..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/FlagDeclaringOp.java +++ /dev/null @@ -1,61 +0,0 @@ -/* - * 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 implements StatelessTestOp { - 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 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 deleted file mode 100644 index dded670d1..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/IntStreamTestDataProvider.java +++ /dev/null @@ -1,158 +0,0 @@ -/* - * 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 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 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 Object[] streamDataDescr(String description, Supplier s) { - return new Object[] { description, TestData.Factory.ofIntSupplier(description, s) }; - } - - static Object[] splitDescr(String description, Supplier 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>) - @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 deleted file mode 100644 index 9a3cc4413..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java +++ /dev/null @@ -1,232 +0,0 @@ -/* - * 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) { - > - void _run(TestData data, IntConsumer b, Function m) { - IntStream s = m.apply(data.stream()); - if (s.isParallel()) { - s = s.sequential(); - } - s.forEach(b); - s.close(); - } - }, - - STREAM_TO_ARRAY(false) { - > - void _run(TestData data, IntConsumer b, Function m) { - for (int t : m.apply(data.stream()).toArray()) { - b.accept(t); - } - } - }, - - STREAM_ITERATOR(false) { - > - void _run(TestData data, IntConsumer b, Function 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) { - > - void _run(TestData data, IntConsumer b, Function 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) { - > - void _run(TestData data, IntConsumer b, Function m) { - SpliteratorTestHelper.mixedTraverseAndSplit(b, m.apply(data.stream()).spliterator()); - } - }, - - // Wrap as stream, and spliterate then iterate in pull mode - STREAM_SPLITERATOR_FOREACH(false) { - > - void _run(TestData data, IntConsumer b, Function m) { - m.apply(data.stream()).spliterator().forEachRemaining(b); - } - }, - - PAR_STREAM_SEQUENTIAL_FOR_EACH(true) { - > - void _run(TestData data, IntConsumer b, Function m) { - m.apply(data.parallelStream()).sequential().forEach(b); - } - }, - - // Wrap as parallel stream + forEachOrdered - PAR_STREAM_FOR_EACH_ORDERED(true) { - > - void _run(TestData data, IntConsumer b, Function 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) { - > - void _run(TestData data, IntConsumer b, Function 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) { - > - void _run(TestData data, IntConsumer b, Function m) { - m.apply(data.parallelStream()).spliterator().forEachRemaining(b); - } - }, - - PAR_STREAM_TO_ARRAY(true) { - > - void _run(TestData data, IntConsumer b, Function 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) { - > - void _run(TestData data, IntConsumer b, Function 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) { - > - void _run(TestData data, IntConsumer b, Function 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) { - > - void _run(TestData data, IntConsumer b, Function 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) { - > - void _run(TestData data, IntConsumer b, Function 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 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 , S_OUT extends BaseStream> - void run(TestData data, Consumer b, Function m) { - _run(data, (IntConsumer) b, (Function) m); - } - - abstract > - void _run(TestData data, IntConsumer b, Function 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 deleted file mode 100644 index 1ed04c7d4..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/IntermediateTestOp.java +++ /dev/null @@ -1,41 +0,0 @@ -/* - * 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 { - - @SuppressWarnings({"rawtypes", "unchecked"}) - public static AbstractPipeline chain(AbstractPipeline upstream, - IntermediateTestOp 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 deleted file mode 100644 index 76a4d72ad..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/LambdaTestHelpers.java +++ /dev/null @@ -1,462 +0,0 @@ -/* - * 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 mZero = x -> 0; - public static final Function mId = x -> x; - public static final Function mDoubler = x -> x * 2; - public static final Function> mfId = e -> Collections.singletonList(e).stream(); - public static final Function> mfNull = e -> Collections.emptyList().stream(); - public static final Function> mfLt = e -> { - List l = new ArrayList<>(); - for (int i=0; i imDoubler = x -> x * 2; - public static final ToLongFunction lmDoubler = x -> x * 2; - public static final ToDoubleFunction dmDoubler = x -> x * 2; - public static final Predicate pFalse = x -> false; - public static final Predicate pTrue = x -> true; - public static final Predicate pEven = x -> 0 == x % 2; - public static final Predicate 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 rPlus = (x, y) -> x+y; - public static final BinaryOperator rMax = (x, y) -> Math.max(x, y); - public static final BinaryOperator 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 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 bipBothEven = (x, y) -> 0 == (x % 2 + y % 2); - public static final BiPredicate 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 integerArrayGenerator = s -> new Integer[s]; - - public static final IntFunction objectArrayGenerator = s -> new Object[s]; - - public static final Function> flattenChars = string -> { - List l = new ArrayList<>(); - for (int i=0; i flattenInt - = string -> IntStream.range(0, string.length()).map(string::charAt); - - public static Function forPredicate(Predicate predicate, R forTrue, R forFalse) { - Objects.requireNonNull(predicate); - - return t -> predicate.test(t) ? forTrue : forFalse; - } - - public static Function identity() { - return t -> t; - } - - public static Function compose(Function after, Function before) { - Objects.requireNonNull(before); - return (V v) -> after.apply(before.apply(v)); - } - - public static List empty() { - ArrayList list = new ArrayList<>(); - list.add(null); - return list; - } - - public static List countTo(int n) { - return range(1, n); - } - - public static List range(int l, int u) { - ArrayList list = new ArrayList<>(u - l + 1); - for (int i=l; i<=u; i++) { - list.add(i); - } - return list; - } - - public static List repeat(int value, int n) { - ArrayList list = new ArrayList<>(n); - for (int i=1; i<=n; i++) { - list.add(value); - } - return list; - } - - public static List asDoubles(List integers) { - ArrayList list = new ArrayList<>(); - for (Integer i : integers) { - list.add((double) i); - } - return list; - } - - public static List asLongs(List integers) { - ArrayList list = new ArrayList<>(); - for (Integer i : integers) { - list.add((long) i); - } - return list; - } - - public static void assertCountSum(Stream it, int count, int sum) { - assertCountSum(it.iterator(), count, sum); - } - - public static void assertCountSum(Iterable it, int count, int sum) { - assertCountSum(it.iterator(), count, sum); - } - - public static void assertCountSum(Iterator 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 it, String result) { - StringBuilder sb = new StringBuilder(); - while (it.hasNext()) { - sb.append(it.next()); - } - - assertEquals(result, sb.toString()); - } - - public static> void assertSorted(Iterator 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 void assertSorted(Iterator i, Comparator 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> void assertSorted(Iterable iter) { - assertSorted(iter.iterator()); - } - - public static void assertSorted(Iterable iter, Comparator comp) { - assertSorted(iter.iterator(), comp); - } - - public static void assertUnique(Iterable iter) { - assertUnique(iter.iterator()); - } - - public static void assertUnique(Iterator iter) { - if (!iter.hasNext()) { - return; - } - - if (iter instanceof PrimitiveIterator.OfInt - || iter instanceof PrimitiveIterator.OfDouble - || iter instanceof PrimitiveIterator.OfLong) { - iter = toBoxedList(iter).iterator(); - } - - Set uniq = new HashSet<>(); - while(iter.hasNext()) { - T each = iter.next(); - assertTrue(!uniq.contains(each), "Not unique"); - uniq.add(each); - } - } - - public static void assertContents(Iterable actual, Iterable expected) { - if (actual instanceof Collection && expected instanceof Collection) { - assertEquals(actual, expected); - } else { - assertContents(actual.iterator(), expected.iterator()); - } - } - - public static void assertContents(Iterator actual, Iterator expected) { - assertEquals(toBoxedList(actual), toBoxedList(expected)); - } - - @SafeVarargs - @SuppressWarnings("varargs") - public static void assertContents(Iterator 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 - extends Consumer, IntConsumer, LongConsumer, DoubleConsumer { } - - @SuppressWarnings({"rawtypes", "unchecked"}) - public static Consumer toBoxingConsumer(Consumer c) { - return (Consumer) 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 List toBoxedList(Iterator it) { - List 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 List toBoxedList(Spliterator sp) { - List 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 Map toBoxedMultiset(Iterator it) { - Map 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) result; - } - - @SuppressWarnings("unchecked") - public static Map toBoxedMultiset(Spliterator it) { - Map 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) 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 void assertContentsUnordered(Iterable actual, Iterable expected) { - assertContentsUnordered(actual.iterator(), expected.iterator()); - } - - public static void assertContentsUnordered(Iterator actual, Iterator expected) { - assertEquals(toBoxedMultiset(actual), toBoxedMultiset(expected)); - } - - public static void launderAssertion(Runnable r, Supplier 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 > - List> permuteStreamFunctions(List> opFunctions) { - List>> opFunctionPermutations = perm(opFunctions); - - List> appliedFunctions = new ArrayList<>(); - for (List> fs : opFunctionPermutations) { - Function applied = s -> { - for (Function f : fs) { - s = f.apply(s); - } - return s; - }; - appliedFunctions.add(applied); - } - - return appliedFunctions; - } - - private static List sub(List l, int index) { - List subL = new ArrayList<>(l); - subL.remove(index); - return subL; - } - - public static List> perm(List l) { - List> result = new ArrayList<>(); - for (int i = 0; i < l.size(); i++) { - for (List perm : perm(sub(l, i))) { - perm.add(0, l.get(i)); - result.add(perm); - } - } - result.add(new ArrayList()); - - 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 deleted file mode 100644 index b598964a8..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/LambdaTestMode.java +++ /dev/null @@ -1,71 +0,0 @@ -/* - * 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. - * - *

This mode may be queried by tests or data supplied by data - * providers, which cannot otherwise be assigned to the test group - * serialization-hostile, to not execute or declare - * serialization-hostile code or data. - * - *

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 deleted file mode 100644 index a0f221929..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/LoggingTestCase.java +++ /dev/null @@ -1,67 +0,0 @@ -/* - * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package java.util.stream; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import org.testng.Assert; -import org.testng.ITestResult; -import org.testng.annotations.AfterMethod; -import org.testng.annotations.BeforeMethod; -import org.testng.annotations.Test; - -/** - * LoggingTestCase - * - */ -@Test -public class LoggingTestCase extends Assert { - private Map context = new HashMap<>(); - - @BeforeMethod - public void before() { - context.clear(); - } - - @AfterMethod - public void after(ITestResult result) { - if (!result.isSuccess()) { - List list = new ArrayList<>(); - Collections.addAll(list, result.getParameters()); - list.add(context.toString()); - result.setParameters(list.toArray(new Object[list.size()])); - } - } - - protected void setContext(String key, Object value) { - context.put(key, value); - } - - protected void clearContext(String key) { - context.remove(key); - } -} diff --git a/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 deleted file mode 100644 index 4ce7ae6d2..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/LongStreamTestDataProvider.java +++ /dev/null @@ -1,158 +0,0 @@ -/* - * 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 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 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 Object[] streamDataDescr(String description, Supplier s) { - return new Object[] { description, TestData.Factory.ofLongSupplier(description, s) }; - } - - static Object[] splitDescr(String description, Supplier 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>) - @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 deleted file mode 100644 index 6d3e1044b..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java +++ /dev/null @@ -1,231 +0,0 @@ -/* - * 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) { - > - void _run(TestData data, LongConsumer b, Function m) { - LongStream s = m.apply(data.stream()); - if (s.isParallel()) { - s = s.sequential(); - } - s.forEach(b); - s.close(); - } - }, - - STREAM_TO_ARRAY(false) { - > - void _run(TestData data, LongConsumer b, Function m) { - for (long t : m.apply(data.stream()).toArray()) { - b.accept(t); - } - } - }, - - STREAM_ITERATOR(false) { - > - void _run(TestData data, LongConsumer b, Function 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) { - > - void _run(TestData data, LongConsumer b, Function 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) { - > - void _run(TestData data, LongConsumer b, Function m) { - SpliteratorTestHelper.mixedTraverseAndSplit(b, m.apply(data.stream()).spliterator()); - } - }, - - // Wrap as stream, and spliterate then iterate in pull mode - STREAM_SPLITERATOR_FOREACH(false) { - > - void _run(TestData data, LongConsumer b, Function m) { - m.apply(data.stream()).spliterator().forEachRemaining(b); - } - }, - - PAR_STREAM_SEQUENTIAL_FOR_EACH(true) { - > - void _run(TestData data, LongConsumer b, Function m) { - m.apply(data.parallelStream()).sequential().forEach(b); - } - }, - - // Wrap as parallel stream + forEachOrdered - PAR_STREAM_FOR_EACH_ORDERED(true) { - > - void _run(TestData data, LongConsumer b, Function 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) { - > - void _run(TestData data, LongConsumer b, Function 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) { - > - void _run(TestData data, LongConsumer b, Function m) { - m.apply(data.parallelStream()).spliterator().forEachRemaining(b); - } - }, - - PAR_STREAM_TO_ARRAY(true) { - > - void _run(TestData data, LongConsumer b, Function 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) { - > - void _run(TestData data, LongConsumer b, Function 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) { - > - void _run(TestData data, LongConsumer b, Function 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) { - > - void _run(TestData data, LongConsumer b, Function 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) { - > - void _run(TestData data, LongConsumer b, Function 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 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 , S_OUT extends BaseStream> - void run(TestData data, Consumer b, Function m) { - _run(data, (LongConsumer) b, (Function) m); - } - - abstract > - void _run(TestData data, LongConsumer b, Function 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 deleted file mode 100644 index 331ac0e88..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/OpTestCase.java +++ /dev/null @@ -1,667 +0,0 @@ -/* - * 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> 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 the type of result to assert on - */ - public interface ResultAsserter { - /** - * Assert a result produced when exercising of stream or terminal - * test. - * - * @param actual the actual result - * @param 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(); - - , S_OUT extends BaseStream> - void run(TestData data, Consumer b, Function m); - } - - protected , S_OUT extends BaseStream> - Collection exerciseOps(TestData data, Function 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, S_OUT extends BaseStream> - Collection exerciseOpsMulti(TestData data, - Function... ms) { - Collection result = null; - for (Function m : ms) { - if (result == null) - result = withData(data).stream(m).exercise(); - else { - Collection 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 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 exerciseOpsInt(TestData.OfRef data, - Function, Stream> mRef, - Function mInt, - Function mLong, - Function mDouble) { - @SuppressWarnings({ "rawtypes", "unchecked" }) - Function, Stream>[] ms = new Function[4]; - ms[0] = mRef; - ms[1] = s -> mInt.apply(s.mapToInt(e -> e)).mapToObj(e -> e); - ms[2] = s -> mLong.apply(s.mapToLong(e -> e)).mapToObj(e -> (int) e); - ms[3] = s -> mDouble.apply(s.mapToDouble(e -> e)).mapToObj(e -> (int) e); - 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, S_OUT extends BaseStream> - void exerciseTerminalOpsMulti(TestData data, - R expected, - Map> streams, - Map> terminals) { - for (Map.Entry> se : streams.entrySet()) { - setContext("Intermediate stream", se.getKey()); - for (Map.Entry> 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 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> data, - Collection expected, - String desc, - Function, Stream> mRef, - Function mInt, - Function mLong, - Function mDouble, - Map, Collection>> terminals) { - - Map, Stream>> 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 > - Collection exerciseOps(Collection data, Function, S_OUT> m) { - TestData.OfRef data1 = TestData.Factory.ofCollection("Collection of type " + data.getClass().getName(), data); - return withData(data1).stream(m).exercise(); - } - - protected , I extends Iterable> - Collection exerciseOps(Collection data, Function, S_OUT> m, I expected) { - TestData.OfRef data1 = TestData.Factory.ofCollection("Collection of type " + data.getClass().getName(), data); - return withData(data1).stream(m).expectedResult(expected).exercise(); - } - - @SuppressWarnings("unchecked") - protected > - Collection exerciseOps(int[] data, Function m) { - return withData(TestData.Factory.ofArray("int array", data)).stream(m).exercise(); - } - - protected Collection exerciseOps(int[] data, Function m, int[] expected) { - TestData.OfInt data1 = TestData.Factory.ofArray("int array", data); - return withData(data1).stream(m).expectedResult(expected).exercise(); - } - - protected > DataStreamBuilder withData(TestData data) { - Objects.requireNonNull(data); - return new DataStreamBuilder<>(data); - } - - @SuppressWarnings({"rawtypes", "unchecked"}) - public class DataStreamBuilder> { - final TestData data; - - private DataStreamBuilder(TestData data) { - this.data = Objects.requireNonNull(data); - } - - public > - ExerciseDataStreamBuilder ops(IntermediateTestOp... ops) { - return new ExerciseDataStreamBuilder<>(data, (S_IN s) -> (S_OUT) chain(s, ops)); - } - - public > ExerciseDataStreamBuilder - stream(Function m) { - return new ExerciseDataStreamBuilder<>(data, m); - } - - public > ExerciseDataStreamBuilder - stream(Function m, IntermediateTestOp additionalOp) { - return new ExerciseDataStreamBuilder<>(data, s -> (S_OUT) chain(m.apply(s), additionalOp)); - } - - public ExerciseDataTerminalBuilder - terminal(Function terminalF) { - return new ExerciseDataTerminalBuilder<>(data, s -> s, terminalF); - } - - public > ExerciseDataTerminalBuilder - terminal(Function streamF, Function terminalF) { - return new ExerciseDataTerminalBuilder<>(data, streamF, terminalF); - } - } - - @SuppressWarnings({"rawtypes", "unchecked"}) - public class ExerciseDataStreamBuilder, S_OUT extends BaseStream> { - final TestData data; - final Function m; - final StreamShape shape; - - Set testSet = new HashSet<>(); - - Collection refResult; - - Consumer> before = LambdaTestHelpers.bEmpty; - - Consumer> after = LambdaTestHelpers.bEmpty; - - ResultAsserter> resultAsserter = (act, exp, ord, par) -> { - if (par & !ord) { - LambdaTestHelpers.assertContentsUnordered(act, exp); - } - else { - LambdaTestHelpers.assertContentsEqual(act, exp); - } - }; - - private ExerciseDataStreamBuilder(TestData data, Function m) { - this.data = data; - - this.m = Objects.requireNonNull(m); - - this.shape = ((AbstractPipeline) 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 > ExerciseDataStreamBuilder expectedResult(I expectedResult) { - List l = new ArrayList<>(); - expectedResult.forEach(l::add); - refResult = l; - return this; - } - - public ExerciseDataStreamBuilder expectedResult(int[] expectedResult) { - List l = new ArrayList(); - for (int anExpectedResult : expectedResult) { - l.add(anExpectedResult); - } - refResult = l; - return this; - } - - public ExerciseDataStreamBuilder expectedResult(long[] expectedResult) { - List l = new ArrayList(); - for (long anExpectedResult : expectedResult) { - l.add(anExpectedResult); - } - refResult = l; - return this; - } - - public ExerciseDataStreamBuilder expectedResult(double[] expectedResult) { - List l = new ArrayList(); - for (double anExpectedResult : expectedResult) { - l.add(anExpectedResult); - } - refResult = l; - return this; - } - - public ExerciseDataStreamBuilder before(Consumer> before) { - this.before = Objects.requireNonNull(before); - return this; - } - - public ExerciseDataStreamBuilder after(Consumer> after) { - this.after = Objects.requireNonNull(after); - return this; - } - - public ExerciseDataStreamBuilder without(BaseStreamTestScenario... tests) { - return without(Arrays.asList(tests)); - } - - public ExerciseDataStreamBuilder without(Collection 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 with(BaseStreamTestScenario... tests) { - return with(Arrays.asList(tests)); - } - - public ExerciseDataStreamBuilder with(Collection 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 resultAsserter(ResultAsserter> resultAsserter) { - this.resultAsserter = resultAsserter; - return this; - } - - // Build method - - public Collection 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 refNodeResult = ((AbstractPipeline) 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 errors = new ArrayList<>(); - for (BaseStreamTestScenario test : testSet) { - try { - before.accept(data); - - List result = new ArrayList<>(); - test.run(data, LambdaTestHelpers.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> { - boolean requiresSingleStageSource(); - - boolean requiresParallelSource(); - - default R run(Function 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, S_OUT extends BaseStream> { - final TestData data; - final Function streamF; - final Function terminalF; - - R refResult; - - ResultAsserter resultAsserter = (act, exp, ord, par) -> LambdaTestHelpers.assertContentsEqual(act, exp); - - private ExerciseDataTerminalBuilder(TestData data, Function streamF, Function terminalF) { - this.data = data; - this.streamF = Objects.requireNonNull(streamF); - this.terminalF = Objects.requireNonNull(terminalF); - } - - // - - public ExerciseDataTerminalBuilder expectedResult(R expectedResult) { - this.refResult = expectedResult; - return this; - } - - public ExerciseDataTerminalBuilder equalator(BiConsumer equalityAsserter) { - resultAsserter = (act, exp, ord, par) -> equalityAsserter.accept(act, exp); - return this; - } - - public ExerciseDataTerminalBuilder resultAsserter(ResultAsserter 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 tests = EnumSet.allOf(TerminalTestScenario.class); - // Sequentially collect the output that will be input to the terminal op - Node 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 R exerciseTerminalOps(Collection data, Function, R> m, R expected) { - TestData.OfRef data1 - = TestData.Factory.ofCollection("Collection of type " + data.getClass().getName(), data); - return withData(data1).terminal(m).expectedResult(expected).exercise(); - } - - protected > R - exerciseTerminalOps(TestData data, - Function terminalF) { - return withData(data).terminal(terminalF).exercise(); - } - - protected , S_OUT extends BaseStream> R - exerciseTerminalOps(TestData data, - Function streamF, - Function terminalF) { - return withData(data).terminal(streamF, terminalF).exercise(); - } - - // - - @SuppressWarnings({"rawtypes", "unchecked"}) - private static AbstractPipeline chain(AbstractPipeline upstream, IntermediateTestOp op) { - return (AbstractPipeline) 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 AbstractPipeline chain(BaseStream pipe, IntermediateTestOp 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 implements StatelessTestOp { - private final StreamShape shape; - - ShortCircuitOp(StreamShape shape) { - this.shape = shape; - } - - @Override - public Sink opWrapSink(int flags, boolean parallel, Sink 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 deleted file mode 100644 index cf9ce2abe..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/SpliteratorTestHelper.java +++ /dev/null @@ -1,727 +0,0 @@ -/* - * 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 { - void assertContents(Collection actual, Collection expected, boolean isOrdered); - } - - private static ContentAsserter DEFAULT_CONTENT_ASSERTER - = SpliteratorTestHelper::assertContents; - - @SuppressWarnings("unchecked") - private static ContentAsserter defaultContentAsserter() { - return (ContentAsserter) DEFAULT_CONTENT_ASSERTER; - } - - public static void testSpliterator(Supplier> supplier) { - testSpliterator(supplier, defaultContentAsserter()); - } - - public static void testSpliterator(Supplier> supplier, - ContentAsserter asserter) { - testSpliterator(supplier, (Consumer b) -> b, asserter); - } - - public static void testIntSpliterator(Supplier supplier) { - testIntSpliterator(supplier, defaultContentAsserter()); - } - - public static void testIntSpliterator(Supplier supplier, - ContentAsserter asserter) { - class BoxingAdapter implements Consumer, IntConsumer { - private final Consumer b; - - BoxingAdapter(Consumer 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 supplier) { - testLongSpliterator(supplier, defaultContentAsserter()); - } - - public static void testLongSpliterator(Supplier supplier, - ContentAsserter asserter) { - class BoxingAdapter implements Consumer, LongConsumer { - private final Consumer b; - - BoxingAdapter(Consumer 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 supplier) { - testDoubleSpliterator(supplier, defaultContentAsserter()); - } - - public static void testDoubleSpliterator(Supplier supplier, - ContentAsserter asserter) { - class BoxingAdapter implements Consumer, DoubleConsumer { - private final Consumer b; - - BoxingAdapter(Consumer 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 > void testSpliterator(Supplier supplier, - UnaryOperator> boxingAdapter, - ContentAsserter asserter) { - ArrayList fromForEach = new ArrayList<>(); - Spliterator spliterator = supplier.get(); - Consumer addToFromForEach = boxingAdapter.apply(fromForEach::add); - spliterator.forEachRemaining(addToFromForEach); - - Collection 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 > void testNullPointerException(Supplier 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 > void testForEach( - Collection exp, - Supplier supplier, - UnaryOperator> boxingAdapter, - ContentAsserter asserter) { - S spliterator = supplier.get(); - long sizeIfKnown = spliterator.getExactSizeIfKnown(); - boolean isOrdered = spliterator.hasCharacteristics(Spliterator.ORDERED); - - ArrayList fromForEach = new ArrayList<>(); - spliterator = supplier.get(); - Consumer 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 > void testTryAdvance( - Collection exp, - Supplier supplier, - UnaryOperator> boxingAdapter, - ContentAsserter asserter) { - S spliterator = supplier.get(); - long sizeIfKnown = spliterator.getExactSizeIfKnown(); - boolean isOrdered = spliterator.hasCharacteristics(Spliterator.ORDERED); - - spliterator = supplier.get(); - ArrayList fromTryAdvance = new ArrayList<>(); - Consumer 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 > void testMixedTryAdvanceForEach( - Collection exp, - Supplier supplier, - UnaryOperator> boxingAdapter, - ContentAsserter asserter) { - S spliterator = supplier.get(); - long sizeIfKnown = spliterator.getExactSizeIfKnown(); - boolean isOrdered = spliterator.hasCharacteristics(Spliterator.ORDERED); - - // tryAdvance first few elements, then forEach rest - ArrayList dest = new ArrayList<>(); - spliterator = supplier.get(); - Consumer 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 > void testMixedTraverseAndSplit( - Collection exp, - Supplier supplier, - UnaryOperator> boxingAdapter, - ContentAsserter asserter) { - S spliterator = supplier.get(); - long sizeIfKnown = spliterator.getExactSizeIfKnown(); - boolean isOrdered = spliterator.hasCharacteristics(Spliterator.ORDERED); - - // tryAdvance first few elements, then forEach rest - ArrayList dest = new ArrayList<>(); - spliterator = supplier.get(); - Consumer b = boxingAdapter.apply(dest::add); - - Spliterator 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 > void testSplitAfterFullTraversal( - Supplier supplier, - UnaryOperator> boxingAdapter) { - // Full traversal using tryAdvance - Spliterator spliterator = supplier.get(); - while (spliterator.tryAdvance(boxingAdapter.apply(e -> { }))) { } - Spliterator 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 > void testSplitOnce( - Collection exp, - Supplier supplier, - UnaryOperator> boxingAdapter, - ContentAsserter asserter) { - S spliterator = supplier.get(); - long sizeIfKnown = spliterator.getExactSizeIfKnown(); - boolean isOrdered = spliterator.hasCharacteristics(Spliterator.ORDERED); - - ArrayList fromSplit = new ArrayList<>(); - Spliterator s1 = supplier.get(); - Spliterator s2 = s1.trySplit(); - long s1Size = s1.getExactSizeIfKnown(); - long s2Size = (s2 != null) ? s2.getExactSizeIfKnown() : 0; - Consumer 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 > void testSplitSixDeep( - Collection exp, - Supplier supplier, - UnaryOperator> boxingAdapter, - ContentAsserter asserter) { - S spliterator = supplier.get(); - boolean isOrdered = spliterator.hasCharacteristics(Spliterator.ORDERED); - - for (int depth=0; depth < 6; depth++) { - List 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 - // private static > - // Android-changed: Workaround for jack type inference bug - void splitSixDeepVisitor(int depth, int curLevel, - List dest, Spliterator spliterator, UnaryOperator> boxingAdapter, - // List dest, S spliterator, UnaryOperator> boxingAdapter, - int rootCharacteristics, boolean useTryAdvance) { - if (curLevel < depth) { - long beforeSize = spliterator.getExactSizeIfKnown(); - Spliterator 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 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 split = spliterator.trySplit(); - assertNull(split); - } - else { - List leafDest = new ArrayList<>(); - Consumer 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 split = spliterator.trySplit(); - assertNull(split); - - dest.addAll(leafDest); - } - } - } - - private static > void testSplitUntilNull( - Collection exp, - Supplier supplier, - UnaryOperator> boxingAdapter, - ContentAsserter asserter) { - Spliterator s = supplier.get(); - boolean isOrdered = s.hasCharacteristics(Spliterator.ORDERED); - assertSpliterator(s); - - List splits = new ArrayList<>(); - Consumer c = boxingAdapter.apply(splits::add); - - testSplitUntilNull(new SplitNode(c, s)); - asserter.assertContents(splits, exp, isOrdered); - } - - private static class SplitNode { - // Constant for every node - final Consumer c; - final int rootCharacteristics; - - final Spliterator s; - - SplitNode(Consumer c, Spliterator s) { - this(c, s.characteristics(), s); - } - - private SplitNode(Consumer c, int rootCharacteristics, Spliterator s) { - this.c = c; - this.rootCharacteristics = rootCharacteristics; - this.s = s; - } - - SplitNode fromSplit(Spliterator 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 void testSplitUntilNull(SplitNode 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> 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 parentAndRightSplit = e.s; - - long parentEstimateSize = parentAndRightSplit.estimateSize(); - assertTrue(parentEstimateSize >= 0, - String.format("Split size estimate %d < 0", parentEstimateSize)); - - long parentSize = parentAndRightSplit.getExactSizeIfKnown(); - Spliterator 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 void assertContents(Collection actual, Collection expected, boolean isOrdered) { - if (isOrdered) { - assertEquals(actual, expected); - } - else { - LambdaTestHelpers.assertContentsUnordered(actual, expected); - } - } - - private static void executeAndCatch(Class 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 void mixedTraverseAndSplit(Consumer b, Spliterator splTop) { - Spliterator 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 deleted file mode 100644 index 5414cfdac..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StatefulTestOp.java +++ /dev/null @@ -1,138 +0,0 @@ -/* - * 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 extends IntermediateTestOp { - - @SuppressWarnings({"rawtypes", "unchecked"}) - public static AbstractPipeline chain(AbstractPipeline upstream, - StatefulTestOp op) { - switch (op.outputShape()) { - case REFERENCE: - return new ReferencePipeline.StatefulOp(upstream, op.inputShape(), op.opGetFlags()) { - @Override - Sink opWrapSink(int flags, Sink sink) { - return op.opWrapSink(flags, isParallel(), sink); - } - - @Override - Spliterator opEvaluateParallelLazy(PipelineHelper helper, - Spliterator spliterator) { - return op.opEvaluateParallelLazy(helper, spliterator); - } - - @Override - Node opEvaluateParallel(PipelineHelper helper, - Spliterator spliterator, - IntFunction generator) { - return op.opEvaluateParallel(helper, spliterator, generator); - } - }; - case INT_VALUE: - return new IntPipeline.StatefulOp(upstream, op.inputShape(), op.opGetFlags()) { - @Override - Sink opWrapSink(int flags, Sink sink) { - return op.opWrapSink(flags, isParallel(), sink); - } - - @Override - Spliterator opEvaluateParallelLazy(PipelineHelper helper, - Spliterator spliterator) { - return op.opEvaluateParallelLazy(helper, spliterator); - } - - @Override - Node opEvaluateParallel(PipelineHelper helper, - Spliterator spliterator, - IntFunction generator) { - return (Node) op.opEvaluateParallel(helper, spliterator, generator); - } - }; - case LONG_VALUE: - return new LongPipeline.StatefulOp(upstream, op.inputShape(), op.opGetFlags()) { - @Override - Sink opWrapSink(int flags, Sink sink) { - return op.opWrapSink(flags, isParallel(), sink); - } - - @Override - Spliterator opEvaluateParallelLazy(PipelineHelper helper, - Spliterator spliterator) { - return op.opEvaluateParallelLazy(helper, spliterator); - } - - @Override - Node opEvaluateParallel(PipelineHelper helper, - Spliterator spliterator, - IntFunction generator) { - return (Node) op.opEvaluateParallel(helper, spliterator, generator); - } - }; - case DOUBLE_VALUE: - return new DoublePipeline.StatefulOp(upstream, op.inputShape(), op.opGetFlags()) { - @Override - Sink opWrapSink(int flags, Sink sink) { - return op.opWrapSink(flags, isParallel(), sink); - } - - @Override - Spliterator opEvaluateParallelLazy(PipelineHelper helper, - Spliterator spliterator) { - return op.opEvaluateParallelLazy(helper, spliterator); - } - - @Override - Node opEvaluateParallel(PipelineHelper helper, - Spliterator spliterator, - IntFunction generator) { - return (Node) 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 opWrapSink(int flags, boolean parallel, Sink sink); - - @SuppressWarnings("unchecked") - default Spliterator opEvaluateParallelLazy(PipelineHelper helper, - Spliterator spliterator) { - return opEvaluateParallel(helper, spliterator, i -> (E[]) new Object[i]).spliterator(); - } - - Node opEvaluateParallel(PipelineHelper helper, - Spliterator spliterator, - IntFunction 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 deleted file mode 100644 index 77460b79a..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StatelessTestOp.java +++ /dev/null @@ -1,73 +0,0 @@ -/* - * 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 extends IntermediateTestOp { - - @SuppressWarnings({"rawtypes", "unchecked"}) - public static AbstractPipeline chain(AbstractPipeline upstream, - StatelessTestOp op) { - int flags = op.opGetFlags(); - switch (op.outputShape()) { - case REFERENCE: - return new ReferencePipeline.StatelessOp(upstream, op.inputShape(), flags) { - public Sink opWrapSink(int flags, Sink sink) { - return op.opWrapSink(flags, isParallel(), sink); - } - }; - case INT_VALUE: - return new IntPipeline.StatelessOp(upstream, op.inputShape(), flags) { - public Sink opWrapSink(int flags, Sink sink) { - return op.opWrapSink(flags, isParallel(), sink); - } - }; - case LONG_VALUE: - return new LongPipeline.StatelessOp(upstream, op.inputShape(), flags) { - @Override - Sink opWrapSink(int flags, Sink sink) { - return op.opWrapSink(flags, isParallel(), sink); - } - }; - case DOUBLE_VALUE: - return new DoublePipeline.StatelessOp(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 opWrapSink(int flags, boolean parallel, Sink 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 deleted file mode 100644 index 11ed0f195..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StreamOpFlagTestHelper.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * 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 allStreamFlags; - - static { - allStreamFlags = EnumSet.allOf(StreamOpFlag.class); - for (StreamOpFlag f : EnumSet.allOf(StreamOpFlag.class)) - if (!f.isStreamFlag()) - allStreamFlags.remove(f); - } - - - static EnumSet 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 deleted file mode 100644 index cc98529df..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StreamTestDataProvider.java +++ /dev/null @@ -1,205 +0,0 @@ -/* - * 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 list = new ArrayList<>(); - for (Object[] data : arrays) { - final Object name = data[0]; - final Integer[] ints = (Integer[])data[1]; - final List 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 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 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 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 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 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 Object[] arrayDataDescr(String description, T[] data) { - return new Object[] { description, TestData.Factory.ofArray(description, data)}; - } - - static Object[] streamDataDescr(String description, Supplier> supplier) { - return new Object[] { description, TestData.Factory.ofSupplier(description, supplier)}; - } - - static Object[] collectionDataDescr(String description, Collection data) { - return new Object[] { description, TestData.Factory.ofCollection(description, data)}; - } - - static Object[] sbDataDescr(String description, SpinedBuffer data) { - return new Object[] { description, TestData.Factory.ofSpinedBuffer(description, data)}; - } - - static Object[] splitDescr(String description, Supplier> ss) { - return new Object[] { description, ss }; - } - - // Return an array of ( String name, StreamTestData ) - @DataProvider(name = "StreamTestData") - public static Object[][] makeStreamTestData() { - return testData; - } - - @DataProvider(name = "withNull:StreamTestData") - public static Object[][] makeStreamWithNullTestData() { - return withNullTestData; - } - - // returns an array of (String name, Supplier>) - @DataProvider(name = "Spliterator") - 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 deleted file mode 100644 index d19c4162e..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java +++ /dev/null @@ -1,270 +0,0 @@ -/* - * 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) { - > - void _run(TestData data, Consumer b, Function> m) { - Stream s = m.apply(data.stream()); - if (s.isParallel()) { - s = s.sequential(); - } - s.forEach(b); - s.close(); - } - }, - - // Collec to list - STREAM_COLLECT(false) { - > - void _run(TestData data, Consumer b, Function> m) { - for (U t : m.apply(data.stream()).collect(Collectors.toList())) { - b.accept(t); - } - } - }, - - // To array - STREAM_TO_ARRAY(false) { - > - void _run(TestData data, Consumer b, Function> m) { - for (Object t : m.apply(data.stream()).toArray()) { - b.accept((U) t); - } - } - }, - - // Wrap as stream, and iterate in pull mode - STREAM_ITERATOR(false) { - > - void _run(TestData data, Consumer b, Function> m) { - for (Iterator 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) { - > - void _run(TestData data, Consumer b, Function> m) { - for (Spliterator 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) { - > - void _run(TestData data, Consumer b, Function> m) { - SpliteratorTestHelper.mixedTraverseAndSplit(b, m.apply(data.stream()).spliterator()); - } - }, - - // Wrap as stream, and spliterate then iterate in pull mode - STREAM_SPLITERATOR_FOREACH(false) { - > - void _run(TestData data, Consumer b, Function> m) { - m.apply(data.stream()).spliterator().forEachRemaining(b); - } - }, - - // Wrap as parallel stream + sequential - PAR_STREAM_SEQUENTIAL_FOR_EACH(true) { - > - void _run(TestData data, Consumer b, Function> m) { - m.apply(data.parallelStream()).sequential().forEach(b); - } - }, - - // Wrap as parallel stream + forEachOrdered - PAR_STREAM_FOR_EACH_ORDERED(true) { - > - void _run(TestData data, Consumer b, Function> 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) { - > - void _run(TestData data, Consumer b, Function> m) { - for (Spliterator spl = m.apply(data.parallelStream()).spliterator(); spl.tryAdvance(b); ) { } - } - }, - - // Wrap as stream, and spliterate then iterate sequentially - PAR_STREAM_SPLITERATOR_FOREACH(true) { - > - void _run(TestData data, Consumer b, Function> m) { - m.apply(data.parallelStream()).spliterator().forEachRemaining(b); - } - }, - - // Wrap as parallel stream + toArray - PAR_STREAM_TO_ARRAY(true) { - > - void _run(TestData data, Consumer b, Function> 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) { - > - void _run(TestData data, Consumer b, Function> m) { - Stream s = m.apply(data.parallelStream()); - Spliterator sp = s.spliterator(); - Stream 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) { - > - void _run(TestData data, Consumer b, Function> m) { - S_IN pipe1 = (S_IN) OpTestCase.chain(data.parallelStream(), - new FlagDeclaringOp(StreamOpFlag.NOT_SIZED, data.getShape())); - Stream 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) { - > - void _run(TestData data, Consumer b, Function> 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) { - > - void _run(TestData data, Consumer b, Function> 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) { - > - void _run(TestData data, Consumer b, Function> 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) { - > - void _run(TestData data, Consumer b, Function> 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) { - > - void _run(TestData data, Consumer b, Function> 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 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 , S_OUT extends BaseStream> - void run(TestData data, Consumer b, Function m) { - _run(data, b, (Function>) m); - } - - abstract > - void _run(TestData data, Consumer b, Function> 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 deleted file mode 100644 index c763e8415..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/TestData.java +++ /dev/null @@ -1,355 +0,0 @@ -/* - * 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> - extends Iterable { - - default int size() { - throw new UnsupportedOperationException(); - } - - @Override - default Iterator iterator() { - return Spliterators.iterator(spliterator()); - } - - Spliterator spliterator(); - - default boolean isOrdered() { - return spliterator().hasCharacteristics(Spliterator.ORDERED); - } - - StreamShape getShape(); - - default > A into(A target) { - spliterator().forEachRemaining(target::add); - return target; - } - - S stream(); - - S parallelStream(); - - public interface OfRef extends TestData> { } - - public interface OfInt extends TestData { } - - public interface OfLong extends TestData { } - - public interface OfDouble extends TestData { } - - // @@@ Temporary garbage class to avoid triggering bugs with lambdas in static methods in interfaces - public static class Factory { - public static OfRef 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 OfRef ofCollection(String name, Collection collection) { - return new AbstractTestData.RefTestData<>(name, collection, Collection::stream, Collection::parallelStream, - Collection::spliterator, Collection::size); - } - - public static OfRef ofSpinedBuffer(String name, SpinedBuffer 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 OfRef ofSupplier(String name, Supplier> 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 OfRef ofRefNode(String name, Node 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 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 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 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 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 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 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_STATE, - T_SPLITR extends Spliterator> - implements TestData { - private final String name; - private final StreamShape shape; - protected final T_STATE state; - private final ToIntFunction sizeFn; - private final Function streamFn; - private final Function parStreamFn; - private final Function splitrFn; - - AbstractTestData(String name, - StreamShape shape, - T_STATE state, - Function streamFn, - Function parStreamFn, - Function splitrFn, - ToIntFunction 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 - extends AbstractTestData, I, Spliterator> - implements TestData.OfRef { - - protected RefTestData(String name, - I state, - Function> streamFn, - Function> parStreamFn, - Function> splitrFn, - ToIntFunction sizeFn) { - super(name, StreamShape.REFERENCE, state, streamFn, parStreamFn, splitrFn, sizeFn); - } - - } - - static class IntTestData - extends AbstractTestData - implements TestData.OfInt { - - protected IntTestData(String name, - I state, - Function streamFn, - Function parStreamFn, - Function splitrFn, - ToIntFunction sizeFn) { - super(name, StreamShape.INT_VALUE, state, streamFn, parStreamFn, splitrFn, sizeFn); - } - - @Override - public PrimitiveIterator.OfInt iterator() { - return Spliterators.iterator(spliterator()); - } - - @Override - public > A into(A target) { - spliterator().forEachRemaining((IntConsumer) target::add); - return target; - } - } - - static class LongTestData - extends AbstractTestData - implements TestData.OfLong { - - protected LongTestData(String name, - I state, - Function streamFn, - Function parStreamFn, - Function splitrFn, - ToIntFunction sizeFn) { - super(name, StreamShape.LONG_VALUE, state, streamFn, parStreamFn, splitrFn, sizeFn); - } - - @Override - public PrimitiveIterator.OfLong iterator() { - return Spliterators.iterator(spliterator()); - } - - @Override - public > A into(A target) { - spliterator().forEachRemaining((LongConsumer) target::add); - return target; - } - } - - static class DoubleTestData - extends AbstractTestData - implements OfDouble { - - protected DoubleTestData(String name, - I state, - Function streamFn, - Function parStreamFn, - Function splitrFn, - ToIntFunction sizeFn) { - super(name, StreamShape.DOUBLE_VALUE, state, streamFn, parStreamFn, splitrFn, sizeFn); - } - - @Override - public PrimitiveIterator.OfDouble iterator() { - return Spliterators.iterator(spliterator()); - } - - @Override - public > 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 deleted file mode 100644 index c59a18555..000000000 --- a/ojluni/src/test/java/util/stream/bootlib/java/util/stream/TestFlagExpectedOp.java +++ /dev/null @@ -1,125 +0,0 @@ -/* - * 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 extends FlagDeclaringOp { - - static class Builder { - final int flags; - StreamShape shape = StreamShape.REFERENCE; - - EnumSet known = EnumSet.noneOf(StreamOpFlag.class); - EnumSet preserve = EnumSet.noneOf(StreamOpFlag.class); - EnumSet notKnown = EnumSet.noneOf(StreamOpFlag.class); - - Builder(int flags) { - this.flags = flags; - } - - Builder known(EnumSet known) { - this.known = known; - return this; - } - - Builder preserve(EnumSet preserve) { - this.preserve = preserve; - return this; - } - - Builder notKnown(EnumSet notKnown) { - this.notKnown = notKnown; - return this; - } - - Builder shape(StreamShape shape) { - this.shape = shape; - return this; - } - - TestFlagExpectedOp build() { - return new TestFlagExpectedOp<>(flags, known, preserve, notKnown, shape); - } - } - - final EnumSet known; - final EnumSet preserve; - final EnumSet notKnown; - final StreamShape shape; - - TestFlagExpectedOp(int flags, - EnumSet known, - EnumSet preserve, - EnumSet notKnown) { - this(flags, known, preserve, notKnown, StreamShape.REFERENCE); - } - - TestFlagExpectedOp(int flags, - EnumSet known, - EnumSet preserve, - EnumSet 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 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 deleted file mode 100644 index d51ddf788..000000000 --- a/ojluni/src/test/java/util/stream/boottest/TEST.properties +++ /dev/null @@ -1,5 +0,0 @@ -# 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 deleted file mode 100644 index c1e8a309e..000000000 --- a/ojluni/src/test/java/util/stream/boottest/java/util/stream/DoubleNodeTest.java +++ /dev/null @@ -1,179 +0,0 @@ -/* - * 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 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> 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 node : nodes) { - params.add(new Object[]{array, node}); - } - - } - - return params.toArray(new Object[0][]); - } - - private static void assertEqualsListDoubleArray(List list, double[] array) { - assertEquals(list.size(), array.length); - for (int i = 0; i < array.length; i++) - assertEquals(array[i], list.get(i)); - } - - private List toList(double[] a) { - List l = new ArrayList<>(); - for (double i : a) { - l.add(i); - } - - return l; - } - - private double[] toDoubleArray(List 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 l, Function, 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 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 deleted file mode 100644 index 154310879..000000000 --- a/ojluni/src/test/java/util/stream/boottest/java/util/stream/FlagOpTest.java +++ /dev/null @@ -1,283 +0,0 @@ -/* - * 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", dataProviderClass = StreamTestDataProvider.class) - public void testFlagsPassThrough(String name, TestData> data) { - - @SuppressWarnings({"unchecked", "rawtypes"}) - TestFlagPassThroughOp[] 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 extends FlagDeclaringOp { - TestFlagPassThroughOp upstream; - TestFlagPassThroughOp downstream; - - TestFlagPassThroughOp() { - super(0); - } - - void set(TestFlagPassThroughOp upstream, TestFlagPassThroughOp downstream) { - this.upstream = upstream; - this.downstream = downstream; - } - - int wrapFlags; - - @Override - @SuppressWarnings({"unchecked", "rawtypes"}) - public Sink 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 known = EnumSet.noneOf(StreamOpFlag.class); - EnumSet notKnown = StreamOpFlagTestHelper.allStreamFlags(); - - List> 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> 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 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 notKnown = EnumSet.noneOf(StreamOpFlag.class); - - List> 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> 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> cf) { - EnumSet known = EnumSet.of(StreamOpFlag.ORDERED, StreamOpFlag.SIZED); - EnumSet preserve = EnumSet.of(StreamOpFlag.DISTINCT, StreamOpFlag.SORTED); - - List> 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> 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> cf) { - EnumSet known = EnumSet.of(StreamOpFlag.ORDERED, StreamOpFlag.SIZED); - EnumSet preserve = EnumSet.of(StreamOpFlag.DISTINCT, StreamOpFlag.SORTED); - EnumSet notKnown = EnumSet.noneOf(StreamOpFlag.class); - - List> 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> 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 parKnown = EnumSet.of(StreamOpFlag.SIZED); - EnumSet serKnown = parKnown.clone(); - - List> 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> 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 extends FlagDeclaringOp { - final EnumSet parKnown; - final EnumSet serKnown; - - ParSerTestFlagExpectedOp(int flags, EnumSet known, EnumSet serKnown) { - super(flags); - this.parKnown = known; - this.serKnown = serKnown; - } - - @Override - @SuppressWarnings({"unchecked", "rawtypes"}) - public Sink 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 deleted file mode 100644 index e050e63d3..000000000 --- a/ojluni/src/test/java/util/stream/boottest/java/util/stream/IntNodeTest.java +++ /dev/null @@ -1,177 +0,0 @@ -/* - * 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 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> 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 node : nodes) { - params.add(new Object[]{array, node}); - } - - } - - return params.toArray(new Object[0][]); - } - - private static void assertEqualsListIntArray(List 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 toList(int[] a) { - List l = new ArrayList<>(); - for (int i : a) { - l.add(i); - } - - return l; - } - - private int[] toIntArray(List 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 l, Function, 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 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 deleted file mode 100644 index d266fd7d0..000000000 --- a/ojluni/src/test/java/util/stream/boottest/java/util/stream/LongNodeTest.java +++ /dev/null @@ -1,178 +0,0 @@ -/* - * 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 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> 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 node : nodes) { - params.add(new Object[]{array, node}); - } - - } - - return params.toArray(new Object[0][]); - } - - private static void assertEqualsListLongArray(List 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 toList(long[] a) { - List l = new ArrayList<>(); - for (long i : a) { - l.add(i); - } - - return l; - } - - private long[] toLongArray(List 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 l, Function, 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 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 deleted file mode 100644 index 11fe86f31..000000000 --- a/ojluni/src/test/java/util/stream/boottest/java/util/stream/NodeBuilderTest.java +++ /dev/null @@ -1,236 +0,0 @@ -/* - * 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 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> ls = new ArrayList<>(); - for (int size : sizes) { - ls.add(countTo(size)); - } - - List>> 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 l : ls) { - for (Function> m : ms) { - params[i++] = new Object[]{l, m}; - } - } - - return params; - } - - @Test(dataProvider = "Node.Builder", groups = { "serialization-hostile" }) - public void testIteration(List l, Function> m) { - Node.Builder nb = m.apply(l.size()); - nb.begin(l.size()); - for (Integer i : l) { - nb.accept(i); - } - nb.end(); - - Node n = nb.build(); - assertEquals(n.count(), l.size()); - - { - List _l = new ArrayList<>(); - n.forEach(_l::add); - - assertContents(_l, l); - } - } - - // Node.Builder.OfInt - - @DataProvider(name = "Node.Builder") - public Object[][] createIntNodeBuilders() { - List> ls = new ArrayList<>(); - for (int size : sizes) { - ls.add(countTo(size)); - } - - List>> ms = Arrays.asList( - s -> Nodes.intBuilder(), - s -> Nodes.intBuilder(s) - ); - - Object[][] params = new Object[ls.size() * ms.size()][]; - int i = 0; - for (List l : ls) { - for (Function> m : ms) { - params[i++] = new Object[]{l, m}; - } - } - - return params; - } - - @Test(dataProvider = "Node.Builder", groups = { "serialization-hostile" }) - public void testIntIteration(List l, Function 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 _l = new ArrayList<>(); - n.forEach((IntConsumer) _l::add); - - assertContents(_l, l); - } - - } - - // Node.Builder.OfLong - - @DataProvider(name = "Node.Builder") - public Object[][] createLongNodeBuilders() { - List> ls = new ArrayList<>(); - for (int size : sizes) { - List l = new ArrayList<>(); - for (long i = 0; i < size; i++) { - l.add(i); - } - ls.add(l); - } - - List>> ms = Arrays.asList( - s -> Nodes.longBuilder(), - s -> Nodes.longBuilder(s) - ); - - Object[][] params = new Object[ls.size() * ms.size()][]; - int i = 0; - for (List l : ls) { - for (Function> m : ms) { - params[i++] = new Object[]{l, m}; - } - } - - return params; - } - - @Test(dataProvider = "Node.Builder") - public void testLongIteration(List l, Function 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 _l = new ArrayList<>(); - n.forEach((LongConsumer) _l::add); - - assertContents(_l, l); - } - - } - - // Node.Builder.OfDouble - - @DataProvider(name = "Node.Builder") - public Object[][] createDoubleNodeBuilders() { - List> ls = new ArrayList<>(); - for (int size : sizes) { - List l = new ArrayList<>(); - for (long i = 0; i < size; i++) { - l.add((double) i); - } - ls.add(l); - } - - List>> ms = Arrays.asList( - s -> Nodes.doubleBuilder(), - s -> Nodes.doubleBuilder(s) - ); - - Object[][] params = new Object[ls.size() * ms.size()][]; - int i = 0; - for (List l : ls) { - for (Function> m : ms) { - params[i++] = new Object[]{l, m}; - } - } - - return params; - } - - @Test(dataProvider = "Node.Builder") - public void testDoubleIteration(List l, Function 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 _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 deleted file mode 100644 index da710033f..000000000 --- a/ojluni/src/test/java/util/stream/boottest/java/util/stream/NodeTest.java +++ /dev/null @@ -1,154 +0,0 @@ -/* - * 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 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> 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 fill(Integer[] array, Node.Builder nb) { - nb.begin(array.length); - for (Integer i : array) { - nb.accept(i); - } - nb.end(); - return nb.build(); - } - - Node degenerateTree(Iterator it) { - if (!it.hasNext()) { - return Nodes.node(Collections.emptyList()); - } - - Integer i = it.next(); - if (it.hasNext()) { - return new Nodes.ConcNode(Nodes.node(new Integer[] {i}), degenerateTree(it)); - } - else { - return Nodes.node(new Integer[]{i}); - } - } - - Node tree(List l, Function, Node> 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 n) { - assertEquals(n.asArray(LambdaTestHelpers.integerArrayGenerator), array); - } - - @Test(dataProvider = "nodes") - public void testFlattenAsArray(Integer[] array, Node n) { - assertEquals(Nodes.flatten(n, LambdaTestHelpers.integerArrayGenerator) - .asArray(LambdaTestHelpers.integerArrayGenerator), array); - } - - @Test(dataProvider = "nodes") - public void testCopyTo(Integer[] array, Node 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 n) { - List 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 n) { - TestData> data = TestData.Factory.ofRefNode("Node", n); - - exerciseOps(data, s -> s); - - exerciseTerminalOps(data, s -> s.toArray()); - } - - @Test(dataProvider = "nodes") - public void testSpliterator(Integer[] array, Node n) { - SpliteratorTestHelper.testSpliterator(n::spliterator); - } - - @Test(dataProvider = "nodes") - public void testTruncate(Integer[] array, Node n) { - int[] nums = new int[] { 0, 1, array.length / 2, array.length - 1, array.length }; - for (int start : nums) - for (int end : nums) { - if (start < 0 || end < 0 || end < start || end > array.length) - continue; - Node slice = n.truncate(start, end, Integer[]::new); - Integer[] asArray = slice.asArray(Integer[]::new); - for (int k = start; k < end; k++) - assertEquals(array[k], asArray[k - start]); - } - } -} diff --git a/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 deleted file mode 100644 index 7aa27bf5b..000000000 --- a/ojluni/src/test/java/util/stream/boottest/java/util/stream/SliceSpliteratorTest.java +++ /dev/null @@ -1,201 +0,0 @@ -/* - * 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 implements SpliteratorTestHelper.ContentAsserter { - Collection source; - - UnorderedContentAsserter(Collection source) { - this.source = source; - } - - @Override - public void assertContents(Collection actual, Collection 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 data = new ArrayList<>(); - - // SIZED/SUBSIZED slice spliterator - - { - SliceTester r = (size, skip, limit) -> { - final Collection source = IntStream.range(0, size).boxed().collect(toList()); - - SpliteratorTestHelper.testSpliterator(() -> { - Spliterator 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 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 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 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 source = IntStream.range(0, size).boxed().collect(toList()); - final UnorderedContentAsserter uca = new UnorderedContentAsserter<>(source); - - SpliteratorTestHelper.testSpliterator(() -> { - Spliterator 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 source = IntStream.range(0, size).boxed().collect(toList()); - final UnorderedContentAsserter 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 source = LongStream.range(0, size).boxed().collect(toList()); - final UnorderedContentAsserter 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 source = LongStream.range(0, size).asDoubleStream().boxed().collect(toList()); - final UnorderedContentAsserter 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 deleted file mode 100644 index 26a62cab6..000000000 --- a/ojluni/src/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java +++ /dev/null @@ -1,370 +0,0 @@ -/* - * 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 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 params = new ArrayList<>(); - - for (int size : sizes) { - int[] array = IntStream.range(0, size).toArray(); - - SpinedBuffer 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 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 sb) { - Spliterator spliterator = sb.spliterator(); - Spliterator split = spliterator.trySplit(); - long splitSizes = (split == null) ? 0 : split.getExactSizeIfKnown(); - long lastSplitSize = spliterator.getExactSizeIfKnown(); - splitSizes += lastSplitSize; - - assertEquals(splitSizes, array.length); - - List contentOfLastSplit = new ArrayList<>(); - spliterator.forEachRemaining(contentOfLastSplit::add); - - assertEquals(contentOfLastSplit.size(), lastSplitSize); - - List end = Arrays.stream(array) - .boxed() - .skip(array.length - lastSplitSize) - .collect(Collectors.toList()); - assertEquals(contentOfLastSplit, end); - } - - @Test(groups = { "serialization-hostile" }) - public void testSpinedBuffer() { - List list1 = new ArrayList<>(); - List list2 = new ArrayList<>(); - SpinedBuffer sb = new SpinedBuffer<>(); - for (int i = 0; i < TEST_SIZE; i++) { - list1.add(i); - sb.accept(i); - } - Iterator 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 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 contentOfLastSplit = new ArrayList<>(); - spliterator.forEachRemaining((IntConsumer) contentOfLastSplit::add); - - assertEquals(contentOfLastSplit.size(), lastSplitSize); - - List end = Arrays.stream(array) - .boxed() - .skip(array.length - lastSplitSize) - .collect(Collectors.toList()); - assertEquals(contentOfLastSplit, end); - } - - @Test(groups = { "serialization-hostile" }) - public void testIntSpinedBuffer() { - List list1 = new ArrayList<>(); - List 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 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 contentOfLastSplit = new ArrayList<>(); - spliterator.forEachRemaining((LongConsumer) contentOfLastSplit::add); - - assertEquals(contentOfLastSplit.size(), lastSplitSize); - - List end = Arrays.stream(array) - .boxed() - .skip(array.length - lastSplitSize) - .collect(Collectors.toList()); - assertEquals(contentOfLastSplit, end); - } - - @Test(groups = { "serialization-hostile" }) - public void testLongSpinedBuffer() { - List list1 = new ArrayList<>(); - List 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 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 contentOfLastSplit = new ArrayList<>(); - spliterator.forEachRemaining((DoubleConsumer) contentOfLastSplit::add); - - assertEquals(contentOfLastSplit.size(), lastSplitSize); - - List end = Arrays.stream(array) - .boxed() - .skip(array.length - lastSplitSize) - .collect(Collectors.toList()); - assertEquals(contentOfLastSplit, end); - } - - @Test(groups = { "serialization-hostile" }) - public void testDoubleSpinedBuffer() { - List list1 = new ArrayList<>(); - List 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 deleted file mode 100644 index 29243cfb9..000000000 --- a/ojluni/src/test/java/util/stream/boottest/java/util/stream/StreamFlagsTest.java +++ /dev/null @@ -1,96 +0,0 @@ -/* - * 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 arrayList = new ArrayList().stream(); - Stream linkedList = new LinkedList().stream(); - Stream hashSet = new HashSet().stream(); - Stream treeSet = new TreeSet().stream(); - Stream linkedHashSet = new LinkedHashSet().stream(); - Stream repeat = Stream.generate(() -> ""); - - Stream[] streams = { arrayList, linkedList, hashSet, treeSet, linkedHashSet, repeat }; - - private void assertFlags(int value, EnumSet setFlags, EnumSet clearFlags) { - for (StreamOpFlag flag : setFlags) - assertTrue(flag.isKnown(value)); - for (StreamOpFlag flag : clearFlags) - assertTrue(!flag.isKnown(value)); - } - - public void testBaseStreams() { - Stream arrayList = new ArrayList().stream(); - Stream linkedList = new LinkedList().stream(); - Stream hashSet = new HashSet().stream(); - Stream treeSet = new TreeSet().stream(); - Stream linkedHashSet = new LinkedHashSet().stream(); - Stream 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 deleted file mode 100644 index aa47aa2a1..000000000 --- a/ojluni/src/test/java/util/stream/boottest/java/util/stream/StreamOpFlagsTest.java +++ /dev/null @@ -1,381 +0,0 @@ -/* - * 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 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 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 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 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 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 { - final Comparator c; - - SortedEmptySpliterator(Comparator c) { - this.c = c; - } - - @Override - public Spliterator trySplit() { - return null; - } - - @Override - public boolean tryAdvance(Consumer action) { - return false; - } - - @Override - public long estimateSize() { - return Long.MAX_VALUE; - } - - @Override - public int characteristics() { - return Spliterator.SORTED; - } - - @Override - public Comparator 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 deleted file mode 100644 index 0ac9d68f4..000000000 --- a/ojluni/src/test/java/util/stream/boottest/java/util/stream/StreamReuseTest.java +++ /dev/null @@ -1,441 +0,0 @@ -/* - * 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 , D extends TestData> void assertSecondFails( - D data, - Function first, - Function second, - Class 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", dataProviderClass = StreamTestDataProvider.class) - public void testTwoStreams(String name, TestData> data) { - assertSecondFails(data, - (Stream s) -> s.map(i -> i), (Stream s) -> s.map(i -> i), - IllegalStateException.class, - "Stream map / map succeeded erroneously"); - assertSecondFails(data, - Stream::distinct, (Stream s) -> s.map(i -> i), - IllegalStateException.class, - "Stream distinct / map succeeded erroneously"); - assertSecondFails(data, - (Stream 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", dataProviderClass = StreamTestDataProvider.class) - public void testTwoTerminals(String name, TestData> data) { - assertSecondFails(data, - Stream::findFirst, Stream::findFirst, - IllegalStateException.class, - "Stream findFirst / findFirst succeeded erroneously"); - } - - @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class) - public void testTerminalStream(String name, TestData> data) { - assertSecondFails(data, - Stream::findFirst, (Stream s) -> s.map(i -> i), - IllegalStateException.class, - "Stream findFirst / map succeeded erroneously"); - assertSecondFails(data, - (Stream 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", dataProviderClass = StreamTestDataProvider.class) - public void testTwoIterators(String name, TestData> data) { - assertSecondFails(data, - Stream::iterator, Stream::iterator, - IllegalStateException.class, - "Stream iterator / iterator succeeded erroneously"); - } - - @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class) - public void testTerminalIterator(String name, TestData> 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", dataProviderClass = StreamTestDataProvider.class) - public void testStreamIterator(String name, TestData> data) { - assertSecondFails(data, - Stream::iterator, (Stream s) -> s.map(i -> i), - IllegalStateException.class, - "Stream iterator / map succeeded erroneously"); - assertSecondFails(data, - (Stream 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 deleted file mode 100644 index 4128f6afd..000000000 --- a/ojluni/src/test/java/util/stream/test/TEST.properties +++ /dev/null @@ -1,8 +0,0 @@ -# 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 deleted file mode 100644 index 1fbf76924..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/lang/invoke/DeserializeMethodTest.java +++ /dev/null @@ -1,87 +0,0 @@ -/* - * 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 deleted file mode 100644 index fdbd689ad..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/lang/invoke/SerializedLambdaTest.java +++ /dev/null @@ -1,357 +0,0 @@ -/* - * 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 void assertSerial(T p, Consumer asserter) throws IOException, ClassNotFoundException { - asserter.accept(p); - - for (int i=0; i 0); - - asserter.accept((T) deserialize(bytes)); - } - } - - private void assertNotSerial(Predicate p, Consumer> 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 pred = (Predicate & Serializable) s -> true; - assertSerial(pred, - p -> { - assertTrue(p instanceof Predicate); - assertTrue(p instanceof Serializable); - assertTrue(p.test("")); - }); - } - - interface SerPredicate extends Predicate, Serializable { } - - // Test instantiating against derived type - public void testSimpleSerializedInstantiation2() throws IOException, ClassNotFoundException { - SerPredicate serPred = (SerPredicate) 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 pred = (Predicate) 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 foo(int x) { - return (Predicate & Serializable) s -> s.length() >= x; - } - } - Predicate 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 foo(String t) { - return (Predicate & Serializable) s -> s.equals(t); - } - } - Predicate 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 foo(Box b) { - return (Predicate & Serializable) s -> s.equals(b.s); - } - } - Predicate 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 mh1 = (Predicate & Serializable) SerializedLambdaTest::startsWithA; - @SuppressWarnings("unchecked") - Predicate mh2 = (SerPredicate) SerializedLambdaTest::startsWithA; - Consumer> 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 mh1 = (BiPredicate & Serializable) Moo::startsWithB; - Consumer> 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 mh1 = (Predicate & Serializable) moo::startsWithB; - @SuppressWarnings("unchecked") - Predicate mh2 = (SerPredicate) moo::startsWithB; - Consumer> 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 mh1 = (Predicate & Serializable) moo::startsWithB; - @SuppressWarnings("unchecked") - Predicate mh2 = (SerPredicate) moo::startsWithB; - Consumer> 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 ctor = (Supplier & Serializable) ForCtorRef::new; - Consumer> 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 list = new ArrayList<>(); - Consumer c = (Consumer & 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> 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 p = (Predicate) 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) 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) 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) 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) 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 deleted file mode 100644 index d4cad598f..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/FillableStringTest.java +++ /dev/null @@ -1,56 +0,0 @@ -/* - * 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 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 deleted file mode 100644 index 74efed584..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/MapTest.java +++ /dev/null @@ -1,93 +0,0 @@ -/* - * 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 EXPECTED = new HashMap<>(); - - private Map 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 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 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 deleted file mode 100644 index 5cae1ba74..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/NullArgsTestCase.java +++ /dev/null @@ -1,70 +0,0 @@ -/* - * 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 sink; - public final Object[] args; - - protected NullArgsTestCase(String name, Consumer 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 content = LambdaTestHelpers.countTo(10); - - List> 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 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 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 c) { - assertTrue(c.remove(1)); - Stream s = c.stream(); - assertTrue(c.remove(2)); - Object[] result = s.toArray(); - assertEquals(result.length, c.size()); - } - - @DataProvider(name = "maps") - public Object[][] createMaps() { - Map content = new HashMap<>(); - for (int i = 0; i < 10; i++) { - content.put(i, i); - } - - Map>> 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>> 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> c) { - testCollectionSizeRemove(name + " key set", c.get().keySet()); - } - - @Test(dataProvider = "maps", groups = { "serialization-hostile" }) - public void testMapValuesSizeRemove(String name, Supplier> c) { - testCollectionSizeRemove(name + " value set", c.get().values()); - } - - @Test(dataProvider = "maps") - public void testMapEntriesSizeRemove(String name, Supplier> c) { - testEntrySetSizeRemove(name + " entry set", c.get().entrySet()); - } - - private void testEntrySetSizeRemove(String name, Set> c) { - Map.Entry first = c.iterator().next(); - assertTrue(c.remove(first)); - Stream> s = c.stream(); - Map.Entry 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 deleted file mode 100644 index 43c513449..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ConcatOpTest.java +++ /dev/null @@ -1,142 +0,0 @@ -/* - * 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", dataProviderClass = StreamTestDataProvider.class) - public void testOps(String name, TestData.OfRef 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 deleted file mode 100644 index cac59c2fe..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ConcatTest.java +++ /dev/null @@ -1,238 +0,0 @@ -/* - * 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 part1 = Arrays.asList(5, 3, 4, 1, 2, 6, 2, 4); - List part2 = Arrays.asList(8, 8, 6, 6, 9, 7, 10, 9); - List p1p2 = Arrays.asList(5, 3, 4, 1, 2, 6, 2, 4, 8, 8, 6, 6, 9, 7, 10, 9); - List p2p1 = Arrays.asList(8, 8, 6, 6, 9, 7, 10, 9, 5, 3, 4, 1, 2, 6, 2, 4); - List empty = new LinkedList<>(); // To be ordered - assertTrue(empty.isEmpty()); - LinkedHashSet distinctP1 = new LinkedHashSet<>(part1); - LinkedHashSet distinctP2 = new LinkedHashSet<>(part2); - TreeSet sortedP1 = new TreeSet<>(part1); - TreeSet 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 c1, Collection c2, Collection expected) { - return new Object[] { - new ConcatTest(scenario, c1, c2, expected) - }; - } - - protected final String scenario; - protected final Collection c1; - protected final Collection c2; - protected final Collection expected; - - public ConcatTest(String scenario, Collection c1, Collection c2, Collection 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 s1s = c1.stream(); - Stream s2s = c2.stream(); - Stream s1p = c1.parallelStream(); - Stream 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 void assertConcatContent(Spliterator sp, boolean ordered, Spliterator 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 s1, Stream s2, boolean parallel, boolean ordered) { - Stream result = Stream.concat(s1, s2); - assertEquals(result.isParallel(), parallel); - assertConcatContent(result.spliterator(), ordered, expected.spliterator()); - } - - private void assertIntConcat(Stream s1, Stream 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 s1, Stream 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 s1, Stream 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 deleted file mode 100644 index 9b87a09f3..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountLargeTest.java +++ /dev/null @@ -1,70 +0,0 @@ -/* - * 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 deleted file mode 100644 index 5bf2876f3..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/CountTest.java +++ /dev/null @@ -1,91 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -/** - * @test - * @summary Tests counting of streams - * @bug 8031187 - */ - -package org.openjdk.tests.java.util.stream; - -import java.util.concurrent.atomic.AtomicLong; -import java.util.stream.DoubleStream; -import java.util.stream.DoubleStreamTestDataProvider; -import java.util.stream.IntStream; -import java.util.stream.IntStreamTestDataProvider; -import java.util.stream.LongStream; -import java.util.stream.LongStreamTestDataProvider; -import java.util.stream.OpTestCase; -import java.util.stream.Stream; -import java.util.stream.StreamTestDataProvider; -import java.util.stream.TestData; - -import org.testng.annotations.Test; - -public class CountTest extends OpTestCase { - - @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class) - public void testOps(String name, TestData.OfRef data) { - AtomicLong expectedCount = new AtomicLong(); - data.stream().forEach(e -> expectedCount.incrementAndGet()); - - withData(data). - terminal(Stream::count). - expectedResult(expectedCount.get()). - exercise(); - } - - @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class) - public void testOps(String name, TestData.OfInt data) { - AtomicLong expectedCount = new AtomicLong(); - data.stream().forEach(e -> expectedCount.incrementAndGet()); - - withData(data). - terminal(IntStream::count). - expectedResult(expectedCount.get()). - exercise(); - } - - @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class) - public void testOps(String name, TestData.OfLong data) { - AtomicLong expectedCount = new AtomicLong(); - data.stream().forEach(e -> expectedCount.incrementAndGet()); - - withData(data). - terminal(LongStream::count). - expectedResult(expectedCount.get()). - exercise(); - } - - @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class) - public void testOps(String name, TestData.OfDouble data) { - AtomicLong expectedCount = new AtomicLong(); - data.stream().forEach(e -> expectedCount.incrementAndGet()); - - withData(data). - terminal(DoubleStream::count). - expectedResult(expectedCount.get()). - exercise(); - } -} 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 deleted file mode 100644 index f59a4f38a..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/DistinctOpTest.java +++ /dev/null @@ -1,200 +0,0 @@ -/* - * 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 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", dataProviderClass = StreamTestDataProvider.class) - public void testOp(String name, TestData.OfRef data) { - Collection 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", dataProviderClass = StreamTestDataProvider.class) - public void testOpWithNull(String name, TestData.OfRef data) { - Collection 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", dataProviderClass = StreamTestDataProvider.class) - public void testOpWithNullSorted(String name, TestData.OfRef data) { - ArrayList 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 node = exerciseOps(new SortedTestData<>(l), Stream::distinct); - assertUnique(node); - assertSorted(node, cNullInteger); - } - - @SuppressWarnings("serial") - static class SortedTestData extends TestData.AbstractTestData.RefTestData> { - SortedTestData(List 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 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", dataProviderClass = StreamTestDataProvider.class) - public void testDistinctDistinct(String name, TestData.OfRef data) { - Collection result = exerciseOpsInt( - data, - s -> s.distinct().distinct(), - s -> s.distinct().distinct(), - s -> s.distinct().distinct(), - s -> s.distinct().distinct()); - - assertUnique(result); - } - - @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class) - public void testDistinctSorted(String name, TestData.OfRef data) { - Collection result = withData(data) - .stream(s -> s.distinct().sorted(), - new CollectorOps.TestParallelSizedOp<>()) - .exercise(); - assertUnique(result); - assertSorted(result); - } - - @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class) - public void testSortedDistinct(String name, TestData.OfRef data) { - Collection 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 input = IntStream.rangeClosed(0, 1000) - .mapToObj(i -> new Integer(1000)) // explicit construction - .collect(Collectors.toList()); - Integer expectedElement = input.get(0); - TestData> data = TestData.Factory.ofCollection( - "1000 instances of Integer with the same value", input); - - withData(data) - .stream(Stream::distinct) - .resultAsserter((actual, expected, isOrdered, isParallel) -> { - List 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 deleted file mode 100644 index c476f18c6..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/DoublePrimitiveOpsTests.java +++ /dev/null @@ -1,106 +0,0 @@ -/* - * 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 deleted file mode 100644 index cbd9534aa..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ExplodeOpTest.java +++ /dev/null @@ -1,119 +0,0 @@ -/* - * 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> integerRangeMapper - = e -> IntStream.range(0, e).boxed(); - - public void testFlatMap() { - String[] stringsArray = {"hello", "there", "", "yada"}; - Stream 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", dataProviderClass = StreamTestDataProvider.class) - public void testOps(String name, TestData.OfRef data) { - Collection 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 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 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 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 deleted file mode 100644 index 12ff052a2..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/FilterOpTest.java +++ /dev/null @@ -1,109 +0,0 @@ -/* - * 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", dataProviderClass = StreamTestDataProvider.class) - public void testOps(String name, TestData.OfRef data) { - Collection 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 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 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 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 deleted file mode 100644 index 64a9240fe..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/FindAnyOpTest.java +++ /dev/null @@ -1,157 +0,0 @@ -/* - * 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", dataProviderClass = StreamTestDataProvider.class) - public void testStream(String name, TestData.OfRef 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 data, Function, Stream> fs) { - Optional or = withData(data).terminal(fs, s -> s.findAny()).equalator(VALID_ANSWER).exercise(); - if (or.isPresent()) { - Integer r = or.get(); - Iterator 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 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 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 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> VALID_ANSWER = (a, b) -> assertEquals(a.isPresent(), b.isPresent()); - - static final BiConsumer INT_VALID_ANSWER = (a, b) -> assertEquals(a.isPresent(), b.isPresent()); - - static final BiConsumer LONG_VALID_ANSWER = (a, b) -> assertEquals(a.isPresent(), b.isPresent()); - - static final BiConsumer 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 deleted file mode 100644 index 02e3d0727..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/FindFirstOpTest.java +++ /dev/null @@ -1,132 +0,0 @@ -/* - * 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", dataProviderClass = StreamTestDataProvider.class) - public void testStream(String name, TestData.OfRef 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 data, Function, Stream> fs) { - Optional r = exerciseTerminalOps(data, fs, s -> s.findFirst()); - if (r.isPresent()) { - Iterator 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 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 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 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 deleted file mode 100644 index e7337e608..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ForEachOpTest.java +++ /dev/null @@ -1,261 +0,0 @@ -/* - * 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 ResultAsserter> 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 input = countTo(10000); - TestData.OfRef data = TestData.Factory.ofCollection("[1, 10000]", input); - - Function, List> terminalFunc = s -> { - List 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", dataProviderClass = StreamTestDataProvider.class) - public void testForEach(String name, TestData.OfRef data) { - Function, List> terminalFunc = s -> { - List 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 input = countTo(10000); - TestData.OfInt data = TestData.Factory.ofIntSupplier("[1, 10000]", - () -> IntStream.range(1, 10001)); - - Function> terminalFunc = s -> { - List 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> terminalFunc = s -> { - List 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(i -> i), terminalFunc). - resultAsserter(resultAsserter()). - exercise(); - } - - // - - @Test(groups = { "serialization-hostile" }) - public void testLongForEachOrdered() { - List input = countTo(10000); - TestData.OfLong data = TestData.Factory.ofLongSupplier("[1, 10000]", - () -> LongStream.range(1, 10001)); - - Function> terminalFunc = s -> { - List 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> terminalFunc = s -> { - List 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(i -> i), terminalFunc). - resultAsserter(resultAsserter()). - exercise(); - } - - // - - @Test(groups = { "serialization-hostile" }) - public void testDoubleForEachOrdered() { - List input = countTo(10000); - TestData.OfDouble data = TestData.Factory.ofDoubleSupplier("[1, 10000]", - () -> IntStream.range(1, 10001).asDoubleStream()); - - Function> terminalFunc = s -> { - List 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> terminalFunc = s -> { - List 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(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 deleted file mode 100644 index dc9e1976f..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/GroupByOpTest.java +++ /dev/null @@ -1,173 +0,0 @@ -/* - * 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>, Map>> collector - = (Collector>, Map>>) Collectors.groupingBy(LambdaTestHelpers.forPredicate(pEven, true, false)); - - Map> 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 group : m.values()) { - int count = 0; - Stream stream = group.stream(); - Iterator it = stream.iterator(); - while (it.hasNext()) { - it.next(); - ++count; - } - assertEquals(5, count); - } - } - - public void testGroupBy() { - Map> result = countTo(10).stream().collect(Collectors.groupingBy(LambdaTestHelpers.forPredicate(pEven, true, false))); - - assertEquals(2, result.keySet().size()); - for(Collection group : result.values()) { - int count = 0; - Stream stream = group.stream(); - Iterator it = stream.iterator(); - while (it.hasNext()) { - it.next(); - ++count; - } - assertEquals(5, count); - } - } - - static class MapperData { - Function m; - int expectedSize; - - MapperData(Function m, int expectedSize) { - this.m = m; - this.expectedSize = expectedSize; - } - } - - List> getMapperData(TestData.OfRef 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", dataProviderClass = StreamTestDataProvider.class) - public void testOps(String name, TestData.OfRef 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 md : getMapperData(data)) { - Collector>> tab = Collectors.groupingBy(md.m); - Map> 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 void assertMultiMapEquals(Map> a, Map> b) { - assertTrue(multiMapEquals(a, b)); - } - - static boolean multiMapEquals(Map> a, Map> b) { - if (!Objects.equals(a.keySet(), b.keySet())) { - return false; - } - - for (K k : a.keySet()) { - Set as = new HashSet<>(a.get(k)); - Set 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 deleted file mode 100644 index 61f2e291a..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/InfiniteStreamWithLimitOpTest.java +++ /dev/null @@ -1,453 +0,0 @@ -/* - * 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 f = s -> String.format(s, SKIP_LIMIT_SIZE); - - List data = new ArrayList<>(); - - data.add(new Object[]{f.apply("Stream.limit(%d)"), - (UnaryOperator) s -> s.limit(SKIP_LIMIT_SIZE)}); - data.add(new Object[]{f.apply("Stream.skip(%1$d).limit(%1$d)"), - (UnaryOperator) 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 f = s -> String.format(s, SKIP_LIMIT_SIZE); - - List data = new ArrayList<>(); - - data.add(new Object[]{f.apply("IntStream.limit(%d)"), - (UnaryOperator) s -> s.limit(SKIP_LIMIT_SIZE)}); - data.add(new Object[]{f.apply("IntStream.skip(%1$d).limit(%1$d)"), - (UnaryOperator) 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 f = s -> String.format(s, SKIP_LIMIT_SIZE); - - List data = new ArrayList<>(); - - data.add(new Object[]{f.apply("LongStream.limit(%d)"), - (UnaryOperator) s -> s.limit(SKIP_LIMIT_SIZE)}); - data.add(new Object[]{f.apply("LongStream.skip(%1$d).limit(%1$d)"), - (UnaryOperator) 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 f = s -> String.format(s, SKIP_LIMIT_SIZE); - - List data = new ArrayList<>(); - - data.add(new Object[]{f.apply("DoubleStream.limit(%d)"), - (UnaryOperator) s -> s.limit(SKIP_LIMIT_SIZE)}); - data.add(new Object[]{f.apply("DoubleStream.skip(%1$d).limit(%1$d)"), - (UnaryOperator) s -> s.skip(SKIP_LIMIT_SIZE).limit(SKIP_LIMIT_SIZE)}); - - return data.toArray(new Object[0][]); - } - - private ResultAsserter> 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 refLongs() { - return refLongRange(0, Long.MAX_VALUE); - } - - private TestData.OfRef 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> 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 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 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 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> 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 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 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 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> 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 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 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 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> fs) { - // Source is spliterator of infinite size - TestData.OfRef 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 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 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 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> fs) { - // Source is a right-balanced tree of infinite size - TestData.OfRef 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 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 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 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 deleted file mode 100644 index 1efc5fde9..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntPrimitiveOpsTests.java +++ /dev/null @@ -1,183 +0,0 @@ -/* - * 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 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 deleted file mode 100644 index baf90075f..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntReduceTest.java +++ /dev/null @@ -1,81 +0,0 @@ -/* - * 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 deleted file mode 100644 index 51d1362da..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntSliceOpTest.java +++ /dev/null @@ -1,208 +0,0 @@ -/* - * 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 skips = sizes(data.size()); - - for (int s : skips) { - setContext("skip", s); - Collection 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 skips = sizes(data.size()); - List limits = skips; - - for (int s : skips) { - setContext("skip", s); - for (int limit : limits) { - setContext("limit", limit); - Collection 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 limits = sizes(data.size()); - - for (int limit : limits) { - setContext("limit", limit); - Collection sr = exerciseOps(data, st -> st.limit(limit)); - assertEquals(sr.size(), sliceSize(data.size(), 0, limit)); - - 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 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 deleted file mode 100644 index 3ec5d219a..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/IntUniqOpTest.java +++ /dev/null @@ -1,72 +0,0 @@ -/* - * 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 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 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 deleted file mode 100644 index fc8fa2a67..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/LongPrimitiveOpsTests.java +++ /dev/null @@ -1,183 +0,0 @@ -/* - * 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 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 deleted file mode 100644 index 4f7aaf6fa..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MapOpTest.java +++ /dev/null @@ -1,125 +0,0 @@ -/* - * 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 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", dataProviderClass = StreamTestDataProvider.class) - public void testOps(String name, TestData.OfRef 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 deleted file mode 100644 index dc825da55..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MatchOpTest.java +++ /dev/null @@ -1,422 +0,0 @@ -/* - * 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_PREDICATES - = (Predicate[]) new Predicate[]{pTrue, pFalse, pEven, pOdd}; - - @SuppressWarnings({"serial", "rawtypes"}) - private final Map kinds - = new HashMap, Function, 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 Map, Function, Boolean>>> kinds() { - return (Map, Function, Boolean>>>) kinds; - } - - private void assertPredicates(List source, Kind kind, Predicate[] predicates, boolean... answers) { - for (int i = 0; i < predicates.length; i++) { - setContext("i", i); - boolean match = this.kinds().get(kind).apply(predicates[i]).apply(source.stream()); - assertEquals(answers[i], match, kind.toString() + predicates[i].toString()); - } - } - - 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", dataProviderClass = StreamTestDataProvider.class) - public void testStream(String name, TestData.OfRef data) { - for (Predicate p : INTEGER_PREDICATES) { - setContext("p", p); - for (Kind kind : Kind.values()) { - setContext("kind", kind); - exerciseTerminalOps(data, this.kinds().get(kind).apply(p)); - exerciseTerminalOps(data, s -> s.filter(pFalse), this.kinds().get(kind).apply(p)); - exerciseTerminalOps(data, s -> s.filter(pEven), this.kinds().get(kind).apply(p)); - } - } - } - - public void testInfinite() { - class CycleIterator implements Iterator { - final Supplier> source; - Iterator i = null; - - CycleIterator(Supplier> 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> source = () -> Arrays.asList(1, 2, 3, 4).iterator(); - Supplier> 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>> intKinds - = new HashMap>>() {{ - 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 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 source; - PrimitiveIterator.OfInt i = null; - - CycleIterator(Supplier 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 source = () -> Arrays.stream(new int[]{1, 2, 3, 4}).iterator(); - Supplier 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>> longKinds - = new HashMap>>() {{ - 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 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 source; - PrimitiveIterator.OfLong i = null; - - CycleIterator(Supplier 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 source = () -> Arrays.stream(new long[]{1, 2, 3, 4}).iterator(); - Supplier 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>> doubleKinds - = new HashMap>>() {{ - 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 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 source; - PrimitiveIterator.OfDouble i = null; - - CycleIterator(Supplier 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 source = () -> Arrays.stream(new double[]{1, 2, 3, 4}).iterator(); - Supplier 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 deleted file mode 100644 index eed4a82bb..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/MinMaxTest.java +++ /dev/null @@ -1,92 +0,0 @@ -/* - * 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", dataProviderClass = StreamTestDataProvider.class) - public void testOps(String name, TestData.OfRef 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 deleted file mode 100644 index 82491e5a9..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/PrimitiveAverageOpTest.java +++ /dev/null @@ -1,50 +0,0 @@ -/* - * 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 deleted file mode 100644 index 6f2822f9d..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/PrimitiveSumTest.java +++ /dev/null @@ -1,65 +0,0 @@ -/* - * 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 deleted file mode 100644 index 20ae203bb..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/RangeTest.java +++ /dev/null @@ -1,339 +0,0 @@ -/* - * 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 deleted file mode 100644 index 3fcb46917..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ReduceByOpTest.java +++ /dev/null @@ -1,68 +0,0 @@ -/* - * 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", dataProviderClass = StreamTestDataProvider.class) - public void testOps(String name, TestData.OfRef data) { - Map> gbResult = data.stream().collect(groupingBy(LambdaTestHelpers.forPredicate(pEven, true, false))); - Map result = data.stream().collect(groupingBy(LambdaTestHelpers.forPredicate(pEven, true, false), reducing(0, rPlus))); - assertEquals(result.size(), gbResult.size()); - for (Map.Entry entry : result.entrySet()) { - setContext("entry", entry); - Boolean key = entry.getKey(); - assertEquals(entry.getValue(), data.stream().filter(e -> pEven.test(e) == key).reduce(0, rPlus)); - } - - int uniqueSize = data.into(new HashSet()).size(); - Map> mgResult = exerciseTerminalOps(data, s -> s.collect(groupingBy(mId))); - Map miResult = exerciseTerminalOps(data, s -> s.collect(groupingBy(mId, reducing(0, e -> 1, Integer::sum)))); - assertEquals(miResult.keySet().size(), uniqueSize); - for (Map.Entry entry : miResult.entrySet()) { - 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 deleted file mode 100644 index fd4c6874e..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ReduceTest.java +++ /dev/null @@ -1,87 +0,0 @@ -/* - * 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 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", dataProviderClass = StreamTestDataProvider.class) - public void testOps(String name, TestData.OfRef data) { - assertEquals(0, (int) exerciseTerminalOps(data, s -> s.filter(pFalse), s -> s.reduce(0, rPlus, rPlus))); - - Optional 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 deleted file mode 100644 index efa5c62e6..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SequentialOpTest.java +++ /dev/null @@ -1,135 +0,0 @@ -/* - * 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", dataProviderClass = StreamTestDataProvider.class, - groups = { "serialization-hostile" }) - public void testLazy(String name, TestData.OfRef data) { - Function id = LambdaTestHelpers.identity(); - AtomicInteger counter = new AtomicInteger(); - Supplier>[] suppliers = new Supplier[] { () -> data.stream(), () -> data.parallelStream() }; - UnaryOperator>[] configs - = new UnaryOperator[] { - (UnaryOperator>) s -> s.peek(e -> { counter.incrementAndGet(); }), - (UnaryOperator>) s -> s.map(id).peek(e -> { counter.incrementAndGet(); }).sequential().map(id), - (UnaryOperator>) s -> s.map(id).peek(e -> { counter.incrementAndGet(); }).parallel().map(id), - (UnaryOperator>) s -> s.sequential().map(id).peek(e -> { - counter.incrementAndGet(); - }).map(id), - (UnaryOperator>) s -> s.parallel().map(id).peek(e -> { counter.incrementAndGet(); }).map(id) - }; - - for (int i = 0; i < suppliers.length; i++) { - setContext("supplierIndex", i); - Supplier> supp = suppliers[i]; - for (int j = 0; j < configs.length; j++) { - setContext("configIndex", j); - UnaryOperator> config = configs[j]; - counter.set(0); - Stream stream = config.apply(supp.get()); - assertEquals(0, counter.get()); - - Iterator 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 spliterator = stream.spliterator(); - assertEquals(0, counter.get()); - - spliterator.forEachRemaining(e -> { - }); - assertTrue(data.size() == 0 || counter.get() > 0); - } - } - } - - @SuppressWarnings({"rawtypes", "unchecked"}) - @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class) - public void testMixedSeqPar(String name, TestData.OfRef data) { - Function id = LambdaTestHelpers.identity(); - UnaryOperator>[] changers - = new UnaryOperator[] { - (UnaryOperator>) s -> s, - (UnaryOperator>) s -> s.sequential(), - (UnaryOperator>) s -> s.parallel(), - (UnaryOperator>) s -> s.unordered() - }; - UnaryOperator>[] stuff - = new UnaryOperator[] { - (UnaryOperator>) s -> s, - (UnaryOperator>) s -> s.map(id), - (UnaryOperator>) s -> s.sorted(Comparator.naturalOrder()), - (UnaryOperator>) s -> s.map(id).sorted(Comparator.naturalOrder()).map(id), - (UnaryOperator>) s -> s.filter(LambdaTestHelpers.pEven).sorted(Comparator.naturalOrder()).map(id), - }; - - for (int c1Index = 0; c1Index < changers.length; c1Index++) { - setContext("c1Index", c1Index); - UnaryOperator> c1 = changers[c1Index]; - for (int s1Index = 0; s1Index < stuff.length; s1Index++) { - setContext("s1Index", s1Index); - UnaryOperator> s1 = stuff[s1Index]; - for (int c2Index = 0; c2Index < changers.length; c2Index++) { - setContext("c2Index", c2Index); - UnaryOperator> c2 = changers[c2Index]; - for (int s2Index = 0; s2Index < stuff.length; s2Index++) { - setContext("s2Index", s2Index); - UnaryOperator> s2 = stuff[s2Index]; - UnaryOperator> composed = s -> s2.apply(c2.apply(s1.apply(c1.apply(s)))); - exerciseOps(data, composed); - } - } - } - } - } -} diff --git a/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 deleted file mode 100644 index 44499d021..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java +++ /dev/null @@ -1,343 +0,0 @@ -/* - * 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", dataProviderClass = StreamTestDataProvider.class, - groups = { "serialization-hostile" }) - public void testSkipOps(String name, TestData.OfRef data) { - List 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", dataProviderClass = StreamTestDataProvider.class, - groups = { "serialization-hostile" }) - public void testSkipLimitOps(String name, TestData.OfRef data) { - List skips = sizes(data.size()); - List 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 implements Spliterator { - Spliterator s; - - NonSplittingNotSubsizedOrderedSpliterator(Spliterator s) { - assert s.hasCharacteristics(Spliterator.ORDERED); - this.s = s; - } - - @Override - public boolean tryAdvance(Consumer action) { - return s.tryAdvance(action); - } - - @Override - public void forEachRemaining(Consumer action) { - s.forEachRemaining(action); - } - - @Override - public Spliterator trySplit() { - return null; - } - - @Override - public long estimateSize() { - return s.estimateSize(); - } - - @Override - public int characteristics() { - return s.characteristics() & ~(Spliterator.SUBSIZED); - } - - @Override - public Comparator getComparator() { - return s.getComparator(); - } - } - List list = IntStream.range(0, 100).boxed().collect(Collectors.toList()); - TestData.OfRef data = TestData.Factory.ofSupplier( - "Non splitting, not SUBSIZED, ORDERED, stream", - () -> StreamSupport.stream(new NonSplittingNotSubsizedOrderedSpliterator<>(list.spliterator()), false)); - - testSkipLimitOps("testSkipLimitOpsWithNonSplittingSpliterator", data); - } - - @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class, - groups = { "serialization-hostile" }) - public void testLimitOps(String name, TestData.OfRef data) { - List 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> sliceResultAsserter(Iterable data, - int expectedSize) { - return (act, exp, ord, par) -> { - if (par & !ord) { - List expected = new ArrayList<>(); - data.forEach(expected::add); - - List actual = new ArrayList<>(); - act.forEach(actual::add); - - assertEquals(actual.size(), expectedSize); - assertTrue(expected.containsAll(actual)); - } - else { - LambdaTestHelpers.assertContents(act, exp); - } - }; - } - - private void testSliceMulti(TestData.OfRef data, - int expectedSize, - Function, Stream> mRef, - Function mInt, - Function mLong, - Function mDouble) { - - @SuppressWarnings({ "rawtypes", "unchecked" }) - Function, Stream>[] ms = new Function[4]; - ms[0] = mRef; - ms[1] = s -> mInt.apply(s.mapToInt(e -> e)).mapToObj(e -> e); - ms[2] = s -> mLong.apply(s.mapToLong(e -> e)).mapToObj(e -> (int) e); - ms[3] = s -> mDouble.apply(s.mapToDouble(e -> e)).mapToObj(e -> (int) e); - testSliceMulti(data, expectedSize, ms); - } - - @SafeVarargs - private final void testSliceMulti(TestData.OfRef data, - int expectedSize, - Function, Stream>... ms) { - for (int i = 0; i < ms.length; i++) { - setContext("mIndex", i); - Function, Stream> m = ms[i]; - Collection sr = withData(data) - .stream(m) - .resultAsserter(sliceResultAsserter(data, expectedSize)) - .exercise(); - assertEquals(sr.size(), expectedSize); - } - } - - public void testLimitSort() { - List 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 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 deleted file mode 100644 index 3ca690e90..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SortedOpTest.java +++ /dev/null @@ -1,361 +0,0 @@ -/* - * 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> f = s -> - // Clear the SORTED flag - s.mapToObj(i -> i) - .sorted(); - - testStreamTooLarge(f, Stream::findFirst); - } - - public void testIntStreamTooLarge() { - Function f = s -> - // Clear the SORTED flag - s.mapToInt(i -> (int) i) - .sorted(); - - testStreamTooLarge(f, IntStream::findFirst); - } - - public void testLongStreamTooLarge() { - Function f = s -> - // Clear the SORTED flag - s.map(i -> i) - .sorted(); - - testStreamTooLarge(f, LongStream::findFirst); - } - - public void testDoubleStreamTooLarge() { - Function f = s -> - // Clear the SORTED flag - s.mapToDouble(i -> (double) i) - .sorted(); - - testStreamTooLarge(f, DoubleStream::findFirst); - } - - > void testStreamTooLarge(Function s, - Function terminal) { - // Set up conditions for a large input > maximum array size - Supplier input = () -> LongStream.range(0, 1L + Integer.MAX_VALUE); - - // Transformation functions - List> 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 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 to10 = countTo(10); - assertSorted(to10.stream().sorted(cInteger.reversed()).iterator(), cInteger.reversed()); - - Collections.reverse(to10); - assertSorted(to10.stream().sorted().iterator()); - - Spliterator 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 l = Arrays.asList(5, 4, 3, 2, 1); - - Function> knownSize = i -> assertNCallsOnly( - l.stream().sorted(), Stream::peek, i); - Function> 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 Stream unknownSizeStream(List l) { - return StreamSupport.stream(Spliterators.spliteratorUnknownSize(l.iterator(), 0), false); - } - - @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class) - public void testOps(String name, TestData.OfRef data) { - Collection 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", dataProviderClass = StreamTestDataProvider.class) - public void testSortSort(String name, TestData.OfRef data) { - // For parallel cases ensure the size is known - Collection result = withData(data) - .stream(s -> s.sorted().sorted(), - new CollectorOps.TestParallelSizedOp()) - .exercise(); - - assertSorted(result); - assertContentsUnordered(data, result); - - result = withData(data) - .stream(s -> s.sorted(cInteger.reversed()).sorted(cInteger.reversed()), - new CollectorOps.TestParallelSizedOp()) - .exercise(); - - assertSorted(result, cInteger.reversed()); - assertContentsUnordered(data, result); - - result = withData(data) - .stream(s -> s.sorted().sorted(cInteger.reversed()), - new CollectorOps.TestParallelSizedOp()) - .exercise(); - - assertSorted(result, cInteger.reversed()); - assertContentsUnordered(data, result); - - result = withData(data) - .stream(s -> s.sorted(cInteger.reversed()).sorted(), - new CollectorOps.TestParallelSizedOp()) - .exercise(); - - assertSorted(result); - assertContentsUnordered(data, result); - } - - // - - @Test(groups = { "serialization-hostile" }) - public void testIntSequentialShortCircuitTerminal() { - int[] a = new int[]{5, 4, 3, 2, 1}; - - Function knownSize = i -> assertNCallsOnly( - Arrays.stream(a).sorted(), (s, c) -> s.peek(c::accept), i); - Function 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 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 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 knownSize = i -> assertNCallsOnly( - Arrays.stream(a).sorted(), (s, c) -> s.peek(c::accept), i); - Function 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 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 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 knownSize = i -> assertNCallsOnly( - Arrays.stream(a).sorted(), (s, c) -> s.peek(c::accept), i); - Function 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 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 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. - */ - , R> S assertNCallsOnly(S s, BiFunction, 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 deleted file mode 100644 index d69c585b7..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorTest.java +++ /dev/null @@ -1,64 +0,0 @@ -/* - * 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", dataProviderClass = StreamTestDataProvider.class ) - public void testSpliterator(String name, Supplier> supplier) { - SpliteratorTestHelper.testSpliterator(supplier); - } - - @Test(dataProvider = "IntSpliterator", dataProviderClass = IntStreamTestDataProvider.class ) - public void testIntSpliterator(String name, Supplier supplier) { - SpliteratorTestHelper.testIntSpliterator(supplier); - } - - @Test(dataProvider = "LongSpliterator", dataProviderClass = LongStreamTestDataProvider.class ) - public void testLongSpliterator(String name, Supplier supplier) { - SpliteratorTestHelper.testLongSpliterator(supplier); - } - - @Test(dataProvider = "DoubleSpliterator", dataProviderClass = DoubleStreamTestDataProvider.class ) - public void testDoubleSpliterator(String name, Supplier 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 deleted file mode 100644 index d8d46fd63..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamBuilderTest.java +++ /dev/null @@ -1,318 +0,0 @@ -/* - * 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 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 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 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 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 sb = Stream.builder(); - IntStream.range(0, s).boxed().forEach(sb); - return sb.build(); - }); - - testStreamBuilder(size, (s) -> { - Stream.Builder sb = Stream.builder(); - IntStream.range(0, s).boxed().forEach(i -> { - Stream.Builder _sb = sb.add(i); - assertTrue(sb == _sb); - }); - return sb.build(); - }); - } - - private void testStreamBuilder(int size, Function> supplier) { - TestData.OfRef 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 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 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 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 deleted file mode 100644 index 51ffd4b90..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamCloseTest.java +++ /dev/null @@ -1,166 +0,0 @@ -/* - * 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 ints = countTo(100).stream()) { - ints.forEach(i -> {}); - } - } - - public void testOneCloseHandler() { - final boolean[] holder = new boolean[1]; - Runnable closer = () -> { holder[0] = true; }; - - try (Stream ints = countTo(100).stream()) { - ints.onClose(closer); - ints.forEach(i -> {}); - } - assertTrue(holder[0]); - - Arrays.fill(holder, false); - try (Stream ints = countTo(100).stream().onClose(closer)) { - ints.forEach(i -> {}); - } - assertTrue(holder[0]); - - Arrays.fill(holder, false); - try (Stream ints = countTo(100).stream().filter(e -> true).onClose(closer)) { - ints.forEach(i -> {}); - } - assertTrue(holder[0]); - - Arrays.fill(holder, false); - try (Stream 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 ints = countTo(100).stream()) { - ints.onClose(close1).onClose(close2); - ints.forEach(i -> {}); - } - assertTrue(holder[0] && holder[1]); - - Arrays.fill(holder, false); - try (Stream ints = countTo(100).stream().onClose(close1).onClose(close2)) { - ints.forEach(i -> {}); - } - assertTrue(holder[0] && holder[1]); - - Arrays.fill(holder, false); - try (Stream 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 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 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 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 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 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 Function apply(int n, Function f) { - return s -> { - for (int i = 0; i < n; i++) { - s = f.apply(s); - } - return s; - }; - } - - private List sizes = Arrays.asList(0, 1, 2, 3, 4, 5, 255, 1000); - - @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class) - public void testManyStreams(String name, TestData.OfRef data) { - for (int n : sizes) { - setContext("n", n); - List expected = data.stream().map(e -> (Integer) (e + n)).collect(Collectors.toList()); - - withData(data). - stream(apply(n, (Stream 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 deleted file mode 100644 index 650edc1f1..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamParSeqTest.java +++ /dev/null @@ -1,52 +0,0 @@ -/* - * 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 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 deleted file mode 100644 index f3739784b..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/StreamSpliteratorTest.java +++ /dev/null @@ -1,616 +0,0 @@ -/* - * 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 implements Spliterator { - final Spliterator sp; - final boolean proxyEstimateSize; - int splits = 0; - int prefixSplits = 0; - - long sizeOnTraversal = -1; - - ProxyNoExactSizeSpliterator(Spliterator sp, boolean proxyEstimateSize) { - this.sp = sp; - this.proxyEstimateSize = proxyEstimateSize; - } - - @Override - public Spliterator trySplit() { - splits++; - Spliterator prefix = sp.trySplit(); - if (prefix != null) - prefixSplits++; - return prefix; - } - - @Override - public boolean tryAdvance(Consumer consumer) { - if (sizeOnTraversal == -1) - sizeOnTraversal = sp.getExactSizeIfKnown(); - return sp.tryAdvance(consumer); - } - - @Override - public void forEachRemaining(Consumer consumer) { - sizeOnTraversal = sp.getExactSizeIfKnown(); - sp.forEachRemaining(consumer); - } - - @Override - public long estimateSize() { - return proxyEstimateSize ? sp.estimateSize() : Long.MAX_VALUE; - } - - @Override - public Comparator 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 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 consumer) { - return Spliterator.OfInt.super.tryAdvance(consumer); - } - - @Override - public void forEachRemaining(Consumer 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 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 consumer) { - return Spliterator.OfLong.super.tryAdvance(consumer); - } - - @Override - public void forEachRemaining(Consumer 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 - 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 consumer) { - return Spliterator.OfDouble.super.tryAdvance(consumer); - } - - @Override - public void forEachRemaining(Consumer 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 l = countTo(1000); - - List>> terminalOps = Arrays.asList( - s -> s.toArray(), - s -> s.forEach(e -> { }), - s -> s.reduce(Integer::sum) - ); - - List>> 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> terminalOp = terminalOps.get(i); - for (int j = 0; j < intermediateOps.size(); j++) { - setContext("intOpIndex", j); - UnaryOperator> intermediateOp = intermediateOps.get(j); - for (boolean proxyEstimateSize : new boolean[] {false, true}) { - setContext("proxyEstimateSize", proxyEstimateSize); - Spliterator sp = intermediateOp.apply(l.stream()).spliterator(); - ProxyNoExactSizeSpliterator psp = new ProxyNoExactSizeSpliterator<>(sp, proxyEstimateSize); - Stream s = StreamSupport.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", - dataProviderClass = StreamTestDataProvider.class, - groups = { "serialization-hostile" }) - public void testStreamSpliterators(String name, TestData.OfRef data) { - for (Function, Stream> f : streamFunctions()) { - withData(data). - stream((Stream in) -> { - Stream out = f.apply(in); - return StreamSupport.stream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), false); - }). - exercise(); - - withData(data). - stream((Stream in) -> { - Stream out = f.apply(in); - return StreamSupport.stream(() -> out.spliterator(), OpTestCase.getStreamFlags(out), true); - }). - exercise(); - } - } - - @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class) - public void testSpliterators(String name, TestData.OfRef data) { - for (Function, Stream> f : streamFunctions()) { - SpliteratorTestHelper.testSpliterator(() -> f.apply(data.stream()).spliterator()); - } - } - - @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class) - public void testParSpliterators(String name, TestData.OfRef data) { - for (Function, Stream> f : streamFunctions()) { - SpliteratorTestHelper.testSpliterator(() -> f.apply(data.parallelStream()).spliterator()); - } - } - - private List, Stream>> streamFunctions; - - List, Stream>> streamFunctions() { - if (streamFunctions == null) { - List, Stream>> 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> terminalOps = Arrays.asList( - s -> s.toArray(), - s -> s.forEach(e -> {}), - s -> s.reduce(Integer::sum) - ); - - List> 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 terminalOp = terminalOps.get(i); - for (int j = 0; j < intermediateOps.size(); j++) { - setContext("intOpIndex", j); - UnaryOperator intermediateOp = intermediateOps.get(j); - for (boolean proxyEstimateSize : new boolean[] {false, true}) { - setContext("proxyEstimateSize", proxyEstimateSize); - // Size is assumed to be larger than the target size for no splitting - // @@@ Need way to obtain the target size - Spliterator.OfInt sp = intermediateOp.apply(IntStream.range(0, 1000)).spliterator(); - 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 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 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 f : intStreamFunctions()) { - SpliteratorTestHelper.testIntSpliterator(() -> f.apply(data.parallelStream()).spliterator()); - } - } - - private List> intStreamFunctions; - - List> intStreamFunctions() { - if (intStreamFunctions == null) { - List> opFunctions = Arrays.asList( - s -> s.filter(ipEven), - s -> s.map(irDoubler), - s -> s.sorted()); - - intStreamFunctions = permuteStreamFunctions(opFunctions); - } - - return intStreamFunctions; - } - - // - - public void testLongSplitting() { - List> terminalOps = Arrays.asList( - s -> s.toArray(), - s -> s.forEach(e -> {}), - s -> s.reduce(Long::sum) - ); - - List> 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 terminalOp = terminalOps.get(i); - setContext("termOpIndex", i); - for (int j = 0; j < intermediateOps.size(); j++) { - setContext("intOpIndex", j); - UnaryOperator intermediateOp = intermediateOps.get(j); - for (boolean proxyEstimateSize : new boolean[] {false, true}) { - setContext("proxyEstimateSize", proxyEstimateSize); - // Size is assumed to be larger than the target size for no splitting - // @@@ Need way to obtain the target size - Spliterator.OfLong sp = intermediateOp.apply(LongStream.range(0, 1000)).spliterator(); - 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 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 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 f : longStreamFunctions()) { - SpliteratorTestHelper.testLongSpliterator(() -> f.apply(data.parallelStream()).spliterator()); - } - } - - private List> longStreamFunctions; - - List> longStreamFunctions() { - if (longStreamFunctions == null) { - List> 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> terminalOps = Arrays.asList( - s -> s.toArray(), - s -> s.forEach(e -> {}), - s -> s.reduce(Double::sum) - ); - - List> 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 terminalOp = terminalOps.get(i); - setContext("termOpIndex", i); - for (int j = 0; j < intermediateOps.size(); j++) { - UnaryOperator intermediateOp = intermediateOps.get(j); - setContext("intOpIndex", j); - for (boolean proxyEstimateSize : new boolean[] {false, true}) { - setContext("proxyEstimateSize", proxyEstimateSize); - // Size is assumed to be larger than the target size for no splitting - // @@@ Need way to obtain the target size - Spliterator.OfDouble sp = intermediateOp.apply(IntStream.range(0, 1000).asDoubleStream()).spliterator(); - 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 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 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 f : doubleStreamFunctions()) { - SpliteratorTestHelper.testDoubleSpliterator(() -> f.apply(data.parallelStream()).spliterator()); - } - } - - private List> doubleStreamFunctions; - - List> doubleStreamFunctions() { - if (doubleStreamFunctions == null) { - List> 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 deleted file mode 100644 index 3850b8388..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/SummaryStatisticsTest.java +++ /dev/null @@ -1,88 +0,0 @@ -/* - * 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 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 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 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 deleted file mode 100644 index f539df5d8..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java +++ /dev/null @@ -1,621 +0,0 @@ -/* - * 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 { - abstract void assertValue(U value, - Supplier> source, - boolean ordered) throws ReflectiveOperationException; - } - - @SuppressWarnings({"rawtypes", "unchecked"}) - static class GroupedMapAssertion> extends TabulationAssertion { - private final Class clazz; - private final Function classifier; - private final TabulationAssertion downstream; - - protected GroupedMapAssertion(Function classifier, - Class clazz, - TabulationAssertion downstream) { - this.clazz = clazz; - this.classifier = classifier; - this.downstream = downstream; - } - - void assertValue(M map, - Supplier> 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 entry : map.entrySet()) { - K key = entry.getKey(); - downstream.assertValue(entry.getValue(), - () -> source.get().filter(e -> classifier.apply(e).equals(key)), - ordered); - } - } - } - - static class ToMapAssertion> extends TabulationAssertion { - private final Class clazz; - private final Function keyFn; - private final Function valueFn; - private final BinaryOperator mergeFn; - - ToMapAssertion(Function keyFn, - Function valueFn, - BinaryOperator mergeFn, - Class clazz) { - this.clazz = clazz; - this.keyFn = keyFn; - this.valueFn = valueFn; - this.mergeFn = mergeFn; - } - - @Override - void assertValue(M map, Supplier> source, boolean ordered) throws ReflectiveOperationException { - Set 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 extends TabulationAssertion> { - private final Predicate predicate; - private final TabulationAssertion downstream; - - protected PartitionAssertion(Predicate predicate, - TabulationAssertion downstream) { - this.predicate = predicate; - this.downstream = downstream; - } - - void assertValue(Map map, - Supplier> 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 extends TabulationAssertion> { - @Override - void assertValue(List value, Supplier> source, boolean ordered) - throws ReflectiveOperationException { - if (!List.class.isAssignableFrom(value.getClass())) - fail(String.format("Class mismatch in ListAssertion: %s", value.getClass())); - Stream stream = source.get(); - List result = new ArrayList<>(); - for (Iterator 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 extends TabulationAssertion> { - private final Class clazz; - private final boolean targetOrdered; - - protected CollectionAssertion(Class clazz, boolean targetOrdered) { - this.clazz = clazz; - this.targetOrdered = targetOrdered; - } - - @Override - void assertValue(Collection value, Supplier> source, boolean ordered) - throws ReflectiveOperationException { - if (!clazz.isAssignableFrom(value.getClass())) - fail(String.format("Class mismatch in CollectionAssertion: %s, %s", clazz, value.getClass())); - Stream stream = source.get(); - Collection result = clazz.newInstance(); - for (Iterator 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 extends TabulationAssertion { - private final U identity; - private final Function mapper; - private final BinaryOperator reducer; - - ReduceAssertion(U identity, Function mapper, BinaryOperator reducer) { - this.identity = identity; - this.mapper = mapper; - this.reducer = reducer; - } - - @Override - void assertValue(U value, Supplier> source, boolean ordered) - throws ReflectiveOperationException { - Optional 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 ResultAsserter mapTabulationAsserter(boolean ordered) { - return (act, exp, ord, par) -> { - if (par && (!ordered || !ord)) { - TabulatorsTest.nestedMapEqualityAssertion(act, exp); - } - else { - LambdaTestHelpers.assertContentsEqual(act, exp); - } - }; - } - - private - void exerciseMapTabulation(TestData> data, - Collector collector, - TabulationAssertion assertion) - throws ReflectiveOperationException { - boolean ordered = !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 void assertCollect(TestData.OfRef data, - Collector collector, - Function, R> streamReduction) { - R check = streamReduction.apply(data.stream()); - withData(data).terminal(s -> s.collect(collector)).expectedResult(check).exercise(); - } - - @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class) - public void testReduce(String name, TestData.OfRef 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 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", dataProviderClass = StreamTestDataProvider.class) - public void testJoin(String name, TestData.OfRef data) throws ReflectiveOperationException { - withData(data) - .terminal(s -> s.map(Object::toString).collect(Collectors.joining())) - .expectedResult(join(data, "")) - .exercise(); - - Collector 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 String join(TestData.OfRef 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", dataProviderClass = StreamTestDataProvider.class) - public void testSimpleToMap(String name, TestData.OfRef data) throws ReflectiveOperationException { - Function keyFn = i -> i * 2; - Function valueFn = i -> i * 4; - - List dataAsList = Arrays.asList(data.stream().toArray(Integer[]::new)); - Set dataAsSet = new HashSet<>(dataAsList); - - BinaryOperator sum = Integer::sum; - for (BinaryOperator 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", dataProviderClass = StreamTestDataProvider.class) - public void testSimpleGroupBy(String name, TestData.OfRef data) throws ReflectiveOperationException { - Function 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(HashSet.class, false))); - exerciseMapTabulation(data, - groupingByConcurrent(classifier, ConcurrentSkipListMap::new, - toCollection(HashSet::new)), - new GroupedMapAssertion<>(classifier, ConcurrentSkipListMap.class, - new CollectionAssertion(HashSet.class, false))); - } - - @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class) - public void testTwoLevelGroupBy(String name, TestData.OfRef data) throws ReflectiveOperationException { - Function classifier = i -> i % 6; - Function 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(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", dataProviderClass = StreamTestDataProvider.class) - public void testGroupedReduce(String name, TestData.OfRef data) throws ReflectiveOperationException { - Function 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", dataProviderClass = StreamTestDataProvider.class) - public void testSimplePartition(String name, TestData.OfRef data) throws ReflectiveOperationException { - Predicate 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", dataProviderClass = StreamTestDataProvider.class) - public void testTwoLevelPartition(String name, TestData.OfRef data) throws ReflectiveOperationException { - Predicate classifier = i -> i % 3 == 0; - Predicate 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", dataProviderClass = StreamTestDataProvider.class) - public void testComposeFinisher(String name, TestData.OfRef data) throws ReflectiveOperationException { - List asList = exerciseTerminalOps(data, s -> s.collect(toList())); - List 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 deleted file mode 100644 index 777158fd4..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/TeeOpTest.java +++ /dev/null @@ -1,139 +0,0 @@ -/* - * 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 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 { - List list; - - void before(TestData td) { - // Tee block can be called concurrently - list = Collections.synchronizedList(new ArrayList<>()); - } - - void after(TestData 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())); - } - } - - @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class) - public void testOps(String name, final TestData.OfRef data) { - class RecordingConsumer extends AbstractRecordingConsumer implements Consumer { - 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 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 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 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 deleted file mode 100644 index 5132d9d91..000000000 --- a/ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ToArrayOpTest.java +++ /dev/null @@ -1,417 +0,0 @@ -/* - * 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", dataProviderClass = StreamTestDataProvider.class) - public void testOps(String name, TestData.OfRef data) { - exerciseTerminalOps(data, s -> s.toArray()); - } - - @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class) - public void testOpsWithMap(String name, TestData.OfRef 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", dataProviderClass = StreamTestDataProvider.class) - public void testOpsWithSorted(String name, TestData.OfRef 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", dataProviderClass = StreamTestDataProvider.class) - public void testOpsWithFlatMap(String name, TestData.OfRef 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", dataProviderClass = StreamTestDataProvider.class) - public void testOpsWithFilter(String name, TestData.OfRef 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, Stream>> uniqueAndSortedPermutations = - LambdaTestHelpers.permuteStreamFunctions(Arrays.asList( - s -> s.distinct(), - s -> s.distinct(), - s -> s.sorted(), - s -> s.sorted() - )); - - @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class) - public void testDistinctAndSortedPermutations(String name, TestData.OfRef data) { - for (Function, Stream> 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, Stream>> statefulOpPermutations = - LambdaTestHelpers.permuteStreamFunctions(Arrays.asList( - s -> s.limit(10), - s -> s.distinct(), - s -> s.sorted() - )); - - private ResultAsserter statefulOpResultAsserter(TestData.OfRef data) { - return (act, exp, ord, par) -> { - if (par) { - if (!data.isOrdered()) { - // Relax the checking if the data source is unordered - // It is not exactly possible to determine if the limit - // operation is present and if it is before or after - // the sorted operation - // If the limit operation is present and before the sorted - // operation then the sub-set output after limit is a - // non-deterministic sub-set of the source - List expected = new ArrayList<>(); - data.forEach(expected::add); - - List actual = Arrays.asList(act); - - assertEquals(actual.size(), exp.length); - assertTrue(expected.containsAll(actual)); - return; - } - else if (!ord) { - LambdaTestHelpers.assertContentsUnordered(Arrays.asList(act), - Arrays.asList(exp)); - return; - } - } - assertEquals(act, exp); - }; - } - - @Test(dataProvider = "StreamTestData", dataProviderClass = StreamTestDataProvider.class, - groups = { "serialization-hostile" }) - public void testStatefulOpPermutations(String name, TestData.OfRef data) { - for (Function, Stream> 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> 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 f : intUniqueAndSortedPermutations) { - exerciseTerminalOps(data, f, s -> s.toArray()); - } - } - - private List> 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 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> 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 f : longUniqueAndSortedPermutations) { - exerciseTerminalOps(data, f, s -> s.toArray()); - } - } - - private List> 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 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> 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 f : doubleUniqueAndSortedPermutations) { - exerciseTerminalOps(data, f, s -> s.toArray()); - } - } - - private List> 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 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 deleted file mode 100644 index ea52d70ba..000000000 --- a/ojluni/src/test/test-output/emailable-report.html +++ /dev/null @@ -1,2 +0,0 @@ - -TestNG Report
Test# Passed# Skipped# FailedTime (ms)Included GroupsExcluded Groups
ClassMethodStartTime (ms)
\ 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 deleted file mode 100644 index 981b5599b..000000000 --- a/ojluni/src/test/test-output/old/index.html +++ /dev/null @@ -1,8 +0,0 @@ - -Test results - - -

Test results

- - -
SuitePassedFailedSkippedtestng.xml
Total000 
diff --git a/ojluni/src/test/test-output/testng-results.xml b/ojluni/src/test/test-output/testng-results.xml deleted file mode 100644 index 1c245d8ef..000000000 --- a/ojluni/src/test/test-output/testng-results.xml +++ /dev/null @@ -1,5 +0,0 @@ - - - - - diff --git a/ojluni/src/test/testng.xml b/ojluni/src/test/testng.xml deleted file mode 100644 index 851461a03..000000000 --- a/ojluni/src/test/testng.xml +++ /dev/null @@ -1,72 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -