1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License
15 */
16
17package libcore.java.util;
18
19import junit.framework.TestCase;
20
21import java.util.ArrayList;
22import java.util.Arrays;
23import java.util.Collection;
24import java.util.Iterator;
25import java.util.List;
26import java.util.PrimitiveIterator;
27import java.util.Spliterator;
28import java.util.Spliterators;
29import java.util.function.Consumer;
30import java.util.function.DoubleConsumer;
31import java.util.function.IntConsumer;
32import java.util.function.LongConsumer;
33
34public class SpliteratorsTest extends TestCase {
35
36    public void testEmptyIntSpliterator() {
37        Spliterator.OfInt empty = Spliterators.emptyIntSpliterator();
38        assertNull(empty.trySplit());
39        assertEquals(0, empty.estimateSize());
40        assertEquals(0, empty.getExactSizeIfKnown());
41
42        IntConsumer alwaysFails = (int value) -> fail();
43        Consumer<Integer> alwaysFailsBoxed = (Integer value) -> fail();
44        empty.tryAdvance(alwaysFails);
45        empty.tryAdvance(alwaysFailsBoxed);
46
47        empty.forEachRemaining(alwaysFails);
48        empty.forEachRemaining(alwaysFailsBoxed);
49
50        assertEquals(Spliterator.SIZED | Spliterator.SUBSIZED, empty.characteristics());
51    }
52
53    public void testEmptyRefSpliterator() {
54        Spliterator<Object> empty = Spliterators.emptySpliterator();
55        assertNull(empty.trySplit());
56        assertEquals(0, empty.estimateSize());
57        assertEquals(0, empty.getExactSizeIfKnown());
58
59        Consumer<Object> alwaysFails = (Object value) -> fail();
60        empty.tryAdvance(alwaysFails);
61        empty.forEachRemaining(alwaysFails);
62
63        assertEquals(Spliterator.SIZED | Spliterator.SUBSIZED, empty.characteristics());
64    }
65
66    public void testEmptyLongSpliterator() {
67        Spliterator.OfLong empty = Spliterators.emptyLongSpliterator();
68        assertNull(empty.trySplit());
69        assertEquals(0, empty.estimateSize());
70        assertEquals(0, empty.getExactSizeIfKnown());
71
72        LongConsumer alwaysFails = (long value) -> fail();
73        Consumer<Long> alwaysFailsBoxed = (Long value) -> fail();
74        empty.tryAdvance(alwaysFails);
75        empty.tryAdvance(alwaysFailsBoxed);
76
77        empty.forEachRemaining(alwaysFails);
78        empty.forEachRemaining(alwaysFailsBoxed);
79
80        assertEquals(Spliterator.SIZED | Spliterator.SUBSIZED, empty.characteristics());
81    }
82
83    public void testEmptyDoubleSpliterator() {
84        Spliterator.OfDouble empty = Spliterators.emptyDoubleSpliterator();
85        assertNull(empty.trySplit());
86        assertEquals(0, empty.estimateSize());
87        assertEquals(0, empty.getExactSizeIfKnown());
88
89        DoubleConsumer alwaysFails = (double value) -> fail();
90        Consumer<Double> alwaysFailsBoxed = (Double value) -> fail();
91        empty.tryAdvance(alwaysFails);
92        empty.tryAdvance(alwaysFailsBoxed);
93
94        empty.forEachRemaining(alwaysFails);
95        empty.forEachRemaining(alwaysFailsBoxed);
96
97        assertEquals(Spliterator.SIZED | Spliterator.SUBSIZED, empty.characteristics());
98    }
99
100    public void testSpliteratorObjectArray() {
101        String[] array = { "a", "b", "c", "d", "e", "f", "g", "h" };
102        ArrayList<String> expectedValues = new ArrayList<>(Arrays.asList(array));
103
104        Spliterator<String> sp = Spliterators.spliterator(array, 0);
105        assertEquals(8, sp.estimateSize());
106        assertEquals(8, sp.getExactSizeIfKnown());
107
108        sp = Spliterators.spliterator(array, 0);
109        SpliteratorTester.runBasicIterationTests(sp, expectedValues);
110
111        sp = Spliterators.spliterator(array, 0);
112        SpliteratorTester.testSpliteratorNPE(sp);
113
114        sp = Spliterators.spliterator(array, 0);
115        SpliteratorTester.runBasicSplitTests(sp, expectedValues, String::compareTo);
116
117        sp = Spliterators.spliterator(array, 0);
118        SpliteratorTester.runSizedTests(sp, 8);
119
120        sp = Spliterators.spliterator(array, 0);
121        SpliteratorTester.runSubSizedTests(sp, 8);
122
123        // Assert the spliterator inherits any characteristics we ask it to.
124        sp = Spliterators.spliterator(array, Spliterator.ORDERED);
125        assertTrue(sp.hasCharacteristics(Spliterator.ORDERED));
126    }
127
128    public void testSpliteratorObjectArrayRange() {
129        String[] array = { "FOO", "BAR", "a", "b", "c", "d", "e", "f", "g", "h", "BAZ", "BAH" };
130        ArrayList<String> expectedValues = new ArrayList<>(
131                Arrays.asList(Arrays.copyOfRange(array, 2, 10)));
132
133        Spliterator<String> sp = Spliterators.spliterator(array, 2, 10, 0);
134        assertEquals(8, sp.estimateSize());
135        assertEquals(8, sp.getExactSizeIfKnown());
136
137        sp = Spliterators.spliterator(array, 2, 10, 0);
138        SpliteratorTester.runBasicIterationTests(sp, expectedValues);
139
140        sp = Spliterators.spliterator(array, 2, 10, 0);
141        SpliteratorTester.testSpliteratorNPE(sp);
142
143        sp = Spliterators.spliterator(array, 2, 10, 0);
144        SpliteratorTester.runBasicSplitTests(sp, expectedValues, String::compareTo);
145
146        sp = Spliterators.spliterator(array, 2, 10, 0);
147        SpliteratorTester.runSizedTests(sp, 8);
148
149        sp = Spliterators.spliterator(array, 2, 10, 0);
150        SpliteratorTester.runSubSizedTests(sp, 8);
151
152        // Assert the spliterator inherits any characteristics we ask it to.
153        sp = Spliterators.spliterator(array, 2, 10, Spliterator.ORDERED);
154        assertTrue(sp.hasCharacteristics(Spliterator.ORDERED));
155    }
156
157    private static class PrimitiveIntArrayList {
158        final int[] array;
159        int idx;
160
161        PrimitiveIntArrayList(int size) {
162            array = new int[size];
163        }
164
165        public void add(int element) {
166            array[idx++] = element;
167        }
168
169        public int[] toSortedArray() {
170            Arrays.sort(array);
171            return array;
172        }
173    }
174
175    private static class PrimitiveLongArrayList {
176        final long[] array;
177        int idx;
178
179        PrimitiveLongArrayList(int size) {
180            array = new long[size];
181        }
182
183        public void add(long element) {
184            array[idx++] = element;
185        }
186
187        public long[] toSortedArray() {
188            Arrays.sort(array);
189            return array;
190        }
191    }
192
193    private static class PrimitiveDoubleArrayList {
194        final double[] array;
195        int idx;
196
197        PrimitiveDoubleArrayList(int size) {
198            array = new double[size];
199        }
200
201        public void add(double element) {
202            array[idx++] = element;
203        }
204
205        public double[] toSortedArray() {
206            Arrays.sort(array);
207            return array;
208        }
209    }
210
211    public void test_spliterator_int() {
212        int[] elements = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
213
214        Spliterator.OfInt intSp = Spliterators.spliterator(elements, 0);
215
216        assertEquals(16, intSp.estimateSize());
217        assertEquals(16, intSp.getExactSizeIfKnown());
218
219        assertTrue(intSp.tryAdvance((Integer value) -> assertEquals(1, (int) value)));
220        assertTrue(intSp.tryAdvance((int value) -> assertEquals(2, (int) value)));
221
222        PrimitiveIntArrayList recorder = new PrimitiveIntArrayList(16);
223        // Record elements observed by previous tests.
224        recorder.add(1);
225        recorder.add(2);
226
227        Spliterator.OfInt split1 = intSp.trySplit();
228        assertNotNull(split1);
229        assertTrue(split1.tryAdvance((int value) -> recorder.add(value)));
230        assertTrue(split1.tryAdvance((Integer value) -> recorder.add(value)));
231
232        // Assert that splits can themselves resplit.
233        Spliterator.OfInt split2 = split1.trySplit();
234        assertNotNull(split2);
235        split2.forEachRemaining((int value) -> recorder.add(value));
236        assertFalse(split2.tryAdvance((int value) -> fail()));
237        assertFalse(split2.tryAdvance((Integer value) -> fail()));
238
239        // Iterate over the remaning elements so we can make sure we've looked at
240        // everything.
241        split1.forEachRemaining((int value) -> recorder.add(value));
242        intSp.forEachRemaining((int value) -> recorder.add(value));
243
244        int[] recorded = recorder.toSortedArray();
245        assertEquals(Arrays.toString(elements), Arrays.toString(recorded));
246    }
247
248    public void test_spliterator_intOffsetBasic() {
249        int[] elements = { 123123, 131321312, 1, 2, 3, 4, 32323232, 45454};
250        Spliterator.OfInt sp = Spliterators.spliterator(elements, 2, 6, 0);
251
252        PrimitiveIntArrayList recorder = new PrimitiveIntArrayList(4);
253        sp.tryAdvance((Integer value) -> recorder.add((int) value));
254        sp.tryAdvance((int value) -> recorder.add(value));
255        sp.forEachRemaining((int value) -> recorder.add(value));
256
257        int[] recorded = recorder.toSortedArray();
258        assertEquals(Arrays.toString(new int[] { 1, 2, 3, 4 }), Arrays.toString(recorded));
259    }
260
261    public void test_spliterator_longOffsetBasic() {
262        long[] elements = { 123123, 131321312, 1, 2, 3, 4, 32323232, 45454};
263        Spliterator.OfLong sp = Spliterators.spliterator(elements, 2, 6, 0);
264
265        PrimitiveLongArrayList recorder = new PrimitiveLongArrayList(4);
266        sp.tryAdvance((Long value) -> recorder.add((long) value));
267        sp.tryAdvance((long value) -> recorder.add(value));
268        sp.forEachRemaining((long value) -> recorder.add(value));
269
270        long[] recorded = recorder.toSortedArray();
271        assertEquals(Arrays.toString(new long[] { 1, 2, 3, 4 }), Arrays.toString(recorded));
272    }
273
274    public void test_spliterator_doubleOffsetBasic() {
275        double[] elements = { 123123, 131321312, 1, 2, 3, 4, 32323232, 45454};
276        Spliterator.OfDouble sp = Spliterators.spliterator(elements, 2, 6, 0);
277
278        PrimitiveDoubleArrayList recorder = new PrimitiveDoubleArrayList(4);
279        sp.tryAdvance((Double value) -> recorder.add((double) value));
280        sp.tryAdvance((double value) -> recorder.add(value));
281        sp.forEachRemaining((double value) -> recorder.add(value));
282
283        double[] recorded = recorder.toSortedArray();
284        assertEquals(Arrays.toString(new double[] { 1, 2, 3, 4 }), Arrays.toString(recorded));
285    }
286
287    public void test_spliterator_long() {
288        long[] elements = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
289
290        Spliterator.OfLong longSp = Spliterators.spliterator(elements, 0);
291
292        assertEquals(16, longSp.estimateSize());
293        assertEquals(16, longSp.getExactSizeIfKnown());
294
295        assertTrue(longSp.tryAdvance((Long value) -> assertEquals(1, (long) value)));
296        assertTrue(longSp.tryAdvance((long value) -> assertEquals(2, (long) value)));
297
298        PrimitiveLongArrayList recorder = new PrimitiveLongArrayList(16);
299        // Record elements observed by previous tests.
300        recorder.add(1);
301        recorder.add(2);
302
303        Spliterator.OfLong split1 = longSp.trySplit();
304        assertNotNull(split1);
305        assertTrue(split1.tryAdvance((long value) -> recorder.add(value)));
306        assertTrue(split1.tryAdvance((Long value) -> recorder.add(value)));
307
308        // Assert that splits can themselves resplit.
309        Spliterator.OfLong split2 = split1.trySplit();
310        assertNotNull(split2);
311        split2.forEachRemaining((long value) -> recorder.add(value));
312        assertFalse(split2.tryAdvance((long value) -> fail()));
313        assertFalse(split2.tryAdvance((Long value) -> fail()));
314
315        // Iterate over the remaning elements so we can make sure we've looked at
316        // everything.
317        split1.forEachRemaining((long value) -> recorder.add(value));
318        longSp.forEachRemaining((long value) -> recorder.add(value));
319
320        long[] recorded = recorder.toSortedArray();
321        assertEquals(Arrays.toString(elements), Arrays.toString(recorded));
322    }
323
324    public void test_spliterator_double() {
325        double[] elements = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
326
327        Spliterator.OfDouble doubleSp = Spliterators.spliterator(elements, 0);
328
329        assertEquals(16, doubleSp.estimateSize());
330        assertEquals(16, doubleSp.getExactSizeIfKnown());
331
332        assertTrue(doubleSp.tryAdvance((Double value) -> assertEquals(1.0, (double) value)));
333        assertTrue(doubleSp.tryAdvance((double value) -> assertEquals(2.0, (double) value)));
334
335        PrimitiveDoubleArrayList recorder = new PrimitiveDoubleArrayList(16);
336        // Record elements observed by previous tests.
337        recorder.add(1);
338        recorder.add(2);
339
340        Spliterator.OfDouble split1 = doubleSp.trySplit();
341        assertNotNull(split1);
342        assertTrue(split1.tryAdvance((double value) -> recorder.add(value)));
343        assertTrue(split1.tryAdvance((Double value) -> recorder.add(value)));
344
345        // Assert that splits can themselves resplit.
346        Spliterator.OfDouble split2 = split1.trySplit();
347        assertNotNull(split2);
348        split2.forEachRemaining((double value) -> recorder.add(value));
349        assertFalse(split2.tryAdvance((double value) -> fail()));
350        assertFalse(split2.tryAdvance((Double value) -> fail()));
351
352        // Iterate over the remaining elements so we can make sure we've looked at
353        // everything.
354        split1.forEachRemaining((double value) -> recorder.add(value));
355        doubleSp.forEachRemaining((double value) -> recorder.add(value));
356
357        double[] recorded = recorder.toSortedArray();
358        assertEquals(Arrays.toString(elements), Arrays.toString(recorded));
359    }
360
361    public void test_primitive_spliterators_NPE() {
362        final int[] elements = { 1, 2, 3, 4, 5, 6};
363        Spliterator.OfInt intSp = Spliterators.spliterator(elements, 0);
364        try {
365            intSp.forEachRemaining((Consumer<Integer>) null);
366            fail();
367        } catch (NullPointerException expected) {
368        }
369
370        try {
371            assertTrue(intSp.tryAdvance((Consumer<Integer>) null));
372            fail();
373        } catch (NullPointerException expected) {
374        }
375
376        try {
377            intSp.forEachRemaining((IntConsumer) null);
378            fail();
379        } catch (NullPointerException expected) {
380        }
381
382        try {
383            intSp.tryAdvance((IntConsumer) null);
384            fail();
385        } catch (NullPointerException expected) {
386        }
387
388        final long[] longElements = { 1, 2, 3, 4, 5, 6};
389        Spliterator.OfLong longSp = Spliterators.spliterator(longElements, 0);
390        try {
391            longSp.forEachRemaining((Consumer<Long>) null);
392            fail();
393        } catch (NullPointerException expected) {
394        }
395
396        try {
397            longSp.tryAdvance((Consumer<Long>) null);
398            fail();
399        } catch (NullPointerException expected) {
400        }
401
402        try {
403            longSp.forEachRemaining((LongConsumer) null);
404            fail();
405        } catch (NullPointerException expected) {
406        }
407
408        try {
409            longSp.tryAdvance((LongConsumer) null);
410            fail();
411        } catch (NullPointerException expected) {
412        }
413
414        final double[] doubleElements = { 1, 2, 3, 4, 5, 6};
415        Spliterator.OfDouble doubleSp = Spliterators.spliterator(doubleElements, 0);
416        try {
417            doubleSp.forEachRemaining((Consumer<Double>) null);
418            fail();
419        } catch (NullPointerException expected) {
420        }
421
422        try {
423            doubleSp.tryAdvance((Consumer<Double>) null);
424            fail();
425        } catch (NullPointerException expected) {
426        }
427
428        try {
429            doubleSp.forEachRemaining((DoubleConsumer) null);
430            fail();
431        } catch (NullPointerException expected) {
432        }
433
434        try {
435            doubleSp.tryAdvance((DoubleConsumer) null);
436            fail();
437        } catch (NullPointerException expected) {
438        }
439    }
440
441    public void testSpliterator_Collection() {
442        String[] array = { "a", "b", "c", "d", "e", "f", "g", "h" };
443        ArrayList<String> expectedValues = new ArrayList<>(Arrays.asList(array));
444
445        Collection<String> collection = Arrays.asList(array);
446
447        Spliterator<String> sp = Spliterators.spliterator(collection, 0);
448        assertEquals(8, sp.estimateSize());
449        assertEquals(8, sp.getExactSizeIfKnown());
450
451        sp = Spliterators.spliterator(collection, 0);
452        SpliteratorTester.runBasicIterationTests(sp, expectedValues);
453
454        sp = Spliterators.spliterator(collection, 0);
455        SpliteratorTester.testSpliteratorNPE(sp);
456
457        sp = Spliterators.spliterator(collection, 0);
458        SpliteratorTester.runBasicSplitTests(sp, expectedValues, String::compareTo);
459
460        sp = Spliterators.spliterator(collection, 0);
461        SpliteratorTester.runSizedTests(sp, 8);
462
463        sp = Spliterators.spliterator(collection, 0);
464        SpliteratorTester.runSubSizedTests(sp, 8);
465
466        // Assert the spliterator inherits any characteristics we ask it to.
467        sp = Spliterators.spliterator(collection, Spliterator.ORDERED);
468        assertTrue(sp.hasCharacteristics(Spliterator.ORDERED));
469    }
470
471    public void testSpliterator_sizedIterator() {
472        String[] array = { "a", "b", "c", "d", "e", "f", "g", "h" };
473        List<String> asList = Arrays.asList(array);
474        ArrayList<String> expectedValues = new ArrayList<>(asList);
475
476        Spliterator<String> sp = Spliterators.spliterator(asList.iterator(), 8 /* size */, 0);
477        assertEquals(8, sp.estimateSize());
478        assertEquals(8, sp.getExactSizeIfKnown());
479
480        sp = Spliterators.spliterator(asList.iterator(), 8 /* size */, 0);
481        SpliteratorTester.runBasicIterationTests(sp, expectedValues);
482
483        sp = Spliterators.spliterator(asList.iterator(), 8 /* size */, 0);
484        SpliteratorTester.testSpliteratorNPE(sp);
485
486        sp = Spliterators.spliterator(asList.iterator(), 8 /* size */, 0);
487        SpliteratorTester.runBasicSplitTests(sp, expectedValues, String::compareTo);
488
489        sp = Spliterators.spliterator(asList.iterator(), 8 /* size */, 0);
490        SpliteratorTester.runSizedTests(sp, 8);
491
492        sp = Spliterators.spliterator(asList.iterator(), 8 /* size */, 0);
493        SpliteratorTester.runSubSizedTests(sp, 8);
494
495        // Assert the spliterator inherits any characteristics we ask it to.
496        sp = Spliterators.spliterator(array, Spliterator.ORDERED);
497        assertTrue(sp.hasCharacteristics(Spliterator.ORDERED));
498    }
499
500    public void testSpliterator_unsizedIterator() {
501        String[] array = { "a", "b", "c", "d", "e", "f", "g", "h" };
502        List<String> asList = Arrays.asList(array);
503        ArrayList<String> expectedValues = new ArrayList<>(asList);
504
505        Spliterator<String> sp = Spliterators.spliteratorUnknownSize(asList.iterator(), 0);
506        SpliteratorTester.runBasicIterationTests(sp, expectedValues);
507
508        sp = Spliterators.spliteratorUnknownSize(asList.iterator(), 0);
509        SpliteratorTester.testSpliteratorNPE(sp);
510
511        sp = Spliterators.spliteratorUnknownSize(asList.iterator(), 0);
512        SpliteratorTester.runBasicSplitTests(sp, expectedValues, String::compareTo);
513
514        // Assert the spliterator inherits any characteristics we ask it to.
515        sp = Spliterators.spliterator(array, Spliterator.ORDERED);
516        assertTrue(sp.hasCharacteristics(Spliterator.ORDERED));
517    }
518
519    private static class CannedIntPrimitiveIterator implements PrimitiveIterator.OfInt {
520        private final int[] data;
521        private int idx;
522
523        public CannedIntPrimitiveIterator(int[] data) {
524            this.data = data;
525            this.idx = 0;
526        }
527
528        @Override
529        public int nextInt() {
530            return data[idx++];
531        }
532
533        @Override
534        public boolean hasNext() {
535            return idx < data.length;
536        }
537    }
538
539    private static class CannedLongPrimitiveIterator implements PrimitiveIterator.OfLong {
540        private final long[] data;
541        private int idx;
542
543        public CannedLongPrimitiveIterator(long[] data) {
544            this.data = data;
545            this.idx = 0;
546        }
547
548        @Override
549        public long nextLong() {
550            return data[idx++];
551        }
552
553        @Override
554        public boolean hasNext() {
555            return idx < data.length;
556        }
557    }
558
559    private static class CannedDoublePrimitiveIterator implements PrimitiveIterator.OfDouble {
560        private final double[] data;
561        private int idx;
562
563        public CannedDoublePrimitiveIterator(double[] data) {
564            this.data = data;
565            this.idx = 0;
566        }
567
568        @Override
569        public double nextDouble() {
570            return data[idx++];
571        }
572
573        @Override
574        public boolean hasNext() {
575            return idx < data.length;
576        }
577
578
579    }
580
581    public void test_spliterator_intPrimitiveIterator() {
582        int[] data = new int[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
583        PrimitiveIterator.OfInt elements = new CannedIntPrimitiveIterator(data);
584        Spliterator.OfInt intSp = Spliterators.spliterator(elements, 16 /* size */, 0);
585
586        assertEquals(16, intSp.estimateSize());
587        assertEquals(16, intSp.getExactSizeIfKnown());
588
589        assertTrue(intSp.tryAdvance((Integer value) -> assertEquals(1, (int) value)));
590        assertTrue(intSp.tryAdvance((int value) -> assertEquals(2, (int) value)));
591
592        PrimitiveIntArrayList recorder = new PrimitiveIntArrayList(16);
593        // Record elements observed by previous tests.
594        recorder.add(1);
595        recorder.add(2);
596
597        Spliterator.OfInt split1 = intSp.trySplit();
598        assertNotNull(split1);
599        assertTrue(split1.tryAdvance((int value) -> recorder.add(value)));
600        assertTrue(split1.tryAdvance((Integer value) -> recorder.add(value)));
601
602        // Assert that splits can themselves resplit.
603        Spliterator.OfInt split2 = split1.trySplit();
604        assertNotNull(split2);
605        split2.forEachRemaining((int value) -> recorder.add(value));
606        assertFalse(split2.tryAdvance((int value) -> fail()));
607        assertFalse(split2.tryAdvance((Integer value) -> fail()));
608
609        // Iterate over the remaning elements so we can make sure we've looked at
610        // everything.
611        split1.forEachRemaining((int value) -> recorder.add(value));
612        intSp.forEachRemaining((int value) -> recorder.add(value));
613
614        int[] recorded = recorder.toSortedArray();
615        assertEquals(Arrays.toString(data), Arrays.toString(recorded));
616    }
617
618    public void test_spliterator_intPrimitiveIterator_unsized() {
619        int[] data = new int[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
620        PrimitiveIterator.OfInt elements = new CannedIntPrimitiveIterator(data);
621        Spliterator.OfInt intSp = Spliterators.spliteratorUnknownSize(elements, 0);
622
623        assertTrue(intSp.tryAdvance((Integer value) -> assertEquals(1, (int) value)));
624        assertTrue(intSp.tryAdvance((int value) -> assertEquals(2, (int) value)));
625
626        PrimitiveIntArrayList recorder = new PrimitiveIntArrayList(16);
627        // Record elements observed by previous tests.
628        recorder.add(1);
629        recorder.add(2);
630
631        Spliterator.OfInt split1 = intSp.trySplit();
632        assertNotNull(split1);
633        assertTrue(split1.tryAdvance((int value) -> recorder.add(value)));
634        assertTrue(split1.tryAdvance((Integer value) -> recorder.add(value)));
635
636        // Assert that splits can themselves resplit.
637        Spliterator.OfInt split2 = split1.trySplit();
638        assertNotNull(split2);
639        split2.forEachRemaining((int value) -> recorder.add(value));
640        assertFalse(split2.tryAdvance((int value) -> fail()));
641        assertFalse(split2.tryAdvance((Integer value) -> fail()));
642
643        // Iterate over the remaning elements so we can make sure we've looked at
644        // everything.
645        split1.forEachRemaining((int value) -> recorder.add(value));
646        intSp.forEachRemaining((int value) -> recorder.add(value));
647
648        int[] recorded = recorder.toSortedArray();
649        assertEquals(Arrays.toString(data), Arrays.toString(recorded));
650    }
651
652    public void test_spliterator_longPrimitiveIterator() {
653        long[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
654        PrimitiveIterator.OfLong elements = new CannedLongPrimitiveIterator(data);
655        Spliterator.OfLong longSp = Spliterators.spliterator(elements, 16 /* size */, 0);
656
657        assertEquals(16, longSp.estimateSize());
658        assertEquals(16, longSp.getExactSizeIfKnown());
659
660        assertTrue(longSp.tryAdvance((Long value) -> assertEquals(1, (long) value)));
661        assertTrue(longSp.tryAdvance((long value) -> assertEquals(2, (long) value)));
662
663        PrimitiveLongArrayList recorder = new PrimitiveLongArrayList(16);
664        // Record elements observed by previous tests.
665        recorder.add(1);
666        recorder.add(2);
667
668        Spliterator.OfLong split1 = longSp.trySplit();
669        assertNotNull(split1);
670        assertTrue(split1.tryAdvance((long value) -> recorder.add(value)));
671        assertTrue(split1.tryAdvance((Long value) -> recorder.add(value)));
672
673        // Assert that splits can themselves resplit.
674        Spliterator.OfLong split2 = split1.trySplit();
675        assertNotNull(split2);
676        split2.forEachRemaining((long value) -> recorder.add(value));
677        assertFalse(split2.tryAdvance((long value) -> fail()));
678        assertFalse(split2.tryAdvance((Long value) -> fail()));
679
680        // Iterate over the remaning elements so we can make sure we've looked at
681        // everything.
682        split1.forEachRemaining((long value) -> recorder.add(value));
683        longSp.forEachRemaining((long value) -> recorder.add(value));
684
685        long[] recorded = recorder.toSortedArray();
686        assertEquals(Arrays.toString(data), Arrays.toString(recorded));
687    }
688
689    public void test_spliterator_longPrimitiveIterator_unsized() {
690        long[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
691        PrimitiveIterator.OfLong elements = new CannedLongPrimitiveIterator(data);
692        Spliterator.OfLong longSp = Spliterators.spliteratorUnknownSize(elements, 0);
693
694        assertTrue(longSp.tryAdvance((Long value) -> assertEquals(1, (long) value)));
695        assertTrue(longSp.tryAdvance((long value) -> assertEquals(2, (long) value)));
696
697        PrimitiveLongArrayList recorder = new PrimitiveLongArrayList(16);
698        // Record elements observed by previous tests.
699        recorder.add(1);
700        recorder.add(2);
701
702        Spliterator.OfLong split1 = longSp.trySplit();
703        assertNotNull(split1);
704        assertTrue(split1.tryAdvance((long value) -> recorder.add(value)));
705        assertTrue(split1.tryAdvance((Long value) -> recorder.add(value)));
706
707        // Assert that splits can themselves resplit.
708        Spliterator.OfLong split2 = split1.trySplit();
709        assertNotNull(split2);
710        split2.forEachRemaining((long value) -> recorder.add(value));
711        assertFalse(split2.tryAdvance((long value) -> fail()));
712        assertFalse(split2.tryAdvance((Long value) -> fail()));
713
714        // Iterate over the remaning elements so we can make sure we've looked at
715        // everything.
716        split1.forEachRemaining((long value) -> recorder.add(value));
717        longSp.forEachRemaining((long value) -> recorder.add(value));
718
719        long[] recorded = recorder.toSortedArray();
720        assertEquals(Arrays.toString(data), Arrays.toString(recorded));
721    }
722
723    public void test_spliterator_doublePrimitiveIterator() {
724        double[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
725        PrimitiveIterator.OfDouble elements = new CannedDoublePrimitiveIterator(data);
726        Spliterator.OfDouble doubleSp = Spliterators.spliterator(elements, 16 /* size */, 0);
727
728        assertEquals(16, doubleSp.estimateSize());
729        assertEquals(16, doubleSp.getExactSizeIfKnown());
730
731        assertTrue(doubleSp.tryAdvance((Double value) -> assertEquals(1.0, (double) value)));
732        assertTrue(doubleSp.tryAdvance((double value) -> assertEquals(2.0, (double) value)));
733
734        PrimitiveDoubleArrayList recorder = new PrimitiveDoubleArrayList(16);
735        // Record elements observed by previous tests.
736        recorder.add(1);
737        recorder.add(2);
738
739        Spliterator.OfDouble split1 = doubleSp.trySplit();
740        assertNotNull(split1);
741        assertTrue(split1.tryAdvance((double value) -> recorder.add(value)));
742        assertTrue(split1.tryAdvance((Double value) -> recorder.add(value)));
743
744        // Assert that splits can themselves resplit.
745        Spliterator.OfDouble split2 = split1.trySplit();
746        assertNotNull(split2);
747        split2.forEachRemaining((double value) -> recorder.add(value));
748        assertFalse(split2.tryAdvance((double value) -> fail()));
749        assertFalse(split2.tryAdvance((Double value) -> fail()));
750
751        // Iterate over the remaining elements so we can make sure we've looked at
752        // everything.
753        split1.forEachRemaining((double value) -> recorder.add(value));
754        doubleSp.forEachRemaining((double value) -> recorder.add(value));
755
756        double[] recorded = recorder.toSortedArray();
757        assertEquals(Arrays.toString(data), Arrays.toString(recorded));
758    }
759
760    public void test_spliterator_doublePrimitiveIterator_unsized() {
761        double[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
762        PrimitiveIterator.OfDouble elements = new CannedDoublePrimitiveIterator(data);
763        Spliterator.OfDouble doubleSp = Spliterators.spliteratorUnknownSize(elements, 0);
764
765        assertTrue(doubleSp.tryAdvance((Double value) -> assertEquals(1.0, (double) value)));
766        assertTrue(doubleSp.tryAdvance((double value) -> assertEquals(2.0, (double) value)));
767
768        PrimitiveDoubleArrayList recorder = new PrimitiveDoubleArrayList(16);
769        // Record elements observed by previous tests.
770        recorder.add(1);
771        recorder.add(2);
772
773        Spliterator.OfDouble split1 = doubleSp.trySplit();
774        assertNotNull(split1);
775        assertTrue(split1.tryAdvance((double value) -> recorder.add(value)));
776        assertTrue(split1.tryAdvance((Double value) -> recorder.add(value)));
777
778        // Assert that splits can themselves resplit.
779        Spliterator.OfDouble split2 = split1.trySplit();
780        assertNotNull(split2);
781        split2.forEachRemaining((double value) -> recorder.add(value));
782        assertFalse(split2.tryAdvance((double value) -> fail()));
783        assertFalse(split2.tryAdvance((Double value) -> fail()));
784
785        // Iterate over the remaining elements so we can make sure we've looked at
786        // everything.
787        split1.forEachRemaining((double value) -> recorder.add(value));
788        doubleSp.forEachRemaining((double value) -> recorder.add(value));
789
790        double[] recorded = recorder.toSortedArray();
791        assertEquals(Arrays.toString(data), Arrays.toString(recorded));
792    }
793
794    // Conversions from spliterators to iterators
795
796    public void test_iterator_int() {
797        int[] data = new int[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
798        Spliterator.OfInt intSp = Spliterators.spliterator(data, 0);
799        PrimitiveIterator.OfInt it = Spliterators.iterator(intSp);
800
801        assertTrue(it.hasNext());
802        assertEquals(1, (int) it.next());
803        assertEquals(2, it.nextInt());
804
805        PrimitiveIntArrayList recorder = new PrimitiveIntArrayList(16);
806        recorder.add(1);
807        recorder.add(2);
808        it.forEachRemaining((Integer l) -> recorder.add(l));
809        assertEquals(Arrays.toString(data), Arrays.toString(recorder.toSortedArray()));
810
811        assertFalse(it.hasNext());
812    }
813
814    public void test_iterator_long() {
815        long[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
816        Spliterator.OfLong longSp = Spliterators.spliterator(data, 0);
817        PrimitiveIterator.OfLong it = Spliterators.iterator(longSp);
818
819        assertTrue(it.hasNext());
820        assertEquals(1, (long) it.next());
821        assertEquals(2, it.nextLong());
822
823        PrimitiveLongArrayList recorder = new PrimitiveLongArrayList(16);
824        recorder.add(1);
825        recorder.add(2);
826        it.forEachRemaining((Long l) -> recorder.add(l));
827        assertEquals(Arrays.toString(data), Arrays.toString(recorder.toSortedArray()));
828
829        assertFalse(it.hasNext());
830    }
831
832    public void test_iterator_double() {
833        double[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
834        Spliterator.OfDouble doubleSp = Spliterators.spliterator(data, 0);
835
836        PrimitiveIterator.OfDouble it = Spliterators.iterator(doubleSp);
837
838        assertTrue(it.hasNext());
839        assertEquals(1.0, it.next());
840        assertEquals(2.0, it.nextDouble());
841
842        PrimitiveDoubleArrayList recorder = new PrimitiveDoubleArrayList(16);
843        recorder.add(1.0);
844        recorder.add(2.0);
845        it.forEachRemaining((Double l) -> recorder.add(l));
846        assertEquals(Arrays.toString(data), Arrays.toString(recorder.toSortedArray()));
847
848        assertFalse(it.hasNext());
849    }
850
851    public void test_iterator_ref() {
852        String[] array = { "a", "b", "c", "d", "e", "f", "g", "h" };
853        Spliterator<String> stringSp = Spliterators.spliterator(array, 0);
854        Iterator<String> it = Spliterators.iterator(stringSp);
855
856        assertTrue(it.hasNext());
857        assertEquals("a", it.next());
858
859        ArrayList<String> recorder = new ArrayList<>();
860        recorder.add("a");
861        it.forEachRemaining((val) -> recorder.add(val));
862        assertEquals(Arrays.toString(array), Arrays.toString(recorder.toArray()));
863
864        assertFalse(it.hasNext());
865    }
866}
867