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.18 by jsr166, Sat Nov 21 21:00:34 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 355 | Line 342 | public class LinkedTransferQueueTest ext
342       */
343      public void testInterruptedTimedPoll() throws InterruptedException {
344          final LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
345 <        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
345 >        Thread t = newStartedThread(new CheckedRunnable() {
346              void realRun() throws InterruptedException {
347                  for (int i = 0; i < SIZE; ++i) {
348                      long t0 = System.nanoTime();
# Line 364 | Line 351 | public class LinkedTransferQueueTest ext
351                      long millisElapsed = (System.nanoTime() - t0)/(1024 * 1024);
352                      assertTrue(millisElapsed < SMALL_DELAY_MS);
353                  }
354 <                q.poll(LONG_DELAY_MS, MILLISECONDS);
354 >                try {
355 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
356 >                    shouldThrow();
357 >                } catch (InterruptedException success) {}
358              }});
359 +
360          Thread.sleep(SMALL_DELAY_MS);
361          t.interrupt();
362          t.join();
# Line 378 | Line 369 | public class LinkedTransferQueueTest ext
369       */
370      public void testTimedPollWithOffer() throws InterruptedException {
371          final LinkedTransferQueue q = new LinkedTransferQueue();
372 <        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
372 >        Thread t = new Thread(new CheckedRunnable() {
373              void realRun() throws InterruptedException {
374 <                threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
375 <                q.poll(LONG_DELAY_MS, MILLISECONDS);
376 <                q.poll(LONG_DELAY_MS, MILLISECONDS);
374 >                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
375 >                assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
376 >                try {
377 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
378 >                    shouldThrow();
379 >                } catch (InterruptedException success) {}
380              }});
381 +
382          Thread.sleep(SMALL_DELAY_MS);
383          assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
384          t.interrupt();
# Line 417 | Line 412 | public class LinkedTransferQueueTest ext
412          try {
413              q.element();
414              shouldThrow();
415 <        } catch (NoSuchElementException success) {
421 <        }
415 >        } catch (NoSuchElementException success) {}
416          checkEmpty(q);
417      }
418  
# Line 433 | Line 427 | public class LinkedTransferQueueTest ext
427          try {
428              q.remove();
429              shouldThrow();
430 <        } catch (NoSuchElementException success) {
437 <        }
430 >        } catch (NoSuchElementException success) {}
431          checkEmpty(q);
432      }
433  
# Line 575 | Line 568 | public class LinkedTransferQueueTest ext
568              LinkedTransferQueue q = populatedQueue(SIZE);
569              Object o[] = q.toArray(null);
570              shouldThrow();
571 <        } catch (NullPointerException success) {
579 <        }
571 >        } catch (NullPointerException success) {}
572      }
573  
574      /**
# Line 587 | Line 579 | public class LinkedTransferQueueTest ext
579              LinkedTransferQueue q = populatedQueue(SIZE);
580              Object o[] = q.toArray(new String[10]);
581              shouldThrow();
582 <        } catch (ArrayStoreException success) {
591 <        }
582 >        } catch (ArrayStoreException success) {}
583      }
584  
585      /**
# Line 747 | Line 738 | public class LinkedTransferQueueTest ext
738          try {
739              q.drainTo(null);
740              shouldThrow();
741 <        } catch (NullPointerException success) {
751 <        }
741 >        } catch (NullPointerException success) {}
742      }
743  
744      /**
# Line 759 | Line 749 | public class LinkedTransferQueueTest ext
749          try {
750              q.drainTo(q);
751              shouldThrow();
752 <        } catch (IllegalArgumentException success) {
763 <        }
752 >        } catch (IllegalArgumentException success) {}
753      }
754  
755      /**
# Line 816 | Line 805 | public class LinkedTransferQueueTest ext
805          try {
806              q.drainTo(null, SIZE);
807              shouldThrow();
808 <        } catch (NullPointerException success) {
820 <        }
808 >        } catch (NullPointerException success) {}
809      }
810  
811      /**
# Line 828 | Line 816 | public class LinkedTransferQueueTest ext
816          try {
817              q.drainTo(q, SIZE);
818              shouldThrow();
819 <        } catch (IllegalArgumentException success) {
832 <        }
819 >        } catch (IllegalArgumentException success) {}
820      }
821  
822      /**
# Line 887 | Line 874 | public class LinkedTransferQueueTest ext
874              LinkedTransferQueue q = new LinkedTransferQueue();
875              q.transfer(null);
876              shouldThrow();
877 <        } catch (NullPointerException ex) {
891 <        }
877 >        } catch (NullPointerException success) {}
878      }
879  
880      /**
# Line 995 | Line 981 | public class LinkedTransferQueueTest ext
981              final LinkedTransferQueue q = new LinkedTransferQueue();
982              q.tryTransfer(null);
983              shouldThrow();
984 <        } catch (NullPointerException ex) {
999 <        }
984 >        } catch (NullPointerException success) {}
985      }
986  
987      /**

Diff Legend

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