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