1 /* 2 * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 package org.openjdk.tests.java.util.stream; 24 25 import org.testng.annotations.Test; 26 27 import java.util.*; 28 import java.util.Spliterators; 29 import java.util.stream.*; 30 31 import static java.util.stream.LambdaTestHelpers.*; 32 33 /** 34 * SortedOpTest 35 * 36 * @author Brian Goetz 37 */ 38 @Test 39 public class SortedOpTest extends OpTestCase { 40 public void testSorted() { 41 assertCountSum(countTo(0).stream().sorted(), 0, 0); 42 assertCountSum(countTo(10).stream().sorted(), 10, 55); 43 assertCountSum(countTo(10).stream().sorted(cInteger.reverseOrder()), 10, 55); 44 45 List<Integer> to10 = countTo(10); 46 assertSorted(to10.stream().sorted(cInteger.reverseOrder()).iterator(), cInteger.reverseOrder()); 47 48 Collections.reverse(to10); 49 assertSorted(to10.stream().sorted().iterator()); 50 51 Spliterator<Integer> s = to10.stream().sorted().spliterator(); 52 assertTrue(s.hasCharacteristics(Spliterator.SORTED)); 53 54 s = to10.stream().sorted(cInteger.reverseOrder()).spliterator(); 55 assertFalse(s.hasCharacteristics(Spliterator.SORTED)); 56 } 57 58 @Test(groups = { "serialization-hostile" }) 59 public void testSequentialShortCircuitTerminal() { 60 // The sorted op for sequential evaluation will buffer all elements when accepting 61 // then at the end sort those elements and push those elements downstream 62 63 List<Integer> l = Arrays.asList(5, 4, 3, 2, 1); 64 65 // Find 66 assertEquals(l.stream().sorted().findFirst(), Optional.of(1)); 67 assertEquals(l.stream().sorted().findAny(), Optional.of(1)); 68 assertEquals(unknownSizeStream(l).sorted().findFirst(), Optional.of(1)); 69 assertEquals(unknownSizeStream(l).sorted().findAny(), Optional.of(1)); 70 71 // Match 72 assertEquals(l.stream().sorted().anyMatch(i -> i == 2), true); 73 assertEquals(l.stream().sorted().noneMatch(i -> i == 2), false); 74 assertEquals(l.stream().sorted().allMatch(i -> i == 2), false); 75 assertEquals(unknownSizeStream(l).sorted().anyMatch(i -> i == 2), true); 76 assertEquals(unknownSizeStream(l).sorted().noneMatch(i -> i == 2), false); 77 assertEquals(unknownSizeStream(l).sorted().allMatch(i -> i == 2), false); 78 } 79 80 private <T> Stream<T> unknownSizeStream(List<T> l) { 81 return StreamSupport.stream(Spliterators.spliteratorUnknownSize(l.iterator(), 0)); 82 } 83 84 @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class) 85 public void testOps(String name, TestData.OfRef<Integer> data) { 86 Collection<Integer> result = exerciseOpsInt(data, Stream::sorted, IntStream::sorted, LongStream::sorted, DoubleStream::sorted); 87 assertSorted(result.iterator()); 88 assertContentsUnordered(data, result); 89 90 result = exerciseOps(data, s -> s.sorted(cInteger.reverseOrder())); 91 assertSorted(result.iterator(), cInteger.reverseOrder()); 92 assertContentsUnordered(data, result); 93 } 94 95 @Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class) 96 public void testSortSort(String name, TestData.OfRef<Integer> data) { 97 // For parallel cases ensure the size is known 98 Collection<Integer> result = withData(data) 99 .stream(s -> s.sorted().sorted(), 100 new CollectorOps.TestParallelSizedOp<Integer>()) 101 .exercise(); 102 103 assertSorted(result); 104 assertContentsUnordered(data, result); 105 106 result = withData(data) 107 .stream(s -> s.sorted(cInteger.reverseOrder()).sorted(cInteger.reverseOrder()), 108 new CollectorOps.TestParallelSizedOp<Integer>()) 109 .exercise(); 110 111 assertSorted(result, cInteger.reverseOrder()); 112 assertContentsUnordered(data, result); 113 114 result = withData(data) 115 .stream(s -> s.sorted().sorted(cInteger.reverseOrder()), 116 new CollectorOps.TestParallelSizedOp<Integer>()) 117 .exercise(); 118 119 assertSorted(result, cInteger.reverseOrder()); 120 assertContentsUnordered(data, result); 121 122 result = withData(data) 123 .stream(s -> s.sorted(cInteger.reverseOrder()).sorted(), 124 new CollectorOps.TestParallelSizedOp<Integer>()) 125 .exercise(); 126 127 assertSorted(result); 128 assertContentsUnordered(data, result); 129 } 130 131 // 132 133 @Test(groups = { "serialization-hostile" }) 134 public void testIntSequentialShortCircuitTerminal() { 135 int[] a = new int[]{5, 4, 3, 2, 1}; 136 137 // Find 138 assertEquals(Arrays.stream(a).sorted().findFirst(), OptionalInt.of(1)); 139 assertEquals(Arrays.stream(a).sorted().findAny(), OptionalInt.of(1)); 140 assertEquals(unknownSizeIntStream(a).sorted().findFirst(), OptionalInt.of(1)); 141 assertEquals(unknownSizeIntStream(a).sorted().findAny(), OptionalInt.of(1)); 142 143 // Match 144 assertEquals(Arrays.stream(a).sorted().anyMatch(i -> i == 2), true); 145 assertEquals(Arrays.stream(a).sorted().noneMatch(i -> i == 2), false); 146 assertEquals(Arrays.stream(a).sorted().allMatch(i -> i == 2), false); 147 assertEquals(unknownSizeIntStream(a).sorted().anyMatch(i -> i == 2), true); 148 assertEquals(unknownSizeIntStream(a).sorted().noneMatch(i -> i == 2), false); 149 assertEquals(unknownSizeIntStream(a).sorted().allMatch(i -> i == 2), false); 150 } 151 152 private IntStream unknownSizeIntStream(int[] a) { 153 return StreamSupport.intStream(Spliterators.spliteratorUnknownSize(Spliterators.iterator(Arrays.spliterator(a)), 0)); 154 } 155 156 @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class) 157 public void testIntOps(String name, TestData.OfInt data) { 158 Collection<Integer> result = exerciseOps(data, s -> s.sorted()); 159 assertSorted(result); 160 assertContentsUnordered(data, result); 161 } 162 163 @Test(dataProvider = "IntStreamTestData", dataProviderClass = IntStreamTestDataProvider.class) 164 public void testIntSortSort(String name, TestData.OfInt data) { 165 // For parallel cases ensure the size is known 166 Collection<Integer> result = withData(data) 167 .stream(s -> s.sorted().sorted(), new CollectorOps.TestParallelSizedOp.OfInt()) 168 .exercise(); 169 170 assertSorted(result); 171 assertContentsUnordered(data, result); 172 } 173 174 // 175 176 @Test(groups = { "serialization-hostile" }) 177 public void testLongSequentialShortCircuitTerminal() { 178 long[] a = new long[]{5, 4, 3, 2, 1}; 179 180 // Find 181 assertEquals(Arrays.stream(a).sorted().findFirst(), OptionalLong.of(1)); 182 assertEquals(Arrays.stream(a).sorted().findAny(), OptionalLong.of(1)); 183 assertEquals(unknownSizeLongStream(a).sorted().findFirst(), OptionalLong.of(1)); 184 assertEquals(unknownSizeLongStream(a).sorted().findAny(), OptionalLong.of(1)); 185 186 // Match 187 assertEquals(Arrays.stream(a).sorted().anyMatch(i -> i == 2), true); 188 assertEquals(Arrays.stream(a).sorted().noneMatch(i -> i == 2), false); 189 assertEquals(Arrays.stream(a).sorted().allMatch(i -> i == 2), false); 190 assertEquals(unknownSizeLongStream(a).sorted().anyMatch(i -> i == 2), true); 191 assertEquals(unknownSizeLongStream(a).sorted().noneMatch(i -> i == 2), false); 192 assertEquals(unknownSizeLongStream(a).sorted().allMatch(i -> i == 2), false); 193 } 194 195 private LongStream unknownSizeLongStream(long[] a) { 196 return StreamSupport.longStream(Spliterators.spliteratorUnknownSize(Spliterators.iterator(Arrays.spliterator(a)), 0)); 197 } 198 199 @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class) 200 public void testLongOps(String name, TestData.OfLong data) { 201 Collection<Long> result = exerciseOps(data, s -> s.sorted()); 202 assertSorted(result); 203 assertContentsUnordered(data, result); 204 } 205 206 @Test(dataProvider = "LongStreamTestData", dataProviderClass = LongStreamTestDataProvider.class) 207 public void testLongSortSort(String name, TestData.OfLong data) { 208 // For parallel cases ensure the size is known 209 Collection<Long> result = withData(data) 210 .stream(s -> s.sorted().sorted(), new CollectorOps.TestParallelSizedOp.OfLong()) 211 .exercise(); 212 213 assertSorted(result); 214 assertContentsUnordered(data, result); 215 } 216 217 // 218 219 @Test(groups = { "serialization-hostile" }) 220 public void testDoubleSequentialShortCircuitTerminal() { 221 double[] a = new double[]{5.0, 4.0, 3.0, 2.0, 1.0}; 222 223 // Find 224 assertEquals(Arrays.stream(a).sorted().findFirst(), OptionalDouble.of(1)); 225 assertEquals(Arrays.stream(a).sorted().findAny(), OptionalDouble.of(1)); 226 assertEquals(unknownSizeDoubleStream(a).sorted().findFirst(), OptionalDouble.of(1)); 227 assertEquals(unknownSizeDoubleStream(a).sorted().findAny(), OptionalDouble.of(1)); 228 229 // Match 230 assertEquals(Arrays.stream(a).sorted().anyMatch(i -> i == 2.0), true); 231 assertEquals(Arrays.stream(a).sorted().noneMatch(i -> i == 2.0), false); 232 assertEquals(Arrays.stream(a).sorted().allMatch(i -> i == 2.0), false); 233 assertEquals(unknownSizeDoubleStream(a).sorted().anyMatch(i -> i == 2.0), true); 234 assertEquals(unknownSizeDoubleStream(a).sorted().noneMatch(i -> i == 2.0), false); 235 assertEquals(unknownSizeDoubleStream(a).sorted().allMatch(i -> i == 2.0), false); 236 } 237 238 private DoubleStream unknownSizeDoubleStream(double[] a) { 239 return StreamSupport.doubleStream(Spliterators.spliteratorUnknownSize(Spliterators.iterator(Arrays.spliterator(a)), 0)); 240 } 241 242 @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class) 243 public void testDoubleOps(String name, TestData.OfDouble data) { 244 Collection<Double> result = exerciseOps(data, s -> s.sorted()); 245 assertSorted(result); 246 assertContentsUnordered(data, result); 247 } 248 249 @Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class) 250 public void testDoubleSortSort(String name, TestData.OfDouble data) { 251 // For parallel cases ensure the size is known 252 Collection<Double> result = withData(data) 253 .stream(s -> s.sorted().sorted(), new CollectorOps.TestParallelSizedOp.OfDouble()) 254 .exercise(); 255 256 assertSorted(result); 257 assertContentsUnordered(data, result); 258 } 259 }