RangeTest.java revision 289e51c2258b001f2aa6d6e67b21be7bb65d5102 
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 */
23package org.openjdk.tests.java.util.stream;
24
25import org.openjdk.testlib.java.util.stream.OpTestCase;
26import org.openjdk.testlib.java.util.stream.SpliteratorTestHelper;
27import org.openjdk.testlib.java.util.stream.TestData;
28
29import java.util.Arrays;
30import java.util.Optional;
31import java.util.Spliterator;
32import java.util.stream.IntStream;
33import java.util.stream.LongStream;
34import java.util.stream.Stream;
35
36import org.testng.annotations.Test;
37
38/**
39 * Primitive range tests
40 *
41 * @author Brian Goetz
42 */
43@Test
44public class RangeTest extends OpTestCase {
45
46    public void testInfiniteRangeFindFirst() {
47        Integer first = Stream.iterate(0, i -> i + 1).filter(i -> i > 10000).findFirst().get();
48        assertEquals(first, Stream.iterate(0, i -> i + 1).parallel().filter(i -> i > 10000).findFirst().get());
49
50        // Limit is required to transform the infinite stream to a finite stream
51        // since the exercising requires a finite stream
52        withData(TestData.Factory.ofSupplier(
53                "", () -> Stream.iterate(0, i -> i + 1).filter(i -> i > 10000).limit(20000))).
54                terminal(s->s.findFirst()).expectedResult(Optional.of(10001)).exercise();
55    }
56
57    //
58
59    public void testIntRange() {
60        // Half-open
61        for (int start : Arrays.asList(1, 10, -1, -10)) {
62            setContext("start", start);
63            for (int end : Arrays.asList(1, 10, -1, -10)) {
64                setContext("end", end);
65                int size = (start < end) ? end - start : 0;
66                int[] exp = new int[size];
67                for (int i = start, p = 0; i < end; i++, p++) {
68                    exp[p] = i;
69                }
70
71                int[] inc = IntStream.range(start, end).toArray();
72                assertEquals(inc.length, size);
73                assertTrue(Arrays.equals(exp, inc));
74
75                withData(intRangeData(start, end)).stream(s -> s).
76                        expectedResult(exp).exercise();
77            }
78        }
79
80        // Closed
81        for (int start : Arrays.asList(1, 10, -1, -10)) {
82            setContext("start", start);
83            for (int end : Arrays.asList(1, 10, -1, -10)) {
84                setContext("end", end);
85                int size = (start <= end) ? end - start + 1 : 0;
86                int[] exp = new int[size];
87                for (int i = start, p = 0; i <= end; i++, p++) {
88                    exp[p] = i;
89                }
90
91                int[] inc = IntStream.rangeClosed(start, end).toArray();
92                assertEquals(inc.length, size);
93                assertTrue(Arrays.equals(exp, inc));
94
95                withData(intRangeClosedData(start, end)).stream(s -> s).
96                        expectedResult(exp).exercise();
97            }
98        }
99
100        // Closed, maximum upper bound of Integer.MAX_VALUE
101        {
102            int[] inc = IntStream.rangeClosed(Integer.MAX_VALUE - 1, Integer.MAX_VALUE).toArray();
103            assertEquals(2, inc.length);
104            assertEquals(Integer.MAX_VALUE - 1, inc[0]);
105            assertEquals(Integer.MAX_VALUE, inc[1]);
106
107            inc = IntStream.rangeClosed(Integer.MAX_VALUE, Integer.MAX_VALUE).toArray();
108            assertEquals(1, inc.length);
109            assertEquals(Integer.MAX_VALUE, inc[0]);
110
111            SpliteratorTestHelper.testIntSpliterator(
112                    () -> IntStream.rangeClosed(Integer.MAX_VALUE - 8, Integer.MAX_VALUE).spliterator());
113        }
114
115        // Range wider than Integer.MAX_VALUE
116        {
117            Spliterator.OfInt s = IntStream.rangeClosed(Integer.MIN_VALUE, Integer.MAX_VALUE).
118                    spliterator();
119            assertEquals(s.estimateSize(), 1L << 32);
120        }
121    }
122
123    TestData.OfInt intRangeData(int start, int end) {
124        return TestData.Factory.ofIntSupplier("int range", () -> IntStream.range(start, end));
125    }
126
127    TestData.OfInt intRangeClosedData(int start, int end) {
128        return TestData.Factory.ofIntSupplier("int rangeClosed", () -> IntStream.rangeClosed(start, end));
129    }
130
131    public void tesIntRangeReduce() {
132        withData(intRangeData(0, 10000)).
133                terminal(s -> s.reduce(0, Integer::sum)).exercise();
134    }
135
136    public void testIntInfiniteRangeLimit() {
137        withData(TestData.Factory.ofIntSupplier(
138                "int range", () -> IntStream.iterate(0, i -> i + 1).limit(10000))).
139                terminal(s -> s.reduce(0, Integer::sum)).exercise();
140    }
141
142    public void testIntInfiniteRangeFindFirst() {
143        int first = IntStream.iterate(0, i -> i + 1).filter(i -> i > 10000).findFirst().getAsInt();
144        assertEquals(first, IntStream.iterate(0, i -> i + 1).parallel().filter(i -> i > 10000).findFirst().getAsInt());
145    }
146
147    //
148
149    public void testLongRange() {
150        // Half-open
151        for (long start : Arrays.asList(1, 1000, -1, -1000)) {
152            setContext("start", start);
153            for (long end : Arrays.asList(1, 1000, -1, -1000)) {
154                setContext("end", end);
155                long size = start < end ? end - start : 0;
156                long[] exp = new long[(int) size];
157                for (long i = start, p = 0; i < end; i++, p++) {
158                    exp[(int) p] = i;
159                }
160
161                long[] inc = LongStream.range(start, end).toArray();
162                assertEquals(inc.length, size);
163                assertTrue(Arrays.equals(exp, inc));
164
165                withData(longRangeData(start, end)).stream(s -> s).
166                        expectedResult(exp).exercise();
167            }
168        }
169
170        // Closed
171        for (long start : Arrays.asList(1, 1000, -1, -1000)) {
172            setContext("start", start);
173            for (long end : Arrays.asList(1, 1000, -1, -1000)) {
174                setContext("end", end);
175                long size = start <= end ? end - start + 1: 0;
176                long[] exp = new long[(int) size];
177                for (long i = start, p = 0; i <= end; i++, p++) {
178                    exp[(int) p] = i;
179                }
180
181                long[] inc = LongStream.rangeClosed(start, end).toArray();
182                assertEquals(inc.length, size);
183                assertTrue(Arrays.equals(exp, inc));
184
185                withData(longRangeClosedData(start, end)).stream(s -> s).
186                        expectedResult(exp).exercise();
187            }
188        }
189
190        // Closed, maximum upper bound of Long.MAX_VALUE
191        {
192            long[] inc = LongStream.rangeClosed(Long.MAX_VALUE - 1, Long.MAX_VALUE).toArray();
193            assertEquals(2, inc.length);
194            assertEquals(Long.MAX_VALUE - 1, inc[0]);
195            assertEquals(Long.MAX_VALUE, inc[1]);
196
197            inc = LongStream.rangeClosed(Long.MAX_VALUE, Long.MAX_VALUE).toArray();
198            assertEquals(1, inc.length);
199            assertEquals(Long.MAX_VALUE, inc[0]);
200
201            SpliteratorTestHelper.testLongSpliterator(
202                    () -> LongStream.rangeClosed(Long.MAX_VALUE - 8, Long.MAX_VALUE).spliterator());
203        }
204    }
205
206    TestData.OfLong longRangeData(long start, long end) {
207        return TestData.Factory.ofLongSupplier("long range", () -> LongStream.range(start, end));
208    }
209
210    TestData.OfLong longRangeClosedData(long start, long end) {
211        return TestData.Factory.ofLongSupplier("long rangeClosed", () -> LongStream.rangeClosed(start, end));
212    }
213
214    public void testLongRangeReduce() {
215        withData(longRangeData(0, 10000)).
216                terminal(s -> s.reduce(0, Long::sum)).exercise();
217    }
218
219    public void testLongInfiniteRangeLimit() {
220        withData(TestData.Factory.ofLongSupplier(
221                "long range", () -> LongStream.iterate(0, i -> i + 1).limit(10000))).
222                terminal(s -> s.reduce(0, Long::sum)).exercise();
223    }
224
225    public void testLongInfiniteRangeFindFirst() {
226        long first = LongStream.iterate(0, i -> i + 1).filter(i -> i > 10000).findFirst().getAsLong();
227        assertEquals(first, LongStream.iterate(0, i -> i + 1).parallel().filter(i -> i > 10000).findFirst().getAsLong());
228    }
229
230    private static void assertSizedAndSubSized(Spliterator<?> s) {
231        assertTrue(s.hasCharacteristics(Spliterator.SIZED | Spliterator.SUBSIZED));
232    }
233
234    private static void assertNotSizedAndSubSized(Spliterator<?> s) {
235        assertFalse(s.hasCharacteristics(Spliterator.SIZED | Spliterator.SUBSIZED));
236    }
237
238    public void testLongLongRange() {
239        // Test [Long.MIN_VALUE, Long.MAX_VALUE)
240        // This will concatenate streams of three ranges
241        //   [Long.MIN_VALUE, x) [x, 0) [0, Long.MAX_VALUE)
242        // where x = Long.divideUnsigned(0 - Long.MIN_VALUE, 2) + 1
243        {
244            Spliterator.OfLong s = LongStream.range(Long.MIN_VALUE, Long.MAX_VALUE).spliterator();
245
246            assertEquals(s.estimateSize(), Long.MAX_VALUE);
247            assertNotSizedAndSubSized(s);
248
249            Spliterator.OfLong s1 = s.trySplit();
250            assertNotSizedAndSubSized(s1);
251            assertSizedAndSubSized(s);
252
253            Spliterator.OfLong s2 = s1.trySplit();
254            assertSizedAndSubSized(s1);
255            assertSizedAndSubSized(s2);
256
257            assertTrue(s.estimateSize() == Long.MAX_VALUE);
258            assertTrue(s1.estimateSize() < Long.MAX_VALUE);
259            assertTrue(s2.estimateSize() < Long.MAX_VALUE);
260
261            assertEquals(s.estimateSize() + s1.estimateSize() + s2.estimateSize(),
262                         Long.MAX_VALUE - Long.MIN_VALUE);
263        }
264
265        long[][] ranges = { {Long.MIN_VALUE, 0}, {-1, Long.MAX_VALUE} };
266        for (int i = 0; i < ranges.length; i++) {
267            long start = ranges[i][0];
268            long end = ranges[i][1];
269
270            Spliterator.OfLong s = LongStream.range(start, end).spliterator();
271
272            assertEquals(s.estimateSize(), Long.MAX_VALUE);
273            assertNotSizedAndSubSized(s);
274
275            Spliterator.OfLong s1 = s.trySplit();
276            assertSizedAndSubSized(s1);
277            assertSizedAndSubSized(s);
278
279            assertTrue(s.estimateSize() < Long.MAX_VALUE);
280            assertTrue(s1.estimateSize() < Long.MAX_VALUE);
281
282            assertEquals(s.estimateSize() + s1.estimateSize(), end - start);
283        }
284    }
285
286    public void testLongLongRangeClosed() {
287        // Test [Long.MIN_VALUE, Long.MAX_VALUE]
288        // This will concatenate streams of four ranges
289        //   [Long.MIN_VALUE, x) [x, 0) [0, y) [y, Long.MAX_VALUE]
290        // where x = Long.divideUnsigned(0 - Long.MIN_VALUE, 2) + 1
291        //       y = Long.divideUnsigned(Long.MAX_VALUE, 2) + 1
292
293        {
294            Spliterator.OfLong s = LongStream.rangeClosed(Long.MIN_VALUE, Long.MAX_VALUE).spliterator();
295
296            assertEquals(s.estimateSize(), Long.MAX_VALUE);
297            assertNotSizedAndSubSized(s);
298
299            Spliterator.OfLong s1 = s.trySplit();
300            assertNotSizedAndSubSized(s1);
301            assertNotSizedAndSubSized(s);
302
303            Spliterator.OfLong s2 = s1.trySplit();
304            assertSizedAndSubSized(s1);
305            assertSizedAndSubSized(s2);
306
307            Spliterator.OfLong s3 = s.trySplit();
308            assertSizedAndSubSized(s3);
309            assertSizedAndSubSized(s);
310
311            assertTrue(s.estimateSize() < Long.MAX_VALUE);
312            assertTrue(s3.estimateSize() < Long.MAX_VALUE);
313            assertTrue(s1.estimateSize() < Long.MAX_VALUE);
314            assertTrue(s2.estimateSize() < Long.MAX_VALUE);
315
316            assertEquals(s.estimateSize() + s3.estimateSize() + s1.estimateSize() + s2.estimateSize(),
317                         Long.MAX_VALUE - Long.MIN_VALUE + 1);
318        }
319
320        long[][] ranges = { {Long.MIN_VALUE, 0}, {-1, Long.MAX_VALUE} };
321        for (int i = 0; i < ranges.length; i++) {
322            long start = ranges[i][0];
323            long end = ranges[i][1];
324
325            Spliterator.OfLong s = LongStream.rangeClosed(start, end).spliterator();
326
327            assertEquals(s.estimateSize(), Long.MAX_VALUE);
328            assertNotSizedAndSubSized(s);
329
330            Spliterator.OfLong s1 = s.trySplit();
331            assertSizedAndSubSized(s1);
332            assertSizedAndSubSized(s);
333
334            assertTrue(s.estimateSize() < Long.MAX_VALUE);
335            assertTrue(s1.estimateSize() < Long.MAX_VALUE);
336
337            assertEquals(s.estimateSize() + s1.estimateSize(), end - start + 1);
338        }
339    }
340}
341