209 TestData.OfLong longRangeClosedData(long start, long end) {
210 return TestData.Factory.ofLongSupplier("long rangeClosed", () -> LongStream.rangeClosed(start, end));
211 }
212
213 public void testLongRangeReduce() {
214 withData(longRangeData(0, 10000)).
215 terminal(s -> s.reduce(0, Long::sum)).exercise();
216 }
217
218 public void testLongInfiniteRangeLimit() {
219 withData(TestData.Factory.ofLongSupplier(
220 "long range", () -> LongStream.iterate(0, i -> i + 1).limit(10000))).
221 terminal(s -> s.reduce(0, Long::sum)).exercise();
222 }
223
224 public void testLongInfiniteRangeFindFirst() {
225 long first = LongStream.iterate(0, i -> i + 1).filter(i -> i > 10000).findFirst().getAsLong();
226 assertEquals(first, LongStream.iterate(0, i -> i + 1).parallel().filter(i -> i > 10000).findFirst().getAsLong());
227 }
228
229 // Enable when Stream.concat is present and range implementations are
230 // updated to use that
231 // private static void assertSizedAndSubSized(Spliterator<?> s) {
232 // assertTrue(s.hasCharacteristics(Spliterator.SIZED | Spliterator.SUBSIZED));
233 // }
234 //
235 // private static void assertNotSizedAndSubSized(Spliterator<?> s) {
236 // assertFalse(s.hasCharacteristics(Spliterator.SIZED | Spliterator.SUBSIZED));
237 // }
238 //
239 // public void testLongLongRange() {
240 // // Test [Long.MIN_VALUE, Long.MAX_VALUE)
241 // // This will concatenate streams of three ranges
242 // // [Long.MIN_VALUE, x) [x, 0) [0, Long.MAX_VALUE)
243 // // where x = Long.divideUnsigned(0 - Long.MIN_VALUE, 2) + 1
244 // {
245 // Spliterator.OfLong s = LongStream.range(Long.MIN_VALUE, Long.MAX_VALUE).spliterator();
246 //
247 // assertEquals(s.estimateSize(), Long.MAX_VALUE);
248 // assertNotSizedAndSubSized(s);
249 //
250 // Spliterator.OfLong s1 = s.trySplit();
251 // assertNotSizedAndSubSized(s1);
252 // assertSizedAndSubSized(s);
253 //
254 // Spliterator.OfLong s2 = s1.trySplit();
255 // assertSizedAndSubSized(s1);
256 // assertSizedAndSubSized(s2);
257 //
258 // assertTrue(s.estimateSize() == Long.MAX_VALUE);
259 // assertTrue(s1.estimateSize() < Long.MAX_VALUE);
260 // assertTrue(s2.estimateSize() < Long.MAX_VALUE);
261 //
262 // assertEquals(s.estimateSize() + s1.estimateSize() + s2.estimateSize(),
263 // Long.MAX_VALUE - Long.MIN_VALUE);
264 // }
265 //
266 // long[][] ranges = { {Long.MIN_VALUE, 0}, {-1, Long.MAX_VALUE} };
267 // for (int i = 0; i < ranges.length; i++) {
268 // long start = ranges[i][0];
269 // long end = ranges[i][1];
270 //
271 // Spliterator.OfLong s = LongStream.range(start, end).spliterator();
272 //
273 // assertEquals(s.estimateSize(), Long.MAX_VALUE);
274 // assertNotSizedAndSubSized(s);
275 //
276 // Spliterator.OfLong s1 = s.trySplit();
277 // assertSizedAndSubSized(s1);
278 // assertSizedAndSubSized(s);
279 //
280 // assertTrue(s.estimateSize() < Long.MAX_VALUE);
281 // assertTrue(s1.estimateSize() < Long.MAX_VALUE);
282 //
283 // assertEquals(s.estimateSize() + s1.estimateSize(), end - start);
284 // }
285 // }
286 //
287 // public void testLongLongRangeClosed() {
288 // // Test [Long.MIN_VALUE, Long.MAX_VALUE]
289 // // This will concatenate streams of four ranges
290 // // [Long.MIN_VALUE, x) [x, 0) [0, y) [y, Long.MAX_VALUE]
291 // // where x = Long.divideUnsigned(0 - Long.MIN_VALUE, 2) + 1
292 // // y = Long.divideUnsigned(Long.MAX_VALUE, 2) + 1
293 //
294 // {
295 // Spliterator.OfLong s = LongStream.rangeClosed(Long.MIN_VALUE, Long.MAX_VALUE).spliterator();
296 //
297 // assertEquals(s.estimateSize(), Long.MAX_VALUE);
298 // assertNotSizedAndSubSized(s);
299 //
300 // Spliterator.OfLong s1 = s.trySplit();
301 // assertNotSizedAndSubSized(s1);
302 // assertNotSizedAndSubSized(s);
303 //
304 // Spliterator.OfLong s2 = s1.trySplit();
305 // assertSizedAndSubSized(s1);
306 // assertSizedAndSubSized(s2);
307 //
308 // Spliterator.OfLong s3 = s.trySplit();
309 // assertSizedAndSubSized(s3);
310 // assertSizedAndSubSized(s);
311 //
312 // assertTrue(s.estimateSize() < Long.MAX_VALUE);
313 // assertTrue(s3.estimateSize() < Long.MAX_VALUE);
314 // assertTrue(s1.estimateSize() < Long.MAX_VALUE);
315 // assertTrue(s2.estimateSize() < Long.MAX_VALUE);
316 //
317 // assertEquals(s.estimateSize() + s3.estimateSize() + s1.estimateSize() + s2.estimateSize(),
318 // Long.MAX_VALUE - Long.MIN_VALUE + 1);
319 // }
320 //
321 // long[][] ranges = { {Long.MIN_VALUE, 0}, {-1, Long.MAX_VALUE} };
322 // for (int i = 0; i < ranges.length; i++) {
323 // long start = ranges[i][0];
324 // long end = ranges[i][1];
325 //
326 // Spliterator.OfLong s = LongStream.rangeClosed(start, end).spliterator();
327 //
328 // assertEquals(s.estimateSize(), Long.MAX_VALUE);
329 // assertNotSizedAndSubSized(s);
330 //
331 // Spliterator.OfLong s1 = s.trySplit();
332 // assertSizedAndSubSized(s1);
333 // assertSizedAndSubSized(s);
334 //
335 // assertTrue(s.estimateSize() < Long.MAX_VALUE);
336 // assertTrue(s1.estimateSize() < Long.MAX_VALUE);
337 //
338 // assertEquals(s.estimateSize() + s1.estimateSize(), end - start + 1);
339 // }
340 // }
341 }
|
209 TestData.OfLong longRangeClosedData(long start, long end) {
210 return TestData.Factory.ofLongSupplier("long rangeClosed", () -> LongStream.rangeClosed(start, end));
211 }
212
213 public void testLongRangeReduce() {
214 withData(longRangeData(0, 10000)).
215 terminal(s -> s.reduce(0, Long::sum)).exercise();
216 }
217
218 public void testLongInfiniteRangeLimit() {
219 withData(TestData.Factory.ofLongSupplier(
220 "long range", () -> LongStream.iterate(0, i -> i + 1).limit(10000))).
221 terminal(s -> s.reduce(0, Long::sum)).exercise();
222 }
223
224 public void testLongInfiniteRangeFindFirst() {
225 long first = LongStream.iterate(0, i -> i + 1).filter(i -> i > 10000).findFirst().getAsLong();
226 assertEquals(first, LongStream.iterate(0, i -> i + 1).parallel().filter(i -> i > 10000).findFirst().getAsLong());
227 }
228
229 private static void assertSizedAndSubSized(Spliterator<?> s) {
230 assertTrue(s.hasCharacteristics(Spliterator.SIZED | Spliterator.SUBSIZED));
231 }
232
233 private static void assertNotSizedAndSubSized(Spliterator<?> s) {
234 assertFalse(s.hasCharacteristics(Spliterator.SIZED | Spliterator.SUBSIZED));
235 }
236
237 public void testLongLongRange() {
238 // Test [Long.MIN_VALUE, Long.MAX_VALUE)
239 // This will concatenate streams of three ranges
240 // [Long.MIN_VALUE, x) [x, 0) [0, Long.MAX_VALUE)
241 // where x = Long.divideUnsigned(0 - Long.MIN_VALUE, 2) + 1
242 {
243 Spliterator.OfLong s = LongStream.range(Long.MIN_VALUE, Long.MAX_VALUE).spliterator();
244
245 assertEquals(s.estimateSize(), Long.MAX_VALUE);
246 assertNotSizedAndSubSized(s);
247
248 Spliterator.OfLong s1 = s.trySplit();
249 assertNotSizedAndSubSized(s1);
250 assertSizedAndSubSized(s);
251
252 Spliterator.OfLong s2 = s1.trySplit();
253 assertSizedAndSubSized(s1);
254 assertSizedAndSubSized(s2);
255
256 assertTrue(s.estimateSize() == Long.MAX_VALUE);
257 assertTrue(s1.estimateSize() < Long.MAX_VALUE);
258 assertTrue(s2.estimateSize() < Long.MAX_VALUE);
259
260 assertEquals(s.estimateSize() + s1.estimateSize() + s2.estimateSize(),
261 Long.MAX_VALUE - Long.MIN_VALUE);
262 }
263
264 long[][] ranges = { {Long.MIN_VALUE, 0}, {-1, Long.MAX_VALUE} };
265 for (int i = 0; i < ranges.length; i++) {
266 long start = ranges[i][0];
267 long end = ranges[i][1];
268
269 Spliterator.OfLong s = LongStream.range(start, end).spliterator();
270
271 assertEquals(s.estimateSize(), Long.MAX_VALUE);
272 assertNotSizedAndSubSized(s);
273
274 Spliterator.OfLong s1 = s.trySplit();
275 assertSizedAndSubSized(s1);
276 assertSizedAndSubSized(s);
277
278 assertTrue(s.estimateSize() < Long.MAX_VALUE);
279 assertTrue(s1.estimateSize() < Long.MAX_VALUE);
280
281 assertEquals(s.estimateSize() + s1.estimateSize(), end - start);
282 }
283 }
284
285 public void testLongLongRangeClosed() {
286 // Test [Long.MIN_VALUE, Long.MAX_VALUE]
287 // This will concatenate streams of four ranges
288 // [Long.MIN_VALUE, x) [x, 0) [0, y) [y, Long.MAX_VALUE]
289 // where x = Long.divideUnsigned(0 - Long.MIN_VALUE, 2) + 1
290 // y = Long.divideUnsigned(Long.MAX_VALUE, 2) + 1
291
292 {
293 Spliterator.OfLong s = LongStream.rangeClosed(Long.MIN_VALUE, Long.MAX_VALUE).spliterator();
294
295 assertEquals(s.estimateSize(), Long.MAX_VALUE);
296 assertNotSizedAndSubSized(s);
297
298 Spliterator.OfLong s1 = s.trySplit();
299 assertNotSizedAndSubSized(s1);
300 assertNotSizedAndSubSized(s);
301
302 Spliterator.OfLong s2 = s1.trySplit();
303 assertSizedAndSubSized(s1);
304 assertSizedAndSubSized(s2);
305
306 Spliterator.OfLong s3 = s.trySplit();
307 assertSizedAndSubSized(s3);
308 assertSizedAndSubSized(s);
309
310 assertTrue(s.estimateSize() < Long.MAX_VALUE);
311 assertTrue(s3.estimateSize() < Long.MAX_VALUE);
312 assertTrue(s1.estimateSize() < Long.MAX_VALUE);
313 assertTrue(s2.estimateSize() < Long.MAX_VALUE);
314
315 assertEquals(s.estimateSize() + s3.estimateSize() + s1.estimateSize() + s2.estimateSize(),
316 Long.MAX_VALUE - Long.MIN_VALUE + 1);
317 }
318
319 long[][] ranges = { {Long.MIN_VALUE, 0}, {-1, Long.MAX_VALUE} };
320 for (int i = 0; i < ranges.length; i++) {
321 long start = ranges[i][0];
322 long end = ranges[i][1];
323
324 Spliterator.OfLong s = LongStream.rangeClosed(start, end).spliterator();
325
326 assertEquals(s.estimateSize(), Long.MAX_VALUE);
327 assertNotSizedAndSubSized(s);
328
329 Spliterator.OfLong s1 = s.trySplit();
330 assertSizedAndSubSized(s1);
331 assertSizedAndSubSized(s);
332
333 assertTrue(s.estimateSize() < Long.MAX_VALUE);
334 assertTrue(s1.estimateSize() < Long.MAX_VALUE);
335
336 assertEquals(s.estimateSize() + s1.estimateSize(), end - start + 1);
337 }
338 }
339 }
|