ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/LinkedTransferQueueTest.java
(Generate patch)

Comparing jsr166/src/test/tck/LinkedTransferQueueTest.java (file contents):
Revision 1.14 by jsr166, Sat Aug 15 03:20:36 2009 UTC vs.
Revision 1.20 by jsr166, Sun Nov 22 18:57:17 2009 UTC

# Line 44 | Line 44 | public class LinkedTransferQueueTest ext
44          try {
45              q.element();
46              shouldThrow();
47 <        } catch (NoSuchElementException success) {
48 <        }
47 >        } catch (NoSuchElementException success) {}
48          try {
49              q.iterator().next();
50              shouldThrow();
51 <        } catch (NoSuchElementException success) {
53 <        }
51 >        } catch (NoSuchElementException success) {}
52          try {
53              q.remove();
54              shouldThrow();
55 <        } catch (NoSuchElementException success) {
58 <        }
55 >        } catch (NoSuchElementException success) {}
56      }
57  
58      /**
# Line 75 | Line 72 | public class LinkedTransferQueueTest ext
72          try {
73              new LinkedTransferQueue(null);
74              shouldThrow();
75 <        } catch (NullPointerException success) {
79 <        }
75 >        } catch (NullPointerException success) {}
76      }
77  
78      /**
# Line 88 | Line 84 | public class LinkedTransferQueueTest ext
84              Integer[] ints = new Integer[SIZE];
85              new LinkedTransferQueue(Arrays.asList(ints));
86              shouldThrow();
87 <        } catch (NullPointerException success) {
92 <        }
87 >        } catch (NullPointerException success) {}
88      }
89  
90      /**
# Line 104 | Line 99 | public class LinkedTransferQueueTest ext
99              }
100              new LinkedTransferQueue(Arrays.asList(ints));
101              shouldThrow();
102 <        } catch (NullPointerException success) {
108 <        }
102 >        } catch (NullPointerException success) {}
103      }
104  
105      /**
# Line 157 | Line 151 | public class LinkedTransferQueueTest ext
151              LinkedTransferQueue q = new LinkedTransferQueue();
152              q.offer(null);
153              shouldThrow();
154 <        } catch (NullPointerException success) {
161 <        }
154 >        } catch (NullPointerException success) {}
155      }
156  
157      /**
# Line 169 | Line 162 | public class LinkedTransferQueueTest ext
162              LinkedTransferQueue q = new LinkedTransferQueue();
163              q.add(null);
164              shouldThrow();
165 <        } catch (NullPointerException success) {
173 <        }
165 >        } catch (NullPointerException success) {}
166      }
167  
168      /**
# Line 181 | Line 173 | public class LinkedTransferQueueTest ext
173              LinkedTransferQueue q = new LinkedTransferQueue();
174              q.addAll(null);
175              shouldThrow();
176 <        } catch (NullPointerException success) {
185 <        }
176 >        } catch (NullPointerException success) {}
177      }
178  
179      /**
# Line 193 | Line 184 | public class LinkedTransferQueueTest ext
184              LinkedTransferQueue q = populatedQueue(SIZE);
185              q.addAll(q);
186              shouldThrow();
187 <        } catch (IllegalArgumentException success) {
197 <        }
187 >        } catch (IllegalArgumentException success) {}
188      }
189  
190      /**
# Line 206 | Line 196 | public class LinkedTransferQueueTest ext
196              Integer[] ints = new Integer[SIZE];
197              q.addAll(Arrays.asList(ints));
198              shouldThrow();
199 <        } catch (NullPointerException success) {
210 <        }
199 >        } catch (NullPointerException success) {}
200      }
201  
202      /**
# Line 223 | Line 212 | public class LinkedTransferQueueTest ext
212              }
213              q.addAll(Arrays.asList(ints));
214              shouldThrow();
215 <        } catch (NullPointerException success) {
227 <        }
215 >        } catch (NullPointerException success) {}
216      }
217  
218      /**
# Line 296 | Line 284 | public class LinkedTransferQueueTest ext
284       */
285      public void testBlockingTake() throws InterruptedException {
286          final LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
287 <        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
288 <            void realRun() throws InterruptedException {
287 >        Thread t = new Thread(new CheckedRunnable() {
288 >            public void realRun() throws InterruptedException {
289                  for (int i = 0; i < SIZE; ++i) {
290 <                    threadAssertEquals(i, (int) q.take());
290 >                    assertEquals(i, (int) q.take());
291                  }
292 <                q.take();
292 >                try {
293 >                    q.take();
294 >                    shouldThrow();
295 >                } catch (InterruptedException success) {}
296              }});
297 <        Thread.sleep(SMALL_DELAY_MS);
297 >
298 >        t.start();
299 >        Thread.sleep(SHORT_DELAY_MS);
300          t.interrupt();
301          t.join();
302          checkEmpty(q);
# Line 354 | Line 347 | public class LinkedTransferQueueTest ext
347       */
348      public void testInterruptedTimedPoll() throws InterruptedException {
349          final LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
350 <        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
350 >        Thread t = newStartedThread(new CheckedRunnable() {
351              void realRun() throws InterruptedException {
352                  for (int i = 0; i < SIZE; ++i) {
353                      long t0 = System.nanoTime();
# Line 363 | Line 356 | public class LinkedTransferQueueTest ext
356                      long millisElapsed = (System.nanoTime() - t0)/(1024 * 1024);
357                      assertTrue(millisElapsed < SMALL_DELAY_MS);
358                  }
359 <                q.poll(LONG_DELAY_MS, MILLISECONDS);
359 >                try {
360 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
361 >                    shouldThrow();
362 >                } catch (InterruptedException success) {}
363              }});
364 +
365          Thread.sleep(SMALL_DELAY_MS);
366          t.interrupt();
367          t.join();
# Line 377 | Line 374 | public class LinkedTransferQueueTest ext
374       */
375      public void testTimedPollWithOffer() throws InterruptedException {
376          final LinkedTransferQueue q = new LinkedTransferQueue();
377 <        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
377 >        Thread t = new Thread(new CheckedRunnable() {
378              void realRun() throws InterruptedException {
379 <                threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
380 <                q.poll(LONG_DELAY_MS, MILLISECONDS);
381 <                q.poll(LONG_DELAY_MS, MILLISECONDS);
379 >                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
380 >                assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
381 >                try {
382 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
383 >                    shouldThrow();
384 >                } catch (InterruptedException success) {}
385              }});
386 +
387 +        t.start();
388          Thread.sleep(SMALL_DELAY_MS);
389          assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
390          t.interrupt();
# Line 416 | Line 418 | public class LinkedTransferQueueTest ext
418          try {
419              q.element();
420              shouldThrow();
421 <        } catch (NoSuchElementException success) {
420 <        }
421 >        } catch (NoSuchElementException success) {}
422          checkEmpty(q);
423      }
424  
# Line 432 | Line 433 | public class LinkedTransferQueueTest ext
433          try {
434              q.remove();
435              shouldThrow();
436 <        } catch (NoSuchElementException success) {
436 <        }
436 >        } catch (NoSuchElementException success) {}
437          checkEmpty(q);
438      }
439  
# Line 570 | Line 570 | public class LinkedTransferQueueTest ext
570       * toArray(null) throws NullPointerException
571       */
572      public void testToArray_BadArg() {
573 +        LinkedTransferQueue q = populatedQueue(SIZE);
574          try {
574 –            LinkedTransferQueue q = populatedQueue(SIZE);
575              Object o[] = q.toArray(null);
576              shouldThrow();
577 <        } catch (NullPointerException success) {
578 <        }
577 >        } catch (NullPointerException success) {}
578      }
579  
580      /**
581       * toArray(incompatible array type) throws CCE
582       */
583      public void testToArray1_BadArg() {
584 +        LinkedTransferQueue q = populatedQueue(SIZE);
585          try {
586 –            LinkedTransferQueue q = populatedQueue(SIZE);
586              Object o[] = q.toArray(new String[10]);
587              shouldThrow();
588 <        } catch (ArrayStoreException success) {
590 <        }
588 >        } catch (ArrayStoreException success) {}
589      }
590  
591      /**
# Line 746 | Line 744 | public class LinkedTransferQueueTest ext
744          try {
745              q.drainTo(null);
746              shouldThrow();
747 <        } catch (NullPointerException success) {
750 <        }
747 >        } catch (NullPointerException success) {}
748      }
749  
750      /**
# Line 758 | Line 755 | public class LinkedTransferQueueTest ext
755          try {
756              q.drainTo(q);
757              shouldThrow();
758 <        } catch (IllegalArgumentException success) {
762 <        }
758 >        } catch (IllegalArgumentException success) {}
759      }
760  
761      /**
# Line 815 | Line 811 | public class LinkedTransferQueueTest ext
811          try {
812              q.drainTo(null, SIZE);
813              shouldThrow();
814 <        } catch (NullPointerException success) {
819 <        }
814 >        } catch (NullPointerException success) {}
815      }
816  
817      /**
# Line 827 | Line 822 | public class LinkedTransferQueueTest ext
822          try {
823              q.drainTo(q, SIZE);
824              shouldThrow();
825 <        } catch (IllegalArgumentException success) {
831 <        }
825 >        } catch (IllegalArgumentException success) {}
826      }
827  
828      /**
# Line 886 | Line 880 | public class LinkedTransferQueueTest ext
880              LinkedTransferQueue q = new LinkedTransferQueue();
881              q.transfer(null);
882              shouldThrow();
883 <        } catch (NullPointerException ex) {
890 <        }
883 >        } catch (NullPointerException success) {}
884      }
885  
886      /**
# Line 994 | Line 987 | public class LinkedTransferQueueTest ext
987              final LinkedTransferQueue q = new LinkedTransferQueue();
988              q.tryTransfer(null);
989              shouldThrow();
990 <        } catch (NullPointerException ex) {
998 <        }
990 >        } catch (NullPointerException success) {}
991      }
992  
993      /**

Diff Legend

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