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.49 by jsr166, Mon Mar 26 21:06:51 2018 UTC vs.
Revision 1.61 by dl, Tue Jan 26 13:33:05 2021 UTC

# Line 8 | Line 8
8   import static java.util.concurrent.TimeUnit.HOURS;
9   import static java.util.concurrent.TimeUnit.MILLISECONDS;
10  
11 + import java.util.ArrayDeque;
12   import java.util.ArrayList;
13   import java.util.Arrays;
14   import java.util.Collection;
# Line 92 | Line 93 | public class Collection8Test extends JSR
93  
94      void emptyMeansEmpty(Collection c) throws InterruptedException {
95          assertTrue(c.isEmpty());
96 <        assertEquals(0, c.size());
97 <        assertEquals("[]", c.toString());
96 >        mustEqual(0, c.size());
97 >        mustEqual("[]", c.toString());
98          if (c instanceof List<?>) {
99              List x = (List) c;
100 <            assertEquals(1, x.hashCode());
101 <            assertEquals(x, Collections.emptyList());
102 <            assertEquals(Collections.emptyList(), x);
103 <            assertEquals(-1, x.indexOf(impl.makeElement(86)));
104 <            assertEquals(-1, x.lastIndexOf(impl.makeElement(99)));
100 >            mustEqual(1, x.hashCode());
101 >            mustEqual(x, Collections.emptyList());
102 >            mustEqual(Collections.emptyList(), x);
103 >            mustEqual(-1, x.indexOf(impl.makeElement(86)));
104 >            mustEqual(-1, x.lastIndexOf(impl.makeElement(99)));
105              assertThrows(
106                  IndexOutOfBoundsException.class,
107                  () -> x.get(0),
108                  () -> x.set(0, impl.makeElement(42)));
109          }
110          else if (c instanceof Set<?>) {
111 <            assertEquals(0, c.hashCode());
112 <            assertEquals(c, Collections.emptySet());
113 <            assertEquals(Collections.emptySet(), c);
111 >            mustEqual(0, c.hashCode());
112 >            mustEqual(c, Collections.emptySet());
113 >            mustEqual(Collections.emptySet(), c);
114          }
115          {
116              Object[] a = c.toArray();
117 <            assertEquals(0, a.length);
117 >            mustEqual(0, a.length);
118              assertSame(Object[].class, a.getClass());
119          }
120          {
# Line 121 | Line 122 | public class Collection8Test extends JSR
122              assertSame(a, c.toArray(a));
123          }
124          {
125 <            Integer[] a = new Integer[0];
125 >            Item[] a = new Item[0];
126              assertSame(a, c.toArray(a));
127          }
128          {
129 <            Integer[] a = { 1, 2, 3};
129 >            Item[] a = { one, two, three};
130              assertSame(a, c.toArray(a));
131              assertNull(a[0]);
132 <            assertSame(2, a[1]);
133 <            assertSame(3, a[2]);
132 >            mustEqual(2, a[1]);
133 >            mustEqual(3, a[2]);
134          }
135          assertIteratorExhausted(c.iterator());
136          Consumer alwaysThrows = e -> { throw new AssertionError(); };
# Line 138 | Line 139 | public class Collection8Test extends JSR
139          c.spliterator().forEachRemaining(alwaysThrows);
140          assertFalse(c.spliterator().tryAdvance(alwaysThrows));
141          if (c.spliterator().hasCharacteristics(Spliterator.SIZED))
142 <            assertEquals(0, c.spliterator().estimateSize());
142 >            mustEqual(0, c.spliterator().estimateSize());
143          assertFalse(c.contains(bomb()));
144          assertFalse(c.remove(bomb()));
145          if (c instanceof Queue) {
# Line 170 | Line 171 | public class Collection8Test extends JSR
171  
172      public void testNullPointerExceptions() throws InterruptedException {
173          Collection c = impl.emptyCollection();
174 +        Collection nullCollection = null;
175          assertThrows(
176              NullPointerException.class,
177 <            () -> c.addAll(null),
178 <            () -> c.containsAll(null),
179 <            () -> c.retainAll(null),
180 <            () -> c.removeAll(null),
177 >            () -> c.addAll(nullCollection),
178 >            () -> c.containsAll(nullCollection),
179 >            () -> c.retainAll(nullCollection),
180 >            () -> c.removeAll(nullCollection),
181              () -> c.removeIf(null),
182              () -> c.forEach(null),
183              () -> c.iterator().forEachRemaining(null),
184              () -> c.spliterator().forEachRemaining(null),
185              () -> c.spliterator().tryAdvance(null),
186 <            () -> c.toArray(null));
186 >            () -> c.toArray((Object[])null));
187  
188          if (!impl.permitsNulls()) {
189              assertThrows(
# Line 209 | Line 211 | public class Collection8Test extends JSR
211              BlockingQueue q = (BlockingQueue) c;
212              assertThrows(
213                  NullPointerException.class,
214 <                () -> {
215 <                    try { q.offer(null, 1L, HOURS); }
214 <                    catch (InterruptedException ex) {
215 <                        throw new AssertionError(ex);
216 <                    }},
217 <                () -> {
218 <                    try { q.put(null); }
219 <                    catch (InterruptedException ex) {
220 <                        throw new AssertionError(ex);
221 <                    }});
214 >                () -> q.offer(null, 1L, HOURS),
215 >                () -> q.put(null));
216          }
217          if (c instanceof BlockingDeque) {
218              BlockingDeque q = (BlockingDeque) c;
219              assertThrows(
220                  NullPointerException.class,
221 <                () -> {
222 <                    try { q.offerFirst(null, 1L, HOURS); }
223 <                    catch (InterruptedException ex) {
224 <                        throw new AssertionError(ex);
231 <                    }},
232 <                () -> {
233 <                    try { q.offerLast(null, 1L, HOURS); }
234 <                    catch (InterruptedException ex) {
235 <                        throw new AssertionError(ex);
236 <                    }},
237 <                () -> {
238 <                    try { q.putFirst(null); }
239 <                    catch (InterruptedException ex) {
240 <                        throw new AssertionError(ex);
241 <                    }},
242 <                () -> {
243 <                    try { q.putLast(null); }
244 <                    catch (InterruptedException ex) {
245 <                        throw new AssertionError(ex);
246 <                    }});
221 >                () -> q.offerFirst(null, 1L, HOURS),
222 >                () -> q.offerLast(null, 1L, HOURS),
223 >                () -> q.putFirst(null),
224 >                () -> q.putLast(null));
225          }
226      }
227  
# Line 315 | Line 293 | public class Collection8Test extends JSR
293              try {
294                  boolean modified = c.removeIf(randomPredicate);
295                  assertNull(threwAt.get());
296 <                assertEquals(modified, accepts.size() > 0);
297 <                assertEquals(modified, rejects.size() != n);
298 <                assertEquals(accepts.size() + rejects.size(), n);
296 >                mustEqual(modified, accepts.size() > 0);
297 >                mustEqual(modified, rejects.size() != n);
298 >                mustEqual(accepts.size() + rejects.size(), n);
299                  if (ordered) {
300 <                    assertEquals(rejects,
300 >                    mustEqual(rejects,
301                                   Arrays.asList(c.toArray()));
302                  } else {
303 <                    assertEquals(new HashSet(rejects),
303 >                    mustEqual(new HashSet(rejects),
304                                   new HashSet(Arrays.asList(c.toArray())));
305                  }
306              } catch (ArithmeticException ok) {
# Line 346 | Line 324 | public class Collection8Test extends JSR
324              assertTrue(c.containsAll(survivors));
325              assertTrue(survivors.containsAll(rejects));
326              if (threwAt.get() == null) {
327 <                assertEquals(n - accepts.size(), c.size());
327 >                mustEqual(n - accepts.size(), c.size());
328                  for (Object x : accepts) assertFalse(c.contains(x));
329              } else {
330                  // Two acceptable behaviors: entire removeIf call is one
# Line 436 | Line 414 | public class Collection8Test extends JSR
414              if (rnd.nextBoolean()) assertTrue(it.hasNext());
415              it.next();
416          }
439 –        Consumer alwaysThrows = e -> { throw new AssertionError(); };
417          // TODO: many more removal methods
418          if (rnd.nextBoolean()) {
419              for (Iterator z = c.iterator(); z.hasNext(); ) {
# Line 510 | Line 487 | public class Collection8Test extends JSR
487          if (c instanceof List || c instanceof Deque)
488              assertTrue(ordered);
489          HashSet cset = new HashSet(c);
490 <        assertEquals(cset, new HashSet(parallelStreamForEached));
490 >        mustEqual(cset, new HashSet(parallelStreamForEached));
491          if (ordered) {
492 <            assertEquals(iterated, iteratedForEachRemaining);
493 <            assertEquals(iterated, tryAdvanced);
494 <            assertEquals(iterated, spliterated);
495 <            assertEquals(iterated, splitonced);
496 <            assertEquals(iterated, forEached);
497 <            assertEquals(iterated, streamForEached);
498 <            assertEquals(iterated, removeIfed);
492 >            mustEqual(iterated, iteratedForEachRemaining);
493 >            mustEqual(iterated, tryAdvanced);
494 >            mustEqual(iterated, spliterated);
495 >            mustEqual(iterated, splitonced);
496 >            mustEqual(iterated, forEached);
497 >            mustEqual(iterated, streamForEached);
498 >            mustEqual(iterated, removeIfed);
499          } else {
500 <            assertEquals(cset, new HashSet(iterated));
501 <            assertEquals(cset, new HashSet(iteratedForEachRemaining));
502 <            assertEquals(cset, new HashSet(tryAdvanced));
503 <            assertEquals(cset, new HashSet(spliterated));
504 <            assertEquals(cset, new HashSet(splitonced));
505 <            assertEquals(cset, new HashSet(forEached));
506 <            assertEquals(cset, new HashSet(streamForEached));
507 <            assertEquals(cset, new HashSet(removeIfed));
500 >            mustEqual(cset, new HashSet(iterated));
501 >            mustEqual(cset, new HashSet(iteratedForEachRemaining));
502 >            mustEqual(cset, new HashSet(tryAdvanced));
503 >            mustEqual(cset, new HashSet(spliterated));
504 >            mustEqual(cset, new HashSet(splitonced));
505 >            mustEqual(cset, new HashSet(forEached));
506 >            mustEqual(cset, new HashSet(streamForEached));
507 >            mustEqual(cset, new HashSet(removeIfed));
508          }
509          if (c instanceof Deque) {
510              Deque d = (Deque) c;
# Line 539 | Line 516 | public class Collection8Test extends JSR
516                  e -> descendingForEachRemaining.add(e));
517              Collections.reverse(descending);
518              Collections.reverse(descendingForEachRemaining);
519 <            assertEquals(iterated, descending);
520 <            assertEquals(iterated, descendingForEachRemaining);
519 >            mustEqual(iterated, descending);
520 >            mustEqual(iterated, descendingForEachRemaining);
521          }
522      }
523  
# Line 578 | Line 555 | public class Collection8Test extends JSR
555              r2 = ConcurrentModificationException.class;
556              assertFalse(impl.isConcurrent());
557          }
558 <        assertEquals(r1, r2);
558 >        mustEqual(r1, r2);
559      }
560  
561      /**
# Line 588 | Line 565 | public class Collection8Test extends JSR
565      public void testRemoveAfterForEachRemaining() {
566          Collection c = impl.emptyCollection();
567          ThreadLocalRandom rnd = ThreadLocalRandom.current();
568 +        ArrayList copy = new ArrayList();
569 +        boolean ordered = c.spliterator().hasCharacteristics(Spliterator.ORDERED);
570          testCollection: {
571              int n = 3 + rnd.nextInt(2);
572 <            for (int i = 0; i < n; i++) c.add(impl.makeElement(i));
572 >            for (int i = 0; i < n; i++) {
573 >                Object x = impl.makeElement(i);
574 >                c.add(x);
575 >                copy.add(x);
576 >            }
577              Iterator it = c.iterator();
578 <            assertTrue(it.hasNext());
579 <            assertEquals(impl.makeElement(0), it.next());
580 <            assertTrue(it.hasNext());
581 <            assertEquals(impl.makeElement(1), it.next());
582 <            it.forEachRemaining(e -> assertTrue(c.contains(e)));
578 >            if (ordered) {
579 >                if (rnd.nextBoolean()) assertTrue(it.hasNext());
580 >                mustEqual(impl.makeElement(0), it.next());
581 >                if (rnd.nextBoolean()) assertTrue(it.hasNext());
582 >                mustEqual(impl.makeElement(1), it.next());
583 >            } else {
584 >                if (rnd.nextBoolean()) assertTrue(it.hasNext());
585 >                assertTrue(copy.contains(it.next()));
586 >                if (rnd.nextBoolean()) assertTrue(it.hasNext());
587 >                assertTrue(copy.contains(it.next()));
588 >            }
589 >            if (rnd.nextBoolean()) assertTrue(it.hasNext());
590 >            it.forEachRemaining(
591 >                e -> {
592 >                    assertTrue(c.contains(e));
593 >                    assertTrue(copy.contains(e));});
594              if (testImplementationDetails) {
595                  if (c instanceof java.util.concurrent.ArrayBlockingQueue) {
596                      assertIteratorExhausted(it);
# Line 605 | Line 599 | public class Collection8Test extends JSR
599                      catch (UnsupportedOperationException ok) {
600                          break testCollection;
601                      }
602 <                    assertEquals(n - 1, c.size());
603 <                    for (int i = 0; i < n - 1; i++)
604 <                        assertTrue(c.contains(impl.makeElement(i)));
605 <                    assertFalse(c.contains(impl.makeElement(n - 1)));
602 >                    mustEqual(n - 1, c.size());
603 >                    if (ordered) {
604 >                        for (int i = 0; i < n - 1; i++)
605 >                            assertTrue(c.contains(impl.makeElement(i)));
606 >                        assertFalse(c.contains(impl.makeElement(n - 1)));
607 >                    }
608                  }
609              }
610          }
611          if (c instanceof Deque) {
612              Deque d = (Deque) impl.emptyCollection();
613 +            assertTrue(ordered);
614              int n = 3 + rnd.nextInt(2);
615              for (int i = 0; i < n; i++) d.add(impl.makeElement(i));
616              Iterator it = d.descendingIterator();
617              assertTrue(it.hasNext());
618 <            assertEquals(impl.makeElement(n - 1), it.next());
618 >            mustEqual(impl.makeElement(n - 1), it.next());
619              assertTrue(it.hasNext());
620 <            assertEquals(impl.makeElement(n - 2), it.next());
620 >            mustEqual(impl.makeElement(n - 2), it.next());
621              it.forEachRemaining(e -> assertTrue(c.contains(e)));
622              if (testImplementationDetails) {
623                  it.remove();
624 <                assertEquals(n - 1, d.size());
624 >                mustEqual(n - 1, d.size());
625                  for (int i = 1; i < n; i++)
626                      assertTrue(d.contains(impl.makeElement(i)));
627                  assertFalse(d.contains(impl.makeElement(0)));
# Line 637 | Line 634 | public class Collection8Test extends JSR
634       */
635      public void testStreamForEach() throws Throwable {
636          final Collection c = impl.emptyCollection();
640 –        final AtomicLong count = new AtomicLong(0L);
637          final Object x = impl.makeElement(1);
638          final Object y = impl.makeElement(2);
639          final ArrayList found = new ArrayList();
# Line 647 | Line 643 | public class Collection8Test extends JSR
643  
644          assertTrue(c.add(x));
645          c.stream().forEach(spy);
646 <        assertEquals(Collections.singletonList(x), found);
646 >        mustEqual(Collections.singletonList(x), found);
647          found.clear();
648  
649          assertTrue(c.add(y));
650          c.stream().forEach(spy);
651 <        assertEquals(2, found.size());
651 >        mustEqual(2, found.size());
652          assertTrue(found.contains(x));
653          assertTrue(found.contains(y));
654          found.clear();
# Line 695 | Line 691 | public class Collection8Test extends JSR
691       */
692      public void testForEach() throws Throwable {
693          final Collection c = impl.emptyCollection();
698 –        final AtomicLong count = new AtomicLong(0L);
694          final Object x = impl.makeElement(1);
695          final Object y = impl.makeElement(2);
696          final ArrayList found = new ArrayList();
# Line 705 | Line 700 | public class Collection8Test extends JSR
700  
701          assertTrue(c.add(x));
702          c.forEach(spy);
703 <        assertEquals(Collections.singletonList(x), found);
703 >        mustEqual(Collections.singletonList(x), found);
704          found.clear();
705  
706          assertTrue(c.add(y));
707          c.forEach(spy);
708 <        assertEquals(2, found.size());
708 >        mustEqual(2, found.size());
709          assertTrue(found.contains(x));
710          assertTrue(found.contains(y));
711          found.clear();
# Line 884 | Line 879 | public class Collection8Test extends JSR
879              c.add(one);
880              split.forEachRemaining(
881                  e -> { assertSame(e, one); count.getAndIncrement(); });
882 <            assertEquals(1L, count.get());
882 >            mustEqual(1L, count.get());
883              assertFalse(split.tryAdvance(e -> { throw new AssertionError(); }));
884              assertTrue(c.contains(one));
885          }
# Line 906 | Line 901 | public class Collection8Test extends JSR
901          }
902      }
903  
904 +    public void testCollectionCopies() throws Exception {
905 +        ThreadLocalRandom rnd = ThreadLocalRandom.current();
906 +        Collection c = impl.emptyCollection();
907 +        for (int n = rnd.nextInt(4); n--> 0; )
908 +            c.add(impl.makeElement(rnd.nextInt()));
909 +        mustEqual(c, c);
910 +        if (c instanceof List)
911 +            assertCollectionsEquals(c, new ArrayList(c));
912 +        else if (c instanceof Set)
913 +            assertCollectionsEquals(c, new HashSet(c));
914 +        else if (c instanceof Deque)
915 +            assertCollectionsEquivalent(c, new ArrayDeque(c));
916 +
917 +        Collection clone = cloneableClone(c);
918 +        if (clone != null) {
919 +            assertSame(c.getClass(), clone.getClass());
920 +            assertCollectionsEquivalent(c, clone);
921 +        }
922 +        try {
923 +            Collection serialClone = serialClonePossiblyFailing(c);
924 +            assertSame(c.getClass(), serialClone.getClass());
925 +            assertCollectionsEquivalent(c, serialClone);
926 +        } catch (java.io.NotSerializableException acceptable) {}
927 +    }
928 +
929 +    /**
930 +     * TODO: move out of limbo
931 +     * 8203662: remove increment of modCount from ArrayList and Vector replaceAll()
932 +     */
933 +    public void DISABLED_testReplaceAllIsNotStructuralModification() {
934 +        Collection c = impl.emptyCollection();
935 +        if (!(c instanceof List))
936 +            return;
937 +        List list = (List) c;
938 +        ThreadLocalRandom rnd = ThreadLocalRandom.current();
939 +        for (int n = rnd.nextInt(2, 10); n--> 0; )
940 +            list.add(impl.makeElement(rnd.nextInt()));
941 +        ArrayList copy = new ArrayList(list);
942 +        int size = list.size(), half = size / 2;
943 +        Iterator it = list.iterator();
944 +        for (int i = 0; i < half; i++)
945 +            mustEqual(it.next(), copy.get(i));
946 +        list.replaceAll(n -> n);
947 +        // ConcurrentModificationException must not be thrown here.
948 +        for (int i = half; i < size; i++)
949 +            mustEqual(it.next(), copy.get(i));
950 +    }
951 +
952   //     public void testCollection8DebugFail() {
953   //         fail(impl.klazz().getSimpleName());
954   //     }

Diff Legend

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