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