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