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.8 by jsr166, Thu Nov 3 15:31:25 2016 UTC vs.
Revision 1.17 by jsr166, Sun Nov 6 18:51:53 2016 UTC

# Line 5 | Line 5
5   * http://creativecommons.org/publicdomain/zero/1.0/
6   */
7  
8 + import static java.util.concurrent.TimeUnit.HOURS;
9   import static java.util.concurrent.TimeUnit.MILLISECONDS;
10  
11   import java.util.ArrayList;
# Line 17 | Line 18 | import java.util.List;
18   import java.util.NoSuchElementException;
19   import java.util.Queue;
20   import java.util.Spliterator;
21 + import java.util.concurrent.BlockingDeque;
22 + import java.util.concurrent.BlockingQueue;
23   import java.util.concurrent.CountDownLatch;
24   import java.util.concurrent.Executors;
25   import java.util.concurrent.ExecutorService;
# Line 49 | Line 52 | public class Collection8Test extends JSR
52                                        impl);
53      }
54  
55 +    Object bomb() {
56 +        return new Object() {
57 +                public boolean equals(Object x) { throw new AssertionError(); }
58 +                public int hashCode() { throw new AssertionError(); }
59 +            };
60 +    }
61 +
62      /** Checks properties of empty collections. */
63 <    public void testEmptyMeansEmpty() {
63 >    public void testEmptyMeansEmpty() throws InterruptedException {
64          Collection c = impl.emptyCollection();
65 +        emptyMeansEmpty(c);
66 +
67 +        if (c instanceof java.io.Serializable)
68 +            emptyMeansEmpty(serialClone(c));
69 +
70 +        Collection clone = cloneableClone(c);
71 +        if (clone != null)
72 +            emptyMeansEmpty(clone);
73 +    }
74 +
75 +    void emptyMeansEmpty(Collection c) throws InterruptedException {
76          assertTrue(c.isEmpty());
77          assertEquals(0, c.size());
78          assertEquals("[]", c.toString());
# Line 81 | Line 102 | public class Collection8Test extends JSR
102          c.iterator().forEachRemaining(alwaysThrows);
103          c.spliterator().forEachRemaining(alwaysThrows);
104          assertFalse(c.spliterator().tryAdvance(alwaysThrows));
105 <        if (Queue.class.isAssignableFrom(impl.klazz())) {
105 >        if (c.spliterator().hasCharacteristics(Spliterator.SIZED))
106 >            assertEquals(0, c.spliterator().estimateSize());
107 >        assertFalse(c.contains(bomb()));
108 >        assertFalse(c.remove(bomb()));
109 >        if (c instanceof Queue) {
110              Queue q = (Queue) c;
111              assertNull(q.peek());
112              assertNull(q.poll());
113          }
114 <        if (Deque.class.isAssignableFrom(impl.klazz())) {
114 >        if (c instanceof Deque) {
115              Deque d = (Deque) c;
116              assertNull(d.peekFirst());
117              assertNull(d.peekLast());
118              assertNull(d.pollFirst());
119              assertNull(d.pollLast());
120              assertIteratorExhausted(d.descendingIterator());
121 +            d.descendingIterator().forEachRemaining(alwaysThrows);
122 +            assertFalse(d.removeFirstOccurrence(bomb()));
123 +            assertFalse(d.removeLastOccurrence(bomb()));
124 +        }
125 +        if (c instanceof BlockingQueue) {
126 +            BlockingQueue q = (BlockingQueue) c;
127 +            assertNull(q.poll(0L, MILLISECONDS));
128 +        }
129 +        if (c instanceof BlockingDeque) {
130 +            BlockingDeque q = (BlockingDeque) c;
131 +            assertNull(q.pollFirst(0L, MILLISECONDS));
132 +            assertNull(q.pollLast(0L, MILLISECONDS));
133          }
134      }
135  
136 <    public void testNullPointerExceptions() {
136 >    public void testNullPointerExceptions() throws InterruptedException {
137          Collection c = impl.emptyCollection();
138          assertThrows(
139              NullPointerException.class,
# Line 116 | Line 153 | public class Collection8Test extends JSR
153                  NullPointerException.class,
154                  () -> c.add(null));
155          }
156 <        if (!impl.permitsNulls()
120 <            && Queue.class.isAssignableFrom(impl.klazz())) {
156 >        if (!impl.permitsNulls() && c instanceof Queue) {
157              Queue q = (Queue) c;
158              assertThrows(
159                  NullPointerException.class,
160                  () -> q.offer(null));
161          }
162 <        if (!impl.permitsNulls()
127 <            && Deque.class.isAssignableFrom(impl.klazz())) {
162 >        if (!impl.permitsNulls() && c instanceof Deque) {
163              Deque d = (Deque) c;
164              assertThrows(
165                  NullPointerException.class,
# Line 135 | Line 170 | public class Collection8Test extends JSR
170                  () -> d.push(null),
171                  () -> d.descendingIterator().forEachRemaining(null));
172          }
173 +        if (c instanceof BlockingQueue) {
174 +            BlockingQueue q = (BlockingQueue) c;
175 +            assertThrows(
176 +                NullPointerException.class,
177 +                () -> {
178 +                    try { q.offer(null, 1L, HOURS); }
179 +                    catch (InterruptedException ex) {
180 +                        throw new AssertionError(ex);
181 +                    }},
182 +                () -> {
183 +                    try { q.put(null); }
184 +                    catch (InterruptedException ex) {
185 +                        throw new AssertionError(ex);
186 +                    }});
187 +        }
188 +        if (c instanceof BlockingDeque) {
189 +            BlockingDeque q = (BlockingDeque) c;
190 +            assertThrows(
191 +                NullPointerException.class,
192 +                () -> {
193 +                    try { q.offerFirst(null, 1L, HOURS); }
194 +                    catch (InterruptedException ex) {
195 +                        throw new AssertionError(ex);
196 +                    }},
197 +                () -> {
198 +                    try { q.offerLast(null, 1L, HOURS); }
199 +                    catch (InterruptedException ex) {
200 +                        throw new AssertionError(ex);
201 +                    }},
202 +                () -> {
203 +                    try { q.putFirst(null); }
204 +                    catch (InterruptedException ex) {
205 +                        throw new AssertionError(ex);
206 +                    }},
207 +                () -> {
208 +                    try { q.putLast(null); }
209 +                    catch (InterruptedException ex) {
210 +                        throw new AssertionError(ex);
211 +                    }});
212 +        }
213      }
214  
215      public void testNoSuchElementExceptions() {
# Line 143 | Line 218 | public class Collection8Test extends JSR
218              NoSuchElementException.class,
219              () -> c.iterator().next());
220  
221 <        if (Queue.class.isAssignableFrom(impl.klazz())) {
221 >        if (c instanceof Queue) {
222              Queue q = (Queue) c;
223              assertThrows(
224                  NoSuchElementException.class,
225                  () -> q.element(),
226                  () -> q.remove());
227          }
228 <        if (Deque.class.isAssignableFrom(impl.klazz())) {
228 >        if (c instanceof Deque) {
229              Deque d = (Deque) c;
230              assertThrows(
231                  NoSuchElementException.class,
# Line 182 | Line 257 | public class Collection8Test extends JSR
257              }
258          };
259          try {
185 –            assertFalse(survivors.contains(null));
260              try {
261                  boolean modified = c.removeIf(randomPredicate);
262                  if (!modified) {
# Line 220 | Line 294 | public class Collection8Test extends JSR
294          for (int i = 0; i < n; i++) c.add(impl.makeElement(i));
295          ArrayList iterated = new ArrayList();
296          ArrayList iteratedForEachRemaining = new ArrayList();
297 +        ArrayList tryAdvanced = new ArrayList();
298          ArrayList spliterated = new ArrayList();
299 <        ArrayList foreached = new ArrayList();
299 >        ArrayList forEached = new ArrayList();
300 >        ArrayList removeIfed = new ArrayList();
301          for (Object x : c) iterated.add(x);
302          c.iterator().forEachRemaining(e -> iteratedForEachRemaining.add(e));
303 +        for (Spliterator s = c.spliterator();
304 +             s.tryAdvance(e -> tryAdvanced.add(e)); ) {}
305          c.spliterator().forEachRemaining(e -> spliterated.add(e));
306 <        c.forEach(e -> foreached.add(e));
306 >        c.forEach(e -> forEached.add(e));
307 >        c.removeIf(e -> { removeIfed.add(e); return false; });
308          boolean ordered =
309              c.spliterator().hasCharacteristics(Spliterator.ORDERED);
310          if (c instanceof List || c instanceof Deque)
311              assertTrue(ordered);
312          if (ordered) {
313              assertEquals(iterated, iteratedForEachRemaining);
314 +            assertEquals(iterated, tryAdvanced);
315              assertEquals(iterated, spliterated);
316 <            assertEquals(iterated, foreached);
316 >            assertEquals(iterated, forEached);
317 >            assertEquals(iterated, removeIfed);
318          } else {
319              HashSet cset = new HashSet(c);
320              assertEquals(cset, new HashSet(iterated));
321              assertEquals(cset, new HashSet(iteratedForEachRemaining));
322 +            assertEquals(cset, new HashSet(tryAdvanced));
323              assertEquals(cset, new HashSet(spliterated));
324 <            assertEquals(cset, new HashSet(foreached));
324 >            assertEquals(cset, new HashSet(forEached));
325 >            assertEquals(cset, new HashSet(removeIfed));
326          }
327          if (c instanceof Deque) {
328              Deque d = (Deque) c;

Diff Legend

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