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.13 by jsr166, Sat Aug 15 00:48:10 2009 UTC vs.
Revision 1.19 by jsr166, Sun Nov 22 00:17:37 2009 UTC

# Line 13 | Line 13 | import java.io.ObjectInputStream;
13   import java.io.ObjectOutputStream;
14   import java.util.ArrayList;
15   import java.util.Arrays;
16 – import java.util.ConcurrentModificationException;
16   import java.util.Iterator;
17   import java.util.List;
18   import java.util.NoSuchElementException;
# Line 45 | Line 44 | public class LinkedTransferQueueTest ext
44          try {
45              q.element();
46              shouldThrow();
47 <        } catch (NoSuchElementException success) {
49 <        }
47 >        } catch (NoSuchElementException success) {}
48          try {
49              q.iterator().next();
50              shouldThrow();
51 <        } catch (NoSuchElementException success) {
54 <        }
51 >        } catch (NoSuchElementException success) {}
52          try {
53              q.remove();
54              shouldThrow();
55 <        } catch (NoSuchElementException success) {
59 <        }
55 >        } catch (NoSuchElementException success) {}
56      }
57  
58      /**
# Line 76 | Line 72 | public class LinkedTransferQueueTest ext
72          try {
73              new LinkedTransferQueue(null);
74              shouldThrow();
75 <        } catch (NullPointerException success) {
80 <        }
75 >        } catch (NullPointerException success) {}
76      }
77  
78      /**
# Line 89 | Line 84 | public class LinkedTransferQueueTest ext
84              Integer[] ints = new Integer[SIZE];
85              new LinkedTransferQueue(Arrays.asList(ints));
86              shouldThrow();
87 <        } catch (NullPointerException success) {
93 <        }
87 >        } catch (NullPointerException success) {}
88      }
89  
90      /**
# Line 105 | Line 99 | public class LinkedTransferQueueTest ext
99              }
100              new LinkedTransferQueue(Arrays.asList(ints));
101              shouldThrow();
102 <        } catch (NullPointerException success) {
109 <        }
102 >        } catch (NullPointerException success) {}
103      }
104  
105      /**
# Line 158 | Line 151 | public class LinkedTransferQueueTest ext
151              LinkedTransferQueue q = new LinkedTransferQueue();
152              q.offer(null);
153              shouldThrow();
154 <        } catch (NullPointerException success) {
162 <        }
154 >        } catch (NullPointerException success) {}
155      }
156  
157      /**
# Line 170 | Line 162 | public class LinkedTransferQueueTest ext
162              LinkedTransferQueue q = new LinkedTransferQueue();
163              q.add(null);
164              shouldThrow();
165 <        } catch (NullPointerException success) {
174 <        }
165 >        } catch (NullPointerException success) {}
166      }
167  
168      /**
# Line 182 | Line 173 | public class LinkedTransferQueueTest ext
173              LinkedTransferQueue q = new LinkedTransferQueue();
174              q.addAll(null);
175              shouldThrow();
176 <        } catch (NullPointerException success) {
186 <        }
176 >        } catch (NullPointerException success) {}
177      }
178  
179      /**
# Line 194 | Line 184 | public class LinkedTransferQueueTest ext
184              LinkedTransferQueue q = populatedQueue(SIZE);
185              q.addAll(q);
186              shouldThrow();
187 <        } catch (IllegalArgumentException success) {
198 <        }
187 >        } catch (IllegalArgumentException success) {}
188      }
189  
190      /**
# Line 207 | Line 196 | public class LinkedTransferQueueTest ext
196              Integer[] ints = new Integer[SIZE];
197              q.addAll(Arrays.asList(ints));
198              shouldThrow();
199 <        } catch (NullPointerException success) {
211 <        }
199 >        } catch (NullPointerException success) {}
200      }
201  
202      /**
# Line 224 | Line 212 | public class LinkedTransferQueueTest ext
212              }
213              q.addAll(Arrays.asList(ints));
214              shouldThrow();
215 <        } catch (NullPointerException success) {
228 <        }
215 >        } catch (NullPointerException success) {}
216      }
217  
218      /**
# Line 297 | 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 355 | 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 364 | 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 378 | 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 417 | Line 418 | public class LinkedTransferQueueTest ext
418          try {
419              q.element();
420              shouldThrow();
421 <        } catch (NoSuchElementException success) {
421 <        }
421 >        } catch (NoSuchElementException success) {}
422          checkEmpty(q);
423      }
424  
# Line 433 | Line 433 | public class LinkedTransferQueueTest ext
433          try {
434              q.remove();
435              shouldThrow();
436 <        } catch (NoSuchElementException success) {
437 <        }
436 >        } catch (NoSuchElementException success) {}
437          checkEmpty(q);
438      }
439  
# Line 575 | Line 574 | public class LinkedTransferQueueTest ext
574              LinkedTransferQueue q = populatedQueue(SIZE);
575              Object o[] = q.toArray(null);
576              shouldThrow();
577 <        } catch (NullPointerException success) {
579 <        }
577 >        } catch (NullPointerException success) {}
578      }
579  
580      /**
# Line 587 | Line 585 | public class LinkedTransferQueueTest ext
585              LinkedTransferQueue q = populatedQueue(SIZE);
586              Object o[] = q.toArray(new String[10]);
587              shouldThrow();
588 <        } catch (ArrayStoreException success) {
591 <        }
588 >        } catch (ArrayStoreException success) {}
589      }
590  
591      /**
# Line 747 | Line 744 | public class LinkedTransferQueueTest ext
744          try {
745              q.drainTo(null);
746              shouldThrow();
747 <        } catch (NullPointerException success) {
751 <        }
747 >        } catch (NullPointerException success) {}
748      }
749  
750      /**
# Line 759 | Line 755 | public class LinkedTransferQueueTest ext
755          try {
756              q.drainTo(q);
757              shouldThrow();
758 <        } catch (IllegalArgumentException success) {
763 <        }
758 >        } catch (IllegalArgumentException success) {}
759      }
760  
761      /**
# Line 816 | Line 811 | public class LinkedTransferQueueTest ext
811          try {
812              q.drainTo(null, SIZE);
813              shouldThrow();
814 <        } catch (NullPointerException success) {
820 <        }
814 >        } catch (NullPointerException success) {}
815      }
816  
817      /**
# Line 828 | Line 822 | public class LinkedTransferQueueTest ext
822          try {
823              q.drainTo(q, SIZE);
824              shouldThrow();
825 <        } catch (IllegalArgumentException success) {
832 <        }
825 >        } catch (IllegalArgumentException success) {}
826      }
827  
828      /**
# Line 887 | Line 880 | public class LinkedTransferQueueTest ext
880              LinkedTransferQueue q = new LinkedTransferQueue();
881              q.transfer(null);
882              shouldThrow();
883 <        } catch (NullPointerException ex) {
891 <        }
883 >        } catch (NullPointerException success) {}
884      }
885  
886      /**
# Line 995 | Line 987 | public class LinkedTransferQueueTest ext
987              final LinkedTransferQueue q = new LinkedTransferQueue();
988              q.tryTransfer(null);
989              shouldThrow();
990 <        } catch (NullPointerException ex) {
999 <        }
990 >        } catch (NullPointerException success) {}
991      }
992  
993      /**

Diff Legend

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