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.9 by jsr166, Thu Nov 3 16:53:13 2016 UTC vs.
Revision 1.16 by jsr166, Sun Nov 6 05:45:09 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 83 | Line 104 | public class Collection8Test extends JSR
104          assertFalse(c.spliterator().tryAdvance(alwaysThrows));
105          if (c.spliterator().hasCharacteristics(Spliterator.SIZED))
106              assertEquals(0, c.spliterator().estimateSize());
107 <        if (Queue.class.isAssignableFrom(impl.klazz())) {
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());
# Line 96 | Line 119 | public class Collection8Test extends JSR
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 119 | Line 153 | public class Collection8Test extends JSR
153                  NullPointerException.class,
154                  () -> c.add(null));
155          }
156 <        if (!impl.permitsNulls()
123 <            && 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()
130 <            && Deque.class.isAssignableFrom(impl.klazz())) {
162 >        if (!impl.permitsNulls() && c instanceof Deque) {
163              Deque d = (Deque) c;
164              assertThrows(
165                  NullPointerException.class,
# Line 138 | 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 146 | 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 223 | Line 295 | public class Collection8Test extends JSR
295          for (int i = 0; i < n; i++) c.add(impl.makeElement(i));
296          ArrayList iterated = new ArrayList();
297          ArrayList iteratedForEachRemaining = new ArrayList();
298 +        ArrayList tryAdvanced = new ArrayList();
299          ArrayList spliterated = new ArrayList();
300 <        ArrayList foreached = new ArrayList();
300 >        ArrayList forEached = new ArrayList();
301 >        ArrayList removeIfed = new ArrayList();
302          for (Object x : c) iterated.add(x);
303          c.iterator().forEachRemaining(e -> iteratedForEachRemaining.add(e));
304 +        for (Spliterator s = c.spliterator();
305 +             s.tryAdvance(e -> tryAdvanced.add(e)); ) {}
306          c.spliterator().forEachRemaining(e -> spliterated.add(e));
307 <        c.forEach(e -> foreached.add(e));
307 >        c.forEach(e -> forEached.add(e));
308 >        c.removeIf(e -> { removeIfed.add(e); return false; });
309          boolean ordered =
310              c.spliterator().hasCharacteristics(Spliterator.ORDERED);
311          if (c instanceof List || c instanceof Deque)
312              assertTrue(ordered);
313          if (ordered) {
314              assertEquals(iterated, iteratedForEachRemaining);
315 +            assertEquals(iterated, tryAdvanced);
316              assertEquals(iterated, spliterated);
317 <            assertEquals(iterated, foreached);
317 >            assertEquals(iterated, forEached);
318 >            assertEquals(iterated, removeIfed);
319          } else {
320              HashSet cset = new HashSet(c);
321              assertEquals(cset, new HashSet(iterated));
322              assertEquals(cset, new HashSet(iteratedForEachRemaining));
323 +            assertEquals(cset, new HashSet(tryAdvanced));
324              assertEquals(cset, new HashSet(spliterated));
325 <            assertEquals(cset, new HashSet(foreached));
325 >            assertEquals(cset, new HashSet(forEached));
326 >            assertEquals(cset, new HashSet(removeIfed));
327          }
328          if (c instanceof Deque) {
329              Deque d = (Deque) c;

Diff Legend

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