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.45 by jsr166, Mon Dec 26 19:54:46 2016 UTC vs.
Revision 1.53 by jsr166, Sun May 6 22:09:42 2018 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 19 | Line 20 | import java.util.Iterator;
20   import java.util.List;
21   import java.util.NoSuchElementException;
22   import java.util.Queue;
23 + import java.util.Set;
24   import java.util.Spliterator;
25   import java.util.concurrent.BlockingDeque;
26   import java.util.concurrent.BlockingQueue;
# Line 59 | Line 61 | public class Collection8Test extends JSR
61  
62      Object bomb() {
63          return new Object() {
64 <                public boolean equals(Object x) { throw new AssertionError(); }
65 <                public int hashCode() { throw new AssertionError(); }
66 <            };
64 >            @Override public boolean equals(Object x) { throw new AssertionError(); }
65 >            @Override public int hashCode() { throw new AssertionError(); }
66 >            @Override public String toString() { throw new AssertionError(); }
67 >        };
68      }
69  
70      /** Checks properties of empty collections. */
# Line 92 | Line 95 | public class Collection8Test extends JSR
95          assertTrue(c.isEmpty());
96          assertEquals(0, c.size());
97          assertEquals("[]", 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)));
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);
114 +        }
115          {
116              Object[] a = c.toArray();
117              assertEquals(0, a.length);
# Line 140 | Line 160 | public class Collection8Test extends JSR
160          }
161          if (c instanceof BlockingQueue) {
162              BlockingQueue q = (BlockingQueue) c;
163 <            assertNull(q.poll(0L, MILLISECONDS));
163 >            assertNull(q.poll(randomExpiredTimeout(), randomTimeUnit()));
164          }
165          if (c instanceof BlockingDeque) {
166              BlockingDeque q = (BlockingDeque) c;
167 <            assertNull(q.pollFirst(0L, MILLISECONDS));
168 <            assertNull(q.pollLast(0L, MILLISECONDS));
167 >            assertNull(q.pollFirst(randomExpiredTimeout(), randomTimeUnit()));
168 >            assertNull(q.pollLast(randomExpiredTimeout(), randomTimeUnit()));
169          }
170      }
171  
# Line 252 | Line 272 | public class Collection8Test extends JSR
272                  () -> d.pop(),
273                  () -> d.descendingIterator().next());
274          }
275 +        if (c instanceof List) {
276 +            List x = (List) c;
277 +            assertThrows(
278 +                NoSuchElementException.class,
279 +                () -> x.iterator().next(),
280 +                () -> x.listIterator().next(),
281 +                () -> x.listIterator(0).next(),
282 +                () -> x.listIterator().previous(),
283 +                () -> x.listIterator(0).previous());
284 +        }
285      }
286  
287      public void testRemoveIf() {
# Line 559 | Line 589 | public class Collection8Test extends JSR
589      public void testRemoveAfterForEachRemaining() {
590          Collection c = impl.emptyCollection();
591          ThreadLocalRandom rnd = ThreadLocalRandom.current();
592 +        ArrayList copy = new ArrayList();
593 +        boolean ordered = c.spliterator().hasCharacteristics(Spliterator.ORDERED);
594          testCollection: {
595              int n = 3 + rnd.nextInt(2);
596 <            for (int i = 0; i < n; i++) c.add(impl.makeElement(i));
596 >            for (int i = 0; i < n; i++) {
597 >                Object x = impl.makeElement(i);
598 >                c.add(x);
599 >                copy.add(x);
600 >            }
601              Iterator it = c.iterator();
602 <            assertTrue(it.hasNext());
603 <            assertEquals(impl.makeElement(0), it.next());
604 <            assertTrue(it.hasNext());
605 <            assertEquals(impl.makeElement(1), it.next());
606 <            it.forEachRemaining(e -> assertTrue(c.contains(e)));
602 >            if (ordered) {
603 >                if (rnd.nextBoolean()) assertTrue(it.hasNext());
604 >                assertEquals(impl.makeElement(0), it.next());
605 >                if (rnd.nextBoolean()) assertTrue(it.hasNext());
606 >                assertEquals(impl.makeElement(1), it.next());
607 >            } else {
608 >                if (rnd.nextBoolean()) assertTrue(it.hasNext());
609 >                assertTrue(copy.contains(it.next()));
610 >                if (rnd.nextBoolean()) assertTrue(it.hasNext());
611 >                assertTrue(copy.contains(it.next()));
612 >            }
613 >            it.forEachRemaining(
614 >                e -> {
615 >                    assertTrue(c.contains(e));
616 >                    assertTrue(copy.contains(e));});
617              if (testImplementationDetails) {
618                  if (c instanceof java.util.concurrent.ArrayBlockingQueue) {
619                      assertIteratorExhausted(it);
# Line 577 | Line 623 | public class Collection8Test extends JSR
623                          break testCollection;
624                      }
625                      assertEquals(n - 1, c.size());
626 <                    for (int i = 0; i < n - 1; i++)
627 <                        assertTrue(c.contains(impl.makeElement(i)));
628 <                    assertFalse(c.contains(impl.makeElement(n - 1)));
626 >                    if (ordered) {
627 >                        for (int i = 0; i < n - 1; i++)
628 >                            assertTrue(c.contains(impl.makeElement(i)));
629 >                        assertFalse(c.contains(impl.makeElement(n - 1)));
630 >                    }
631                  }
632              }
633          }
634          if (c instanceof Deque) {
635              Deque d = (Deque) impl.emptyCollection();
636 +            assertTrue(ordered);
637              int n = 3 + rnd.nextInt(2);
638              for (int i = 0; i < n; i++) d.add(impl.makeElement(i));
639              Iterator it = d.descendingIterator();
# Line 877 | Line 926 | public class Collection8Test extends JSR
926          }
927      }
928  
929 +    public void testCollectionCopies() throws Exception {
930 +        ThreadLocalRandom rnd = ThreadLocalRandom.current();
931 +        Collection c = impl.emptyCollection();
932 +        for (int n = rnd.nextInt(4); n--> 0; )
933 +            c.add(impl.makeElement(rnd.nextInt()));
934 +        assertEquals(c, c);
935 +        if (c instanceof List)
936 +            assertCollectionsEquals(c, new ArrayList(c));
937 +        else if (c instanceof Set)
938 +            assertCollectionsEquals(c, new HashSet(c));
939 +        else if (c instanceof Deque)
940 +            assertCollectionsEquivalent(c, new ArrayDeque(c));
941 +
942 +        Collection clone = cloneableClone(c);
943 +        if (clone != null) {
944 +            assertSame(c.getClass(), clone.getClass());
945 +            assertCollectionsEquivalent(c, clone);
946 +        }
947 +        try {
948 +            Collection serialClone = serialClonePossiblyFailing(c);
949 +            assertSame(c.getClass(), serialClone.getClass());
950 +            assertCollectionsEquivalent(c, serialClone);
951 +        } catch (java.io.NotSerializableException acceptable) {}
952 +    }
953 +
954 +    public void testReplaceAllIsNotStructuralModification() {
955 +        Collection c = impl.emptyCollection();
956 +        if (!(c instanceof List))
957 +            return;
958 +        List list = (List) c;
959 +        ThreadLocalRandom rnd = ThreadLocalRandom.current();
960 +        for (int n = rnd.nextInt(2, 10); n--> 0; )
961 +            list.add(impl.makeElement(rnd.nextInt()));
962 +        ArrayList copy = new ArrayList(list);
963 +        int size = list.size(), half = size / 2;
964 +        Iterator it = list.iterator();
965 +        for (int i = 0; i < half; i++)
966 +            assertEquals(it.next(), copy.get(i));
967 +        list.replaceAll(n -> n);
968 +        // ConcurrentModificationException must not be thrown here.
969 +        for (int i = half; i < size; i++)
970 +            assertEquals(it.next(), copy.get(i));
971 +    }
972 +
973   //     public void testCollection8DebugFail() {
974   //         fail(impl.klazz().getSimpleName());
975   //     }

Diff Legend

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