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.29 by jsr166, Tue Nov 22 01:08:14 2016 UTC vs.
Revision 1.37 by jsr166, Tue Nov 29 05:23:31 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 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(iteratedForEachRemaining::add);
363          for (Spliterator s = c.spliterator();
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 Consumer checkSanity = x -> assertTrue(x == one || x == two);
566 +        final Consumer<Object[]> checkArraySanity = array -> {
567 +            // assertTrue(array.length <= 2); // duplicates are permitted
568 +            for (Object x : array) assertTrue(x == one || x == two);
569 +        };
570          final Object[] emptyArray =
571              (Object[]) java.lang.reflect.Array.newInstance(one.getClass(), 0);
572          final List<Future<?>> futures;
573          final Phaser threadsStarted = new Phaser(1); // register this thread
574          final Runnable[] frobbers = {
575 <            () -> c.forEach(x -> assertTrue(x == one || x == two)),
576 <            () -> c.stream().forEach(x -> assertTrue(x == one || x == two)),
575 >            () -> c.forEach(checkSanity),
576 >            () -> c.stream().forEach(checkSanity),
577 >            () -> c.parallelStream().forEach(checkSanity),
578              () -> c.spliterator().trySplit(),
579              () -> {
580                  Spliterator s = c.spliterator();
581 <                s.tryAdvance(x -> assertTrue(x == one || x == two));
581 >                s.tryAdvance(checkSanity);
582                  s.trySplit();
583              },
584              () -> {
585                  Spliterator s = c.spliterator();
586 <                do {} while (s.tryAdvance(x -> assertTrue(x == one || x == two)));
564 <            },
565 <            () -> {
566 <                for (Object x : c) assertTrue(x == one || x == two);
567 <            },
568 <            () -> {
569 <                for (Object x : c.toArray()) assertTrue(x == one || x == two);
570 <            },
571 <            () -> {
572 <                for (Object x : c.toArray(emptyArray)) assertTrue(x == one || x == two);
586 >                do {} while (s.tryAdvance(checkSanity));
587              },
588 +            () -> { for (Object x : c) checkSanity.accept(x); },
589 +            () -> checkArraySanity.accept(c.toArray()),
590 +            () -> checkArraySanity.accept(c.toArray(emptyArray)),
591              () -> {
592                  assertTrue(c.add(one));
593                  assertTrue(c.contains(one));
# Line 606 | Line 623 | public class Collection8Test extends JSR
623              assertNull(future.get(0L, MILLISECONDS));
624      }
625  
626 +    /**
627 +     * Spliterators are either IMMUTABLE or truly late-binding or, if
628 +     * concurrent, use the same "late-binding style" of returning
629 +     * elements added between creation and first use.
630 +     */
631 +    public void testLateBindingStyle() {
632 +        if (!testImplementationDetails) return;
633 +        if (impl.klazz() == ArrayList.class) return; // for jdk8
634 +        // Immutable (snapshot) spliterators are exempt
635 +        if (impl.emptyCollection().spliterator()
636 +            .hasCharacteristics(Spliterator.IMMUTABLE))
637 +            return;
638 +        final Object one = impl.makeElement(1);
639 +        {
640 +            final Collection c = impl.emptyCollection();
641 +            final Spliterator split = c.spliterator();
642 +            c.add(one);
643 +            assertTrue(split.tryAdvance(e -> { assertSame(e, one); }));
644 +            assertFalse(split.tryAdvance(e -> { throw new AssertionError(); }));
645 +            assertTrue(c.contains(one));
646 +        }
647 +        {
648 +            final AtomicLong count = new AtomicLong(0);
649 +            final Collection c = impl.emptyCollection();
650 +            final Spliterator split = c.spliterator();
651 +            c.add(one);
652 +            split.forEachRemaining(
653 +                e -> { assertSame(e, one); count.getAndIncrement(); });
654 +            assertEquals(1L, count.get());
655 +            assertFalse(split.tryAdvance(e -> { throw new AssertionError(); }));
656 +            assertTrue(c.contains(one));
657 +        }
658 +    }
659 +
660   //     public void testCollection8DebugFail() {
661   //         fail(impl.klazz().getSimpleName());
662   //     }

Diff Legend

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