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.reversed()), 10, 55);
44
45 List<Integer> to10 = countTo(10);
46 assertSorted(to10.stream().sorted(cInteger.reversed()).iterator(), cInteger.reversed());
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.reversed()).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.reversed()));
91 assertSorted(result.iterator(), cInteger.reversed());
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.reversed()).sorted(cInteger.reversed()),
108 new CollectorOps.TestParallelSizedOp<Integer>())
109 .exercise();
110
111 assertSorted(result, cInteger.reversed());
112 assertContentsUnordered(data, result);
113
114 result = withData(data)
115 .stream(s -> s.sorted().sorted(cInteger.reversed()),
116 new CollectorOps.TestParallelSizedOp<Integer>())
117 .exercise();
118
119 assertSorted(result, cInteger.reversed());
120 assertContentsUnordered(data, result);
121
122 result = withData(data)
123 .stream(s -> s.sorted(cInteger.reversed()).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 }