1 /*
2 * Copyright (c) 2013, 2026, 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
24 /**
25 * @test
26 * @summary Spliterator traversing and splitting tests
27 * @library /lib/testlibrary/bootlib
28 * @build java.base/java.util.SpliteratorOfIntDataBuilder
29 * java.base/java.util.SpliteratorTestHelper
30 * @run testng SpliteratorTraversingAndSplittingTest
31 * @bug 8020016 8071477 8072784 8169838
32 */
33
34 import org.testng.annotations.DataProvider;
35 import org.testng.annotations.Test;
36
37 import java.nio.CharBuffer;
38 import java.util.AbstractCollection;
39 import java.util.AbstractList;
40 import java.util.AbstractSet;
41 import java.util.ArrayDeque;
42 import java.util.ArrayList;
43 import java.util.Arrays;
44 import java.util.Collection;
45 import java.util.Collections;
46 import java.util.Comparator;
47 import java.util.HashMap;
48 import java.util.HashSet;
49 import java.util.IdentityHashMap;
50 import java.util.Iterator;
51 import java.util.LinkedHashMap;
52 import java.util.LinkedHashSet;
53 import java.util.LinkedList;
54 import java.util.List;
55 import java.util.ListIterator;
56 import java.util.Map;
57 import java.util.PriorityQueue;
58 import java.util.RandomAccess;
59 import java.util.Set;
60 import java.util.SortedSet;
61 import java.util.Spliterator;
62 import java.util.SpliteratorOfIntDataBuilder;
63 import java.util.SpliteratorTestHelper;
64 import java.util.Spliterators;
65 import java.util.Stack;
66 import java.util.TreeMap;
67 import java.util.TreeSet;
68 import java.util.Vector;
69 import java.util.WeakHashMap;
70 import java.util.concurrent.ArrayBlockingQueue;
71 import java.util.concurrent.ConcurrentHashMap;
72 import java.util.concurrent.ConcurrentLinkedQueue;
73 import java.util.concurrent.ConcurrentSkipListMap;
74 import java.util.concurrent.ConcurrentSkipListSet;
75 import java.util.concurrent.CopyOnWriteArrayList;
76 import java.util.concurrent.CopyOnWriteArraySet;
77 import java.util.concurrent.LinkedBlockingDeque;
78 import java.util.concurrent.LinkedBlockingQueue;
79 import java.util.concurrent.LinkedTransferQueue;
80 import java.util.concurrent.PriorityBlockingQueue;
81 import java.util.function.Consumer;
82 import java.util.function.DoubleConsumer;
83 import java.util.function.Function;
84 import java.util.function.IntConsumer;
85 import java.util.function.LongConsumer;
86 import java.util.function.Supplier;
87 import java.util.function.UnaryOperator;
88
89 public class SpliteratorTraversingAndSplittingTest extends SpliteratorTestHelper {
90
91 private static final List<Integer> SIZES = Arrays.asList(0, 1, 10, 42);
92
93 private static final String LOW = new String(new char[] {Character.MIN_LOW_SURROGATE});
94 private static final String HIGH = new String(new char[] {Character.MIN_HIGH_SURROGATE});
95 private static final String HIGH_LOW = HIGH + LOW;
96 private static final String CHAR_HIGH_LOW = "A" + HIGH_LOW;
97 private static final String HIGH_LOW_CHAR = HIGH_LOW + "A";
98 private static final String CHAR_HIGH_LOW_CHAR = "A" + HIGH_LOW + "A";
99
100 private static final List<String> STRINGS = generateTestStrings();
101
102 private static List<String> generateTestStrings() {
103 List<String> strings = new ArrayList<>();
104 for (int n : Arrays.asList(1, 2, 3, 16, 17)) {
105 strings.add(generate("A", n));
106 strings.add(generate(LOW, n));
107 strings.add(generate(HIGH, n));
108 strings.add(generate(HIGH_LOW, n));
109 strings.add(generate(CHAR_HIGH_LOW, n));
110 strings.add(generate(HIGH_LOW_CHAR, n));
111 strings.add(generate(CHAR_HIGH_LOW_CHAR, n));
112 }
113 return strings;
114 }
115
116 private static String generate(String s, int n) {
117 StringBuilder sb = new StringBuilder();
118 for (int i = 0; i < n; i++) {
119 sb.append(s);
120 }
121 return sb.toString();
122 }
123
124 private static class SpliteratorDataBuilder<T> {
125 List<Object[]> data;
126
127 List<T> exp;
128
129 List<T> expRev;
130
131 Map<T, T> mExp;
132
133 Map<T, T> mExpRev;
134
135 SpliteratorDataBuilder(List<Object[]> data, List<T> exp) {
136 this.data = data;
137 this.exp = exp;
138 this.expRev = new ArrayList<>(exp);
139 Collections.reverse(this.expRev);
140 this.mExp = createMap(exp);
141 this.mExpRev = createMap(expRev);
142 }
143
144 Map<T, T> createMap(List<T> l) {
145 Map<T, T> m = new LinkedHashMap<>();
146 for (T t : l) {
147 m.put(t, t);
148 }
149 return m;
150 }
151
152 void add(String description, Collection<?> expected, Supplier<Spliterator<?>> s) {
153 description = joiner(description).toString();
154 data.add(new Object[]{description, expected, s});
155 }
156
157 void add(String description, Supplier<Spliterator<?>> s) {
158 add(description, exp, s);
159 }
160
161 void addCollection(Function<Collection<T>, ? extends Collection<T>> c) {
162 add("new " + c.apply(Collections.<T>emptyList()).getClass().getName() + ".spliterator()",
163 () -> c.apply(exp).spliterator());
164 }
165
166 void addList(Function<Collection<T>, ? extends List<T>> l) {
167 addCollection(l);
168 addCollection(l.andThen(list -> list.subList(0, list.size())));
169 }
170
171 void addMap(Function<Map<T, T>, ? extends Map<T, T>> m) {
172 String description = "new " + m.apply(Collections.<T, T>emptyMap()).getClass().getName();
173 addMap(m, description);
174 }
175
176 void addDescendingMap(Function<Map<T, T>, ? extends Map<T, T>> m) {
177 String description = "new " + m.apply(Collections.<T, T>emptyMap()).getClass().getName();
178 addDescendingMap(m, description);
179 }
180
181 void addMap(Function<Map<T, T>, ? extends Map<T, T>> m, String description) {
182 add(description + ".keySet().spliterator()", () -> m.apply(mExp).keySet().spliterator());
183 add(description + ".values().spliterator()", () -> m.apply(mExp).values().spliterator());
184 add(description + ".entrySet().spliterator()", mExp.entrySet(), () -> m.apply(mExp).entrySet().spliterator());
185 }
186
187 void addDescendingMap(Function<Map<T, T>, ? extends Map<T, T>> m, String description) {
188 add(description + ".keySet().spliterator()", expRev, () -> m.apply(mExp).keySet().spliterator());
189 add(description + ".values().spliterator()", expRev, () -> m.apply(mExp).values().spliterator());
190 add(description + ".entrySet().spliterator()", mExpRev.entrySet(), () -> m.apply(mExp).entrySet().spliterator());
191 }
192
193 StringBuilder joiner(String description) {
194 return new StringBuilder(description).
195 append(" {").
196 append("size=").append(exp.size()).
197 append("}");
198 }
199 }
200
201 static Object[][] spliteratorDataProvider;
202
203 @DataProvider(name = "Spliterator<Integer>")
204 public static Object[][] spliteratorDataProvider() {
205 if (spliteratorDataProvider != null) {
206 return spliteratorDataProvider;
207 }
208
209 List<Object[]> data = new ArrayList<>();
210 for (int size : SIZES) {
211 List<Integer> exp = listIntRange(size);
212 SpliteratorDataBuilder<Integer> db = new SpliteratorDataBuilder<>(data, exp);
213
214 // Direct spliterator methods
215
216 db.add("Spliterators.spliterator(Collection, ...)",
217 () -> Spliterators.spliterator(exp, 0));
218
219 db.add("Spliterators.spliterator(Iterator, ...)",
220 () -> Spliterators.spliterator(exp.iterator(), exp.size(), 0));
221
222 db.add("Spliterators.spliteratorUnknownSize(Iterator, ...)",
223 () -> Spliterators.spliteratorUnknownSize(exp.iterator(), 0));
224
225 db.add("Spliterators.spliterator(Spliterators.iteratorFromSpliterator(Spliterator ), ...)",
226 () -> Spliterators.spliterator(Spliterators.iterator(exp.spliterator()), exp.size(), 0));
227
228 db.add("Spliterators.spliterator(T[], ...)",
229 () -> Spliterators.spliterator(exp.toArray(new Integer[0]), 0));
230
231 db.add("Arrays.spliterator(T[], ...)",
232 () -> Arrays.spliterator(exp.toArray(new Integer[0])));
233
234 class SpliteratorFromIterator extends Spliterators.AbstractSpliterator<Integer> {
235 Iterator<Integer> it;
236
237 SpliteratorFromIterator(Iterator<Integer> it, long est) {
238 super(est, Spliterator.SIZED);
239 this.it = it;
240 }
241
242 @Override
243 public boolean tryAdvance(Consumer<? super Integer> action) {
244 if (action == null)
245 throw new NullPointerException();
246 if (it.hasNext()) {
247 action.accept(it.next());
248 return true;
249 }
250 else {
251 return false;
252 }
253 }
254 }
255 db.add("new Spliterators.AbstractSpliterator()",
256 () -> new SpliteratorFromIterator(exp.iterator(), exp.size()));
257
258 // Collections
259
260 // default method implementations
261
262 class AbstractCollectionImpl extends AbstractCollection<Integer> {
263 Collection<Integer> c;
264
265 AbstractCollectionImpl(Collection<Integer> c) {
266 this.c = c;
267 }
268
269 @Override
270 public Iterator<Integer> iterator() {
271 return c.iterator();
272 }
273
274 @Override
275 public int size() {
276 return c.size();
277 }
278 }
279 db.addCollection(
280 c -> new AbstractCollectionImpl(c));
281
282 class AbstractListImpl extends AbstractList<Integer> {
283 List<Integer> l;
284
285 AbstractListImpl(Collection<Integer> c) {
286 this.l = new ArrayList<>(c);
287 }
288
289 @Override
290 public Integer get(int index) {
291 return l.get(index);
292 }
293
294 @Override
295 public int size() {
296 return l.size();
297 }
298 }
299 db.addCollection(
300 c -> new AbstractListImpl(c));
301
302 class AbstractSetImpl extends AbstractSet<Integer> {
303 Set<Integer> s;
304
305 AbstractSetImpl(Collection<Integer> c) {
306 this.s = new HashSet<>(c);
307 }
308
309 @Override
310 public Iterator<Integer> iterator() {
311 return s.iterator();
312 }
313
314 @Override
315 public int size() {
316 return s.size();
317 }
318 }
319 db.addCollection(
320 c -> new AbstractSetImpl(c));
321
322 class AbstractSortedSetImpl extends AbstractSet<Integer> implements SortedSet<Integer> {
323 SortedSet<Integer> s;
324
325 AbstractSortedSetImpl(Collection<Integer> c) {
326 this.s = new TreeSet<>(c);
327 }
328
329 @Override
330 public Iterator<Integer> iterator() {
331 return s.iterator();
332 }
333
334 @Override
335 public int size() {
336 return s.size();
337 }
338
339 @Override
340 public Comparator<? super Integer> comparator() {
341 return s.comparator();
342 }
343
344 @Override
345 public SortedSet<Integer> subSet(Integer fromElement, Integer toElement) {
346 return s.subSet(fromElement, toElement);
347 }
348
349 @Override
350 public SortedSet<Integer> headSet(Integer toElement) {
351 return s.headSet(toElement);
352 }
353
354 @Override
355 public SortedSet<Integer> tailSet(Integer fromElement) {
356 return s.tailSet(fromElement);
357 }
358
359 @Override
360 public Integer first() {
361 return s.first();
362 }
363
364 @Override
365 public Integer last() {
366 return s.last();
367 }
368
369 @Override
370 public Spliterator<Integer> spliterator() {
371 return SortedSet.super.spliterator();
372 }
373 }
374 db.addCollection(
375 c -> new AbstractSortedSetImpl(c));
376
377 class IterableWrapper implements Iterable<Integer> {
378 final Iterable<Integer> it;
379
380 IterableWrapper(Iterable<Integer> it) {
381 this.it = it;
382 }
383
384 @Override
385 public Iterator<Integer> iterator() {
386 return it.iterator();
387 }
388 }
389 db.add("new Iterable.spliterator()",
390 () -> new IterableWrapper(exp).spliterator());
391
392 //
393
394 db.add("Arrays.asList().spliterator()",
395 () -> Spliterators.spliterator(Arrays.asList(exp.toArray(new Integer[0])), 0));
396
397 db.addList(ArrayList::new);
398
399 db.addList(LinkedList::new);
400
401 db.addList(Vector::new);
402
403 class AbstractRandomAccessListImpl extends AbstractList<Integer> implements RandomAccess {
404 Integer[] ia;
405
406 AbstractRandomAccessListImpl(Collection<Integer> c) {
407 this.ia = c.toArray(new Integer[c.size()]);
408 }
409
410 @Override
411 public Integer get(int index) {
412 return ia[index];
413 }
414
415 @Override
416 public int size() {
417 return ia.length;
418 }
419 }
420 db.addList(AbstractRandomAccessListImpl::new);
421
422 class RandomAccessListImpl implements List<Integer>, RandomAccess {
423 Integer[] ia;
424 List<Integer> l;
425
426 RandomAccessListImpl(Collection<Integer> c) {
427 this.ia = c.toArray(new Integer[c.size()]);
428 this.l = Arrays.asList(ia);
429 }
430
431 @Override
432 public Integer get(int index) {
433 return ia[index];
434 }
435
436 @Override
437 public Integer set(int index, Integer element) {
438 throw new UnsupportedOperationException();
439 }
440
441 @Override
442 public void add(int index, Integer element) {
443 throw new UnsupportedOperationException();
444 }
445
446 @Override
447 public Integer remove(int index) {
448 throw new UnsupportedOperationException();
449 }
450
451 @Override
452 public int indexOf(Object o) {
453 return l.indexOf(o);
454 }
455
456 @Override
457 public int lastIndexOf(Object o) {
458 return Arrays.asList(ia).lastIndexOf(o);
459 }
460
461 @Override
462 public ListIterator<Integer> listIterator() {
463 return l.listIterator();
464 }
465
466 @Override
467 public ListIterator<Integer> listIterator(int index) {
468 return l.listIterator(index);
469 }
470
471 @Override
472 public List<Integer> subList(int fromIndex, int toIndex) {
473 return l.subList(fromIndex, toIndex);
474 }
475
476 @Override
477 public int size() {
478 return ia.length;
479 }
480
481 @Override
482 public boolean isEmpty() {
483 return size() != 0;
484 }
485
486 @Override
487 public boolean contains(Object o) {
488 return l.contains(o);
489 }
490
491 @Override
492 public Iterator<Integer> iterator() {
493 return l.iterator();
494 }
495
496 @Override
497 public Object[] toArray() {
498 return l.toArray();
499 }
500
501 @Override
502 public <T> T[] toArray(T[] a) {
503 return l.toArray(a);
504 }
505
506 @Override
507 public boolean add(Integer integer) {
508 throw new UnsupportedOperationException();
509 }
510
511 @Override
512 public boolean remove(Object o) {
513 throw new UnsupportedOperationException();
514 }
515
516 @Override
517 public boolean containsAll(Collection<?> c) {
518 return l.containsAll(c);
519 }
520
521 @Override
522 public boolean addAll(Collection<? extends Integer> c) {
523 throw new UnsupportedOperationException();
524 }
525
526 @Override
527 public boolean addAll(int index, Collection<? extends Integer> c) {
528 throw new UnsupportedOperationException();
529 }
530
531 @Override
532 public boolean removeAll(Collection<?> c) {
533 throw new UnsupportedOperationException();
534 }
535
536 @Override
537 public boolean retainAll(Collection<?> c) {
538 throw new UnsupportedOperationException();
539 }
540
541 @Override
542 public void clear() {
543 throw new UnsupportedOperationException();
544 }
545 }
546 db.addList(RandomAccessListImpl::new);
547
548 db.addCollection(HashSet::new);
549
550 db.addCollection(LinkedHashSet::new);
551
552 db.addCollection(TreeSet::new);
553
554
555 db.addCollection(c -> { Stack<Integer> s = new Stack<>(); s.addAll(c); return s;});
556
557 db.addCollection(PriorityQueue::new);
558
559 db.addCollection(ArrayDeque::new);
560
561
562 db.addCollection(ConcurrentSkipListSet::new);
563
564 if (size > 0) {
565 db.addCollection(c -> {
566 ArrayBlockingQueue<Integer> abq = new ArrayBlockingQueue<>(size);
567 abq.addAll(c);
568 return abq;
569 });
570 }
571
572 db.addCollection(PriorityBlockingQueue::new);
573
574 db.addCollection(LinkedBlockingQueue::new);
575
576 db.addCollection(LinkedTransferQueue::new);
577
578 db.addCollection(ConcurrentLinkedQueue::new);
579
580 db.addCollection(LinkedBlockingDeque::new);
581
582 db.addCollection(CopyOnWriteArrayList::new);
583
584 db.addCollection(CopyOnWriteArraySet::new);
585
586 if (size == 0) {
587 db.addCollection(c -> Collections.<Integer>emptySet());
588 db.addList(c -> Collections.<Integer>emptyList());
589 }
590 else if (size == 1) {
591 db.addCollection(c -> Collections.singleton(exp.get(0)));
592 db.addCollection(c -> Collections.singletonList(exp.get(0)));
593 }
594
595 {
596 Integer[] ai = new Integer[size];
597 Arrays.fill(ai, 1);
598 db.add(String.format("Collections.nCopies(%d, 1)", exp.size()),
599 Arrays.asList(ai),
600 () -> Collections.nCopies(exp.size(), 1).spliterator());
601 }
602
603 // Collections.synchronized/unmodifiable/checked wrappers
604 db.addCollection(Collections::unmodifiableCollection);
605 db.addCollection(c -> Collections.unmodifiableSet(new HashSet<>(c)));
606 db.addCollection(c -> Collections.unmodifiableSortedSet(new TreeSet<>(c)));
607 db.addList(c -> Collections.unmodifiableList(new ArrayList<>(c)));
608 db.addMap(Collections::unmodifiableMap);
609 db.addMap(m -> Collections.unmodifiableSortedMap(new TreeMap<>(m)));
610
611 db.addCollection(Collections::synchronizedCollection);
612 db.addCollection(c -> Collections.synchronizedSet(new HashSet<>(c)));
613 db.addCollection(c -> Collections.synchronizedSortedSet(new TreeSet<>(c)));
614 db.addList(c -> Collections.synchronizedList(new ArrayList<>(c)));
615 db.addMap(Collections::synchronizedMap);
616 db.addMap(m -> Collections.synchronizedSortedMap(new TreeMap<>(m)));
617
618 db.addCollection(c -> Collections.checkedCollection(c, Integer.class));
619 db.addCollection(c -> Collections.checkedQueue(new ArrayDeque<>(c), Integer.class));
620 db.addCollection(c -> Collections.checkedSet(new HashSet<>(c), Integer.class));
621 db.addCollection(c -> Collections.checkedSortedSet(new TreeSet<>(c), Integer.class));
622 db.addList(c -> Collections.checkedList(new ArrayList<>(c), Integer.class));
623 db.addMap(c -> Collections.checkedMap(c, Integer.class, Integer.class));
624 db.addMap(m -> Collections.checkedSortedMap(new TreeMap<>(m), Integer.class, Integer.class));
625
626 // Maps
627
628 db.addMap(HashMap::new);
629
630 db.addMap(m -> {
631 // Create a Map ensuring that for large sizes
632 // buckets will contain 2 or more entries
633 HashMap<Integer, Integer> cm = new HashMap<>(1, m.size() + 1);
634 // Don't use putAll which inflates the table by
635 // m.size() * loadFactor, thus creating a very sparse
636 // map for 1000 entries defeating the purpose of this test,
637 // in addition it will cause the split until null test to fail
638 // because the number of valid splits is larger than the
639 // threshold
640 for (Map.Entry<Integer, Integer> e : m.entrySet())
641 cm.put(e.getKey(), e.getValue());
642 return cm;
643 }, "new java.util.HashMap(1, size + 1)");
644
645 db.addMap(LinkedHashMap::new);
646
647 db.addMap(IdentityHashMap::new);
648
649 db.addMap(WeakHashMap::new);
650
651 db.addMap(m -> {
652 // Create a Map ensuring that for large sizes
653 // buckets will be consist of 2 or more entries
654 WeakHashMap<Integer, Integer> cm = new WeakHashMap<>(1, m.size() + 1);
655 for (Map.Entry<Integer, Integer> e : m.entrySet())
656 cm.put(e.getKey(), e.getValue());
657 return cm;
658 }, "new java.util.WeakHashMap(1, size + 1)");
659
660 db.addMap(TreeMap::new);
661 db.addMap(m -> new TreeMap<>(m).tailMap(Integer.MIN_VALUE));
662 db.addMap(m -> new TreeMap<>(m).headMap(Integer.MAX_VALUE));
663 db.addMap(m -> new TreeMap<>(m).subMap(Integer.MIN_VALUE, Integer.MAX_VALUE));
664 db.addDescendingMap(m -> new TreeMap<>(m).descendingMap());
665 db.addDescendingMap(m -> new TreeMap<>(m).descendingMap().tailMap(Integer.MAX_VALUE));
666 db.addDescendingMap(m -> new TreeMap<>(m).descendingMap().headMap(Integer.MIN_VALUE));
667 db.addDescendingMap(m -> new TreeMap<>(m).descendingMap().subMap(Integer.MAX_VALUE, Integer.MIN_VALUE));
668
669 db.addMap(ConcurrentHashMap::new);
670
671 db.addMap(ConcurrentSkipListMap::new);
672
673 if (size == 0) {
674 db.addMap(m -> Collections.<Integer, Integer>emptyMap());
675 }
676 else if (size == 1) {
677 db.addMap(m -> Collections.singletonMap(exp.get(0), exp.get(0)));
678 }
679 }
680
681 return spliteratorDataProvider = data.toArray(new Object[0][]);
682 }
683
684 private static List<Integer> listIntRange(int upTo) {
685 List<Integer> exp = new ArrayList<>();
686 for (int i = 0; i < upTo; i++)
687 exp.add(i);
688 return Collections.unmodifiableList(exp);
689 }
690
691 @Test(dataProvider = "Spliterator<Integer>")
692 public void testNullPointerException(String description, Collection<Integer> exp, Supplier<Spliterator<Integer>> s) {
693 assertThrowsNPE(() -> s.get().forEachRemaining(null));
694 assertThrowsNPE(() -> s.get().tryAdvance(null));
695 }
696
697 @Test(dataProvider = "Spliterator<Integer>")
698 public void testForEach(String description, Collection<Integer> exp, Supplier<Spliterator<Integer>> s) {
699 testForEach(exp, s, UnaryOperator.identity());
700 }
701
702 @Test(dataProvider = "Spliterator<Integer>")
703 public void testTryAdvance(String description, Collection<Integer> exp, Supplier<Spliterator<Integer>> s) {
704 testTryAdvance(exp, s, UnaryOperator.identity());
705 }
706
707 @Test(dataProvider = "Spliterator<Integer>")
708 public void testMixedTryAdvanceForEach(String description, Collection<Integer> exp, Supplier<Spliterator<Integer>> s) {
709 testMixedTryAdvanceForEach(exp, s, UnaryOperator.identity());
710 }
711
712 @Test(dataProvider = "Spliterator<Integer>")
713 public void testMixedTraverseAndSplit(String description, Collection<Integer> exp, Supplier<Spliterator<Integer>> s) {
714 testMixedTraverseAndSplit(exp, s, UnaryOperator.identity());
715 }
716
717 @Test(dataProvider = "Spliterator<Integer>")
718 public void testSplitAfterFullTraversal(String description, Collection<Integer> exp, Supplier<Spliterator<Integer>> s) {
719 testSplitAfterFullTraversal(s, UnaryOperator.identity());
720 }
721
722 @Test(dataProvider = "Spliterator<Integer>")
723 public void testSplitOnce(String description, Collection<Integer> exp, Supplier<Spliterator<Integer>> s) {
724 testSplitOnce(exp, s, UnaryOperator.identity());
725 }
726
727 @Test(dataProvider = "Spliterator<Integer>")
728 public void testSplitSixDeep(String description, Collection<Integer> exp, Supplier<Spliterator<Integer>> s) {
729 testSplitSixDeep(exp, s, UnaryOperator.identity());
730 }
731
732 @Test(dataProvider = "Spliterator<Integer>")
733 public void testSplitUntilNull(String description, Collection<Integer> exp, Supplier<Spliterator<Integer>> s) {
734 testSplitUntilNull(exp, s, UnaryOperator.identity());
735 }
736
737 //
738 private static class SpliteratorOfIntCharDataBuilder {
739 List<Object[]> data;
740
741 String s;
742
743 List<Integer> expChars;
744
745 List<Integer> expCodePoints;
746
747 SpliteratorOfIntCharDataBuilder(List<Object[]> data, String s) {
748 this.data = data;
749 this.s = s;
750 this.expChars = transform(s, false);
751 this.expCodePoints = transform(s, true);
752 }
753
754 static List<Integer> transform(String s, boolean toCodePoints) {
755 List<Integer> l = new ArrayList<>();
756
757 if (!toCodePoints) {
758 for (int i = 0; i < s.length(); i++) {
759 l.add((int) s.charAt(i));
760 }
761 }
762 else {
763 for (int i = 0; i < s.length();) {
764 char c1 = s.charAt(i++);
765 int cp = c1;
766 if (Character.isHighSurrogate(c1) && i < s.length()) {
767 char c2 = s.charAt(i);
768 if (Character.isLowSurrogate(c2)) {
769 i++;
770 cp = Character.toCodePoint(c1, c2);
771 }
772 }
773 l.add(cp);
774 }
775 }
776 return l;
777 }
778
779 void add(String description, Function<String, CharSequence> f) {
780 description = description.replace("%s", s);
781 {
782 Supplier<Spliterator.OfInt> supplier = () -> f.apply(s).chars().spliterator();
783 data.add(new Object[]{description + ".chars().spliterator()", expChars, supplier});
784 }
785 {
786 Supplier<Spliterator.OfInt> supplier = () -> f.apply(s).codePoints().spliterator();
787 data.add(new Object[]{description + ".codePoints().spliterator()", expCodePoints, supplier});
788 }
789 }
790 }
791
792 static Object[][] spliteratorOfIntDataProvider;
793
794 @DataProvider(name = "Spliterator.OfInt")
795 public static Object[][] spliteratorOfIntDataProvider() {
796 if (spliteratorOfIntDataProvider != null) {
797 return spliteratorOfIntDataProvider;
798 }
799
800 List<Object[]> data = new ArrayList<>();
801 for (int size : SIZES) {
802 int exp[] = arrayIntRange(size);
803 SpliteratorOfIntDataBuilder db = new SpliteratorOfIntDataBuilder(data, listIntRange(size));
804
805 db.add("Spliterators.spliterator(int[], ...)",
806 () -> Spliterators.spliterator(exp, 0));
807
808 db.add("Arrays.spliterator(int[], ...)",
809 () -> Arrays.spliterator(exp));
810
811 db.add("Spliterators.spliterator(PrimitiveIterator.OfInt, ...)",
812 () -> Spliterators.spliterator(Spliterators.iterator(Arrays.spliterator(exp)), exp.length, 0));
813
814 db.add("Spliterators.spliteratorUnknownSize(PrimitiveIterator.OfInt, ...)",
815 () -> Spliterators.spliteratorUnknownSize(Spliterators.iterator(Arrays.spliterator(exp)), 0));
816
817 class IntSpliteratorFromArray extends Spliterators.AbstractIntSpliterator {
818 int[] a;
819 int index = 0;
820
821 IntSpliteratorFromArray(int[] a) {
822 super(a.length, Spliterator.SIZED);
823 this.a = a;
824 }
825
826 @Override
827 public boolean tryAdvance(IntConsumer action) {
828 if (action == null)
829 throw new NullPointerException();
830 if (index < a.length) {
831 action.accept(a[index++]);
832 return true;
833 }
834 else {
835 return false;
836 }
837 }
838 }
839 db.add("new Spliterators.AbstractIntAdvancingSpliterator()",
840 () -> new IntSpliteratorFromArray(exp));
841 }
842
843 // Class for testing default methods
844 class CharSequenceImpl implements CharSequence {
845 final String s;
846
847 public CharSequenceImpl(String s) {
848 this.s = s;
849 }
850
851 @Override
852 public int length() {
853 return s.length();
854 }
855
856 @Override
857 public char charAt(int index) {
858 return s.charAt(index);
859 }
860
861 @Override
862 public CharSequence subSequence(int start, int end) {
863 return s.subSequence(start, end);
864 }
865
866 @Override
867 public String toString() {
868 return s;
869 }
870 }
871
872 for (String string : STRINGS) {
873 SpliteratorOfIntCharDataBuilder cdb = new SpliteratorOfIntCharDataBuilder(data, string);
874 cdb.add("\"%s\"", s -> s);
875 cdb.add("new CharSequenceImpl(\"%s\")", CharSequenceImpl::new);
876 cdb.add("new StringBuilder(\"%s\")", StringBuilder::new);
877 cdb.add("new StringBuffer(\"%s\")", StringBuffer::new);
878 cdb.add("CharBuffer.wrap(\"%s\".toCharArray())", s -> CharBuffer.wrap(s.toCharArray()));
879 }
880
881 return spliteratorOfIntDataProvider = data.toArray(new Object[0][]);
882 }
883
884 private static int[] arrayIntRange(int upTo) {
885 int[] exp = new int[upTo];
886 for (int i = 0; i < upTo; i++)
887 exp[i] = i;
888 return exp;
889 }
890
891 @Test(dataProvider = "Spliterator.OfInt")
892 public void testIntNullPointerException(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
893 assertThrowsNPE(() -> s.get().forEachRemaining((IntConsumer) null));
894 assertThrowsNPE(() -> s.get().tryAdvance((IntConsumer) null));
895 }
896
897 @Test(dataProvider = "Spliterator.OfInt")
898 public void testIntForEach(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
899 testForEach(exp, s, intBoxingConsumer());
900 }
901
902 @Test(dataProvider = "Spliterator.OfInt")
903 public void testIntTryAdvance(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
904 testTryAdvance(exp, s, intBoxingConsumer());
905 }
906
907 @Test(dataProvider = "Spliterator.OfInt")
908 public void testIntMixedTryAdvanceForEach(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
909 testMixedTryAdvanceForEach(exp, s, intBoxingConsumer());
910 }
911
912 @Test(dataProvider = "Spliterator.OfInt")
913 public void testIntMixedTraverseAndSplit(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
914 testMixedTraverseAndSplit(exp, s, intBoxingConsumer());
915 }
916
917 @Test(dataProvider = "Spliterator.OfInt")
918 public void testIntSplitAfterFullTraversal(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
919 testSplitAfterFullTraversal(s, intBoxingConsumer());
920 }
921
922 @Test(dataProvider = "Spliterator.OfInt")
923 public void testIntSplitOnce(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
924 testSplitOnce(exp, s, intBoxingConsumer());
925 }
926
927 @Test(dataProvider = "Spliterator.OfInt")
928 public void testIntSplitSixDeep(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
929 testSplitSixDeep(exp, s, intBoxingConsumer());
930 }
931
932 @Test(dataProvider = "Spliterator.OfInt")
933 public void testIntSplitUntilNull(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
934 testSplitUntilNull(exp, s, intBoxingConsumer());
935 }
936
937 //
938
939 private static class SpliteratorOfLongDataBuilder {
940 List<Object[]> data;
941
942 List<Long> exp;
943
944 SpliteratorOfLongDataBuilder(List<Object[]> data, List<Long> exp) {
945 this.data = data;
946 this.exp = exp;
947 }
948
949 void add(String description, List<Long> expected, Supplier<Spliterator.OfLong> s) {
950 description = joiner(description).toString();
951 data.add(new Object[]{description, expected, s});
952 }
953
954 void add(String description, Supplier<Spliterator.OfLong> s) {
955 add(description, exp, s);
956 }
957
958 StringBuilder joiner(String description) {
959 return new StringBuilder(description).
960 append(" {").
961 append("size=").append(exp.size()).
962 append("}");
963 }
964 }
965
966 static Object[][] spliteratorOfLongDataProvider;
967
968 @DataProvider(name = "Spliterator.OfLong")
969 public static Object[][] spliteratorOfLongDataProvider() {
970 if (spliteratorOfLongDataProvider != null) {
971 return spliteratorOfLongDataProvider;
972 }
973
974 List<Object[]> data = new ArrayList<>();
975 for (int size : SIZES) {
976 long exp[] = arrayLongRange(size);
977 SpliteratorOfLongDataBuilder db = new SpliteratorOfLongDataBuilder(data, listLongRange(size));
978
979 db.add("Spliterators.spliterator(long[], ...)",
980 () -> Spliterators.spliterator(exp, 0));
981
982 db.add("Arrays.spliterator(long[], ...)",
983 () -> Arrays.spliterator(exp));
984
985 db.add("Spliterators.spliterator(PrimitiveIterator.OfLong, ...)",
986 () -> Spliterators.spliterator(Spliterators.iterator(Arrays.spliterator(exp)), exp.length, 0));
987
988 db.add("Spliterators.spliteratorUnknownSize(PrimitiveIterator.OfLong, ...)",
989 () -> Spliterators.spliteratorUnknownSize(Spliterators.iterator(Arrays.spliterator(exp)), 0));
990
991 class LongSpliteratorFromArray extends Spliterators.AbstractLongSpliterator {
992 long[] a;
993 int index = 0;
994
995 LongSpliteratorFromArray(long[] a) {
996 super(a.length, Spliterator.SIZED);
997 this.a = a;
998 }
999
1000 @Override
1001 public boolean tryAdvance(LongConsumer action) {
1002 if (action == null)
1003 throw new NullPointerException();
1004 if (index < a.length) {
1005 action.accept(a[index++]);
1006 return true;
1007 }
1008 else {
1009 return false;
1010 }
1011 }
1012 }
1013 db.add("new Spliterators.AbstractLongAdvancingSpliterator()",
1014 () -> new LongSpliteratorFromArray(exp));
1015 }
1016
1017 return spliteratorOfLongDataProvider = data.toArray(new Object[0][]);
1018 }
1019
1020 private static List<Long> listLongRange(int upTo) {
1021 List<Long> exp = new ArrayList<>();
1022 for (long i = 0; i < upTo; i++)
1023 exp.add(i);
1024 return Collections.unmodifiableList(exp);
1025 }
1026
1027 private static long[] arrayLongRange(int upTo) {
1028 long[] exp = new long[upTo];
1029 for (int i = 0; i < upTo; i++)
1030 exp[i] = i;
1031 return exp;
1032 }
1033
1034 @Test(dataProvider = "Spliterator.OfLong")
1035 public void testLongNullPointerException(String description, Collection<Long> exp, Supplier<Spliterator.OfLong> s) {
1036 assertThrowsNPE(() -> s.get().forEachRemaining((LongConsumer) null));
1037 assertThrowsNPE(() -> s.get().tryAdvance((LongConsumer) null));
1038 }
1039
1040 @Test(dataProvider = "Spliterator.OfLong")
1041 public void testLongForEach(String description, Collection<Long> exp, Supplier<Spliterator.OfLong> s) {
1042 testForEach(exp, s, longBoxingConsumer());
1043 }
1044
1045 @Test(dataProvider = "Spliterator.OfLong")
1046 public void testLongTryAdvance(String description, Collection<Long> exp, Supplier<Spliterator.OfLong> s) {
1047 testTryAdvance(exp, s, longBoxingConsumer());
1048 }
1049
1050 @Test(dataProvider = "Spliterator.OfLong")
1051 public void testLongMixedTryAdvanceForEach(String description, Collection<Long> exp, Supplier<Spliterator.OfLong> s) {
1052 testMixedTryAdvanceForEach(exp, s, longBoxingConsumer());
1053 }
1054
1055 @Test(dataProvider = "Spliterator.OfLong")
1056 public void testLongMixedTraverseAndSplit(String description, Collection<Long> exp, Supplier<Spliterator.OfLong> s) {
1057 testMixedTraverseAndSplit(exp, s, longBoxingConsumer());
1058 }
1059
1060 @Test(dataProvider = "Spliterator.OfLong")
1061 public void testLongSplitAfterFullTraversal(String description, Collection<Long> exp, Supplier<Spliterator.OfLong> s) {
1062 testSplitAfterFullTraversal(s, longBoxingConsumer());
1063 }
1064
1065 @Test(dataProvider = "Spliterator.OfLong")
1066 public void testLongSplitOnce(String description, Collection<Long> exp, Supplier<Spliterator.OfLong> s) {
1067 testSplitOnce(exp, s, longBoxingConsumer());
1068 }
1069
1070 @Test(dataProvider = "Spliterator.OfLong")
1071 public void testLongSplitSixDeep(String description, Collection<Long> exp, Supplier<Spliterator.OfLong> s) {
1072 testSplitSixDeep(exp, s, longBoxingConsumer());
1073 }
1074
1075 @Test(dataProvider = "Spliterator.OfLong")
1076 public void testLongSplitUntilNull(String description, Collection<Long> exp, Supplier<Spliterator.OfLong> s) {
1077 testSplitUntilNull(exp, s, longBoxingConsumer());
1078 }
1079
1080 //
1081
1082 private static class SpliteratorOfDoubleDataBuilder {
1083 List<Object[]> data;
1084
1085 List<Double> exp;
1086
1087 SpliteratorOfDoubleDataBuilder(List<Object[]> data, List<Double> exp) {
1088 this.data = data;
1089 this.exp = exp;
1090 }
1091
1092 void add(String description, List<Double> expected, Supplier<Spliterator.OfDouble> s) {
1093 description = joiner(description).toString();
1094 data.add(new Object[]{description, expected, s});
1095 }
1096
1097 void add(String description, Supplier<Spliterator.OfDouble> s) {
1098 add(description, exp, s);
1099 }
1100
1101 StringBuilder joiner(String description) {
1102 return new StringBuilder(description).
1103 append(" {").
1104 append("size=").append(exp.size()).
1105 append("}");
1106 }
1107 }
1108
1109 static Object[][] spliteratorOfDoubleDataProvider;
1110
1111 @DataProvider(name = "Spliterator.OfDouble")
1112 public static Object[][] spliteratorOfDoubleDataProvider() {
1113 if (spliteratorOfDoubleDataProvider != null) {
1114 return spliteratorOfDoubleDataProvider;
1115 }
1116
1117 List<Object[]> data = new ArrayList<>();
1118 for (int size : SIZES) {
1119 double exp[] = arrayDoubleRange(size);
1120 SpliteratorOfDoubleDataBuilder db = new SpliteratorOfDoubleDataBuilder(data, listDoubleRange(size));
1121
1122 db.add("Spliterators.spliterator(double[], ...)",
1123 () -> Spliterators.spliterator(exp, 0));
1124
1125 db.add("Arrays.spliterator(double[], ...)",
1126 () -> Arrays.spliterator(exp));
1127
1128 db.add("Spliterators.spliterator(PrimitiveIterator.OfDouble, ...)",
1129 () -> Spliterators.spliterator(Spliterators.iterator(Arrays.spliterator(exp)), exp.length, 0));
1130
1131 db.add("Spliterators.spliteratorUnknownSize(PrimitiveIterator.OfDouble, ...)",
1132 () -> Spliterators.spliteratorUnknownSize(Spliterators.iterator(Arrays.spliterator(exp)), 0));
1133
1134 class DoubleSpliteratorFromArray extends Spliterators.AbstractDoubleSpliterator {
1135 double[] a;
1136 int index = 0;
1137
1138 DoubleSpliteratorFromArray(double[] a) {
1139 super(a.length, Spliterator.SIZED);
1140 this.a = a;
1141 }
1142
1143 @Override
1144 public boolean tryAdvance(DoubleConsumer action) {
1145 if (action == null)
1146 throw new NullPointerException();
1147 if (index < a.length) {
1148 action.accept(a[index++]);
1149 return true;
1150 }
1151 else {
1152 return false;
1153 }
1154 }
1155 }
1156 db.add("new Spliterators.AbstractDoubleAdvancingSpliterator()",
1157 () -> new DoubleSpliteratorFromArray(exp));
1158 }
1159
1160 return spliteratorOfDoubleDataProvider = data.toArray(new Object[0][]);
1161 }
1162
1163 private static List<Double> listDoubleRange(int upTo) {
1164 List<Double> exp = new ArrayList<>();
1165 for (double i = 0; i < upTo; i++)
1166 exp.add(i);
1167 return Collections.unmodifiableList(exp);
1168 }
1169
1170 private static double[] arrayDoubleRange(int upTo) {
1171 double[] exp = new double[upTo];
1172 for (int i = 0; i < upTo; i++)
1173 exp[i] = i;
1174 return exp;
1175 }
1176
1177 @Test(dataProvider = "Spliterator.OfDouble")
1178 public void testDoubleNullPointerException(String description, Collection<Double> exp, Supplier<Spliterator.OfDouble> s) {
1179 assertThrowsNPE(() -> s.get().forEachRemaining((DoubleConsumer) null));
1180 assertThrowsNPE(() -> s.get().tryAdvance((DoubleConsumer) null));
1181 }
1182
1183 @Test(dataProvider = "Spliterator.OfDouble")
1184 public void testDoubleForEach(String description, Collection<Double> exp, Supplier<Spliterator.OfDouble> s) {
1185 testForEach(exp, s, doubleBoxingConsumer());
1186 }
1187
1188 @Test(dataProvider = "Spliterator.OfDouble")
1189 public void testDoubleTryAdvance(String description, Collection<Double> exp, Supplier<Spliterator.OfDouble> s) {
1190 testTryAdvance(exp, s, doubleBoxingConsumer());
1191 }
1192
1193 @Test(dataProvider = "Spliterator.OfDouble")
1194 public void testDoubleMixedTryAdvanceForEach(String description, Collection<Double> exp, Supplier<Spliterator.OfDouble> s) {
1195 testMixedTryAdvanceForEach(exp, s, doubleBoxingConsumer());
1196 }
1197
1198 @Test(dataProvider = "Spliterator.OfDouble")
1199 public void testDoubleMixedTraverseAndSplit(String description, Collection<Double> exp, Supplier<Spliterator.OfDouble> s) {
1200 testMixedTraverseAndSplit(exp, s, doubleBoxingConsumer());
1201 }
1202
1203 @Test(dataProvider = "Spliterator.OfDouble")
1204 public void testDoubleSplitAfterFullTraversal(String description, Collection<Double> exp, Supplier<Spliterator.OfDouble> s) {
1205 testSplitAfterFullTraversal(s, doubleBoxingConsumer());
1206 }
1207
1208 @Test(dataProvider = "Spliterator.OfDouble")
1209 public void testDoubleSplitOnce(String description, Collection<Double> exp, Supplier<Spliterator.OfDouble> s) {
1210 testSplitOnce(exp, s, doubleBoxingConsumer());
1211 }
1212
1213 @Test(dataProvider = "Spliterator.OfDouble")
1214 public void testDoubleSplitSixDeep(String description, Collection<Double> exp, Supplier<Spliterator.OfDouble> s) {
1215 testSplitSixDeep(exp, s, doubleBoxingConsumer());
1216 }
1217
1218 @Test(dataProvider = "Spliterator.OfDouble")
1219 public void testDoubleSplitUntilNull(String description, Collection<Double> exp, Supplier<Spliterator.OfDouble> s) {
1220 testSplitUntilNull(exp, s, doubleBoxingConsumer());
1221 }
1222
1223 }