ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/Collection8Test.java
(Generate patch)

Comparing jsr166/src/test/tck/Collection8Test.java (file contents):
Revision 1.26 by jsr166, Tue Nov 15 22:59:09 2016 UTC vs.
Revision 1.34 by jsr166, Mon Nov 28 17:44:26 2016 UTC

# Line 21 | Line 21 | import java.util.Queue;
21   import java.util.Spliterator;
22   import java.util.concurrent.BlockingDeque;
23   import java.util.concurrent.BlockingQueue;
24 + import java.util.concurrent.ConcurrentLinkedQueue;
25   import java.util.concurrent.CountDownLatch;
26   import java.util.concurrent.Executors;
27   import java.util.concurrent.ExecutorService;
# Line 304 | Line 305 | public class Collection8Test extends JSR
305              switch (rnd.nextInt(4)) {
306              case 0: survivors.addAll(c); break;
307              case 1: survivors.addAll(Arrays.asList(c.toArray())); break;
308 <            case 2: c.forEach(e -> survivors.add(e)); break;
308 >            case 2: c.forEach(survivors::add); break;
309              case 3: for (Object e : c) survivors.add(e); break;
310              }
311              assertTrue(orig.containsAll(accepts));
# Line 352 | Line 353 | public class Collection8Test extends JSR
353          ArrayList iteratedForEachRemaining = new ArrayList();
354          ArrayList tryAdvanced = new ArrayList();
355          ArrayList spliterated = new ArrayList();
356 +        ArrayList splitonced = new ArrayList();
357          ArrayList forEached = new ArrayList();
358 +        ArrayList streamForEached = new ArrayList();
359 +        ConcurrentLinkedQueue parallelStreamForEached = new ConcurrentLinkedQueue();
360          ArrayList removeIfed = new ArrayList();
361          for (Object x : c) iterated.add(x);
362 <        c.iterator().forEachRemaining(e -> iteratedForEachRemaining.add(e));
362 >        c.iterator().forEachRemaining(iteratedForEachRemaining::add);
363          for (Spliterator s = c.spliterator();
364 <             s.tryAdvance(e -> tryAdvanced.add(e)); ) {}
365 <        c.spliterator().forEachRemaining(e -> spliterated.add(e));
366 <        c.forEach(e -> forEached.add(e));
364 >             s.tryAdvance(tryAdvanced::add); ) {}
365 >        c.spliterator().forEachRemaining(spliterated::add);
366 >        {                       // trySplit returns "strict prefix"
367 >            Spliterator s1 = c.spliterator(), s2 = s1.trySplit();
368 >            if (s2 != null) s2.forEachRemaining(splitonced::add);
369 >            s1.forEachRemaining(splitonced::add);
370 >        }
371 >        c.forEach(forEached::add);
372 >        c.stream().forEach(streamForEached::add);
373 >        c.parallelStream().forEach(parallelStreamForEached::add);
374          c.removeIf(e -> { removeIfed.add(e); return false; });
375          boolean ordered =
376              c.spliterator().hasCharacteristics(Spliterator.ORDERED);
377          if (c instanceof List || c instanceof Deque)
378              assertTrue(ordered);
379 +        HashSet cset = new HashSet(c);
380 +        assertEquals(cset, new HashSet(parallelStreamForEached));
381          if (ordered) {
382              assertEquals(iterated, iteratedForEachRemaining);
383              assertEquals(iterated, tryAdvanced);
384              assertEquals(iterated, spliterated);
385 +            assertEquals(iterated, splitonced);
386              assertEquals(iterated, forEached);
387 +            assertEquals(iterated, streamForEached);
388              assertEquals(iterated, removeIfed);
389          } else {
375 –            HashSet cset = new HashSet(c);
390              assertEquals(cset, new HashSet(iterated));
391              assertEquals(cset, new HashSet(iteratedForEachRemaining));
392              assertEquals(cset, new HashSet(tryAdvanced));
393              assertEquals(cset, new HashSet(spliterated));
394 +            assertEquals(cset, new HashSet(splitonced));
395              assertEquals(cset, new HashSet(forEached));
396 +            assertEquals(cset, new HashSet(streamForEached));
397              assertEquals(cset, new HashSet(removeIfed));
398          }
399          if (c instanceof Deque) {
# Line 541 | Line 557 | public class Collection8Test extends JSR
557          if (!impl.isConcurrent()) return;
558          final ThreadLocalRandom rnd = ThreadLocalRandom.current();
559          final Collection c = impl.emptyCollection();
560 <        final long testDurationMillis = timeoutMillis();
560 >        final long testDurationMillis
561 >            = expensiveTests ? LONG_DELAY_MS : timeoutMillis();
562          final AtomicBoolean done = new AtomicBoolean(false);
563          final Object one = impl.makeElement(1);
564          final Object two = impl.makeElement(2);
565 +        final Object[] emptyArray =
566 +            (Object[]) java.lang.reflect.Array.newInstance(one.getClass(), 0);
567          final List<Future<?>> futures;
568          final Phaser threadsStarted = new Phaser(1); // register this thread
569 <        final List<Runnable> tasks = List.<Runnable>of(
570 <            () -> c.forEach(x -> assertTrue(x == one || x == two)),
571 <            () -> c.stream().forEach(x -> assertTrue(x == one || x == two)),
569 >        final Consumer checkSanity = x -> assertTrue(x == one || x == two);
570 >        final Runnable[] frobbers = {
571 >            () -> c.forEach(checkSanity),
572 >            () -> c.stream().forEach(checkSanity),
573 >            () -> c.parallelStream().forEach(checkSanity),
574              () -> c.spliterator().trySplit(),
575              () -> {
576                  Spliterator s = c.spliterator();
577 <                s.tryAdvance(x -> assertTrue(x == one || x == two));
577 >                s.tryAdvance(checkSanity);
578                  s.trySplit();
579              },
580              () -> {
581                  Spliterator s = c.spliterator();
582 <                do {} while (s.tryAdvance(x -> assertTrue(x == one || x == two)));
562 <            },
563 <            () -> {
564 <                for (Object x : c) assertTrue(x == one || x == two);
582 >                do {} while (s.tryAdvance(checkSanity));
583              },
584 +            () -> { for (Object x : c) checkSanity.accept(x); },
585 +            () -> { for (Object x : c.toArray()) checkSanity.accept(x); },
586 +            () -> { for (Object x : c.toArray(emptyArray)) checkSanity.accept(x); },
587              () -> {
588                  assertTrue(c.add(one));
589                  assertTrue(c.contains(one));
# Line 574 | Line 595 | public class Collection8Test extends JSR
595                  assertTrue(c.contains(two));
596                  assertTrue(c.remove(two));
597                  assertFalse(c.contains(two));
598 <            })
599 <            .stream()
598 >            },
599 >        };
600 >        final List<Runnable> tasks =
601 >            Arrays.stream(frobbers)
602              .filter(task -> rnd.nextBoolean()) // random subset
603              .map(task -> (Runnable) () -> {
604                       threadsStarted.arriveAndAwaitAdvance();
# Line 587 | Line 610 | public class Collection8Test extends JSR
610          try (PoolCleaner cleaner = cleaner(pool, done)) {
611              threadsStarted.bulkRegister(tasks.size());
612              futures = tasks.stream()
613 <                .map(task -> pool.submit(task))
613 >                .map(pool::submit)
614                  .collect(Collectors.toList());
615              threadsStarted.arriveAndDeregister();
616              Thread.sleep(testDurationMillis);
# Line 596 | Line 619 | public class Collection8Test extends JSR
619              assertNull(future.get(0L, MILLISECONDS));
620      }
621  
622 +    /**
623 +     * Spliterators are either IMMUTABLE or truly late-binding or, if
624 +     * concurrent, use the same "late-binding style" of returning
625 +     * elements added between creation and first use.
626 +     */
627 +    public void testLateBindingStyle() {
628 +        if (!testImplementationDetails) return;
629 +        if (impl.klazz() == ArrayList.class) return; // for jdk8
630 +        // Immutable (snapshot) spliterators are exempt
631 +        if (impl.emptyCollection().spliterator()
632 +            .hasCharacteristics(Spliterator.IMMUTABLE))
633 +            return;
634 +        final Object one = impl.makeElement(1);
635 +        {
636 +            final Collection c = impl.emptyCollection();
637 +            final Spliterator split = c.spliterator();
638 +            c.add(one);
639 +            assertTrue(split.tryAdvance(e -> { assertSame(e, one); }));
640 +            assertFalse(split.tryAdvance(e -> { throw new AssertionError(); }));
641 +            assertTrue(c.contains(one));
642 +        }
643 +        {
644 +            final AtomicLong count = new AtomicLong(0);
645 +            final Collection c = impl.emptyCollection();
646 +            final Spliterator split = c.spliterator();
647 +            c.add(one);
648 +            split.forEachRemaining(
649 +                e -> { assertSame(e, one); count.getAndIncrement(); });
650 +            assertEquals(1L, count.get());
651 +            assertFalse(split.tryAdvance(e -> { throw new AssertionError(); }));
652 +            assertTrue(c.contains(one));
653 +        }
654 +    }
655 +
656   //     public void testCollection8DebugFail() {
657   //         fail(impl.klazz().getSimpleName());
658   //     }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines