[cvs] / jsr166 / src / test / tck / ArrayBlockingQueueTest.java Repository:
ViewVC logotype

Diff of /jsr166/src/test/tck/ArrayBlockingQueueTest.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.16, Sat Nov 21 02:33:20 2009 UTC revision 1.17, Sat Nov 21 07:10:56 2009 UTC
# Line 50  Line 50 
50          try {          try {
51              ArrayBlockingQueue q = new ArrayBlockingQueue(0);              ArrayBlockingQueue q = new ArrayBlockingQueue(0);
52              shouldThrow();              shouldThrow();
53          }          } catch (IllegalArgumentException success) {}
         catch (IllegalArgumentException success) {}  
54      }      }
55    
56      /**      /**
# Line 61  Line 60 
60          try {          try {
61              ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);              ArrayBlockingQueue q = new ArrayBlockingQueue(1, true, null);
62              shouldThrow();              shouldThrow();
63          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
64      }      }
65    
66      /**      /**
# Line 73  Line 71 
71              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
72              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
73              shouldThrow();              shouldThrow();
74          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
75      }      }
76    
77      /**      /**
# Line 87  Line 84 
84                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
85              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
86              shouldThrow();              shouldThrow();
87          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
88      }      }
89    
90      /**      /**
# Line 101  Line 97 
97                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
98              ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));
99              shouldThrow();              shouldThrow();
100          }          } catch (IllegalArgumentException success) {}
         catch (IllegalArgumentException success) {}  
101      }      }
102    
103      /**      /**
# Line 194  Line 189 
189              }              }
190              assertEquals(0, q.remainingCapacity());              assertEquals(0, q.remainingCapacity());
191              q.add(new Integer(SIZE));              q.add(new Integer(SIZE));
192          } catch (IllegalStateException success) {              shouldThrow();
193          }          } catch (IllegalStateException success) {}
194      }      }
195    
196      /**      /**
# Line 206  Line 201 
201              ArrayBlockingQueue q = new ArrayBlockingQueue(1);              ArrayBlockingQueue q = new ArrayBlockingQueue(1);
202              q.addAll(null);              q.addAll(null);
203              shouldThrow();              shouldThrow();
204          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
205      }      }
206    
207      /**      /**
# Line 218  Line 212 
212              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
213              q.addAll(q);              q.addAll(q);
214              shouldThrow();              shouldThrow();
215          }          } catch (IllegalArgumentException success) {}
         catch (IllegalArgumentException success) {}  
216      }      }
217    
218    
# Line 232  Line 225 
225              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
226              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
227              shouldThrow();              shouldThrow();
228          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
229      }      }
230      /**      /**
231       * addAll of a collection with any null elements throws NPE after       * addAll of a collection with any null elements throws NPE after
# Line 247  Line 239 
239                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
240              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
241              shouldThrow();              shouldThrow();
242          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {}  
243      }      }
244      /**      /**
245       * addAll throws ISE if not enough room       * addAll throws ISE if not enough room
# Line 261  Line 252 
252                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
253              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
254              shouldThrow();              shouldThrow();
255          }          } catch (IllegalStateException success) {}
         catch (IllegalStateException success) {}  
256      }      }
257      /**      /**
258       * Queue contains all elements, in traversal order, of successful addAll       * Queue contains all elements, in traversal order, of successful addAll
259       */       */
260      public void testAddAll5() {      public void testAddAll5() {
         try {  
261              Integer[] empty = new Integer[0];              Integer[] empty = new Integer[0];
262              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
263              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
# Line 279  Line 268 
268              for (int i = 0; i < SIZE; ++i)              for (int i = 0; i < SIZE; ++i)
269                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
270          }          }
         finally {}  
     }  
271    
272      /**      /**
273       *  put(null) throws NPE       *  put(null) throws NPE
274       */       */
275       public void testPutNull() {      public void testPutNull() throws InterruptedException {
276          try {          try {
277              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
278              q.put(null);              q.put(null);
279              shouldThrow();              shouldThrow();
280          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {  
         }  
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
281       }       }
282    
283      /**      /**
284       * all elements successfully put are contained       * all elements successfully put are contained
285       */       */
286       public void testPut() {      public void testPut() throws InterruptedException {
          try {  
287               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
288               for (int i = 0; i < SIZE; ++i) {               for (int i = 0; i < SIZE; ++i) {
289                   Integer I = new Integer(i);                   Integer I = new Integer(i);
# Line 311  Line 292 
292               }               }
293               assertEquals(0, q.remainingCapacity());               assertEquals(0, q.remainingCapacity());
294           }           }
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
295    
296      /**      /**
297       * put blocks interruptibly if full       * put blocks interruptibly if full
298       */       */
299      public void testBlockingPut() {      public void testBlockingPut() throws InterruptedException {
300          final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);          final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
301          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
302                  public void run() {              public void realRun() {
303                      int added = 0;                      int added = 0;
304                      try {                      try {
305                          for (int i = 0; i < SIZE; ++i) {                          for (int i = 0; i < SIZE; ++i) {
# Line 333  Line 310 
310                          threadShouldThrow();                          threadShouldThrow();
311                      } catch (InterruptedException ie) {                      } catch (InterruptedException ie) {
312                          threadAssertEquals(added, SIZE);                          threadAssertEquals(added, SIZE);
313                      }                  }}});
314                  }});  
         try {  
315              t.start();              t.start();
316             Thread.sleep(MEDIUM_DELAY_MS);             Thread.sleep(MEDIUM_DELAY_MS);
317             t.interrupt();             t.interrupt();
318             t.join();             t.join();
319          }          }
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
320    
321      /**      /**
322       * put blocks waiting for take when full       * put blocks waiting for take when full
323       */       */
324      public void testPutWithTake() {      public void testPutWithTake() throws InterruptedException {
325          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
326          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
327                  public void run() {              public void realRun() {
328                      int added = 0;                      int added = 0;
329                      try {                      try {
330                          q.put(new Object());                          q.put(new Object());
# Line 367  Line 339 
339                      } catch (InterruptedException e) {                      } catch (InterruptedException e) {
340                          threadAssertTrue(added >= 2);                          threadAssertTrue(added >= 2);
341                      }                      }
342                  }              }});
343              });  
         try {  
344              t.start();              t.start();
345              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
346              q.take();              q.take();
347              t.interrupt();              t.interrupt();
348              t.join();              t.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
349      }      }
350    
351      /**      /**
352       * timed offer times out if full and elements not taken       * timed offer times out if full and elements not taken
353       */       */
354      public void testTimedOffer() {      public void testTimedOffer() throws InterruptedException {
355          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
356          Thread t = new Thread(new Runnable() {          Thread t = new ThreadShouldThrow(InterruptedException.class) {
357                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
358                          q.put(new Object());                          q.put(new Object());
359                          q.put(new Object());                          q.put(new Object());
360                          threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, MILLISECONDS));                          threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, MILLISECONDS));
361                          q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);                          q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
362                          threadShouldThrow();              }};
                     } catch (InterruptedException success) {}  
                 }  
             });  
363    
         try {  
364              t.start();              t.start();
365              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
366              t.interrupt();              t.interrupt();
367              t.join();              t.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
368      }      }
369    
370      /**      /**
371       * take retrieves elements in FIFO order       * take retrieves elements in FIFO order
372       */       */
373      public void testTake() {      public void testTake() throws InterruptedException {
         try {  
374              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
375              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
376                  assertEquals(i, ((Integer)q.take()).intValue());                  assertEquals(i, ((Integer)q.take()).intValue());
377              }              }
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
378      }      }
379    
380      /**      /**
381       * take blocks interruptibly when empty       * take blocks interruptibly when empty
382       */       */
383      public void testTakeFromEmpty() {      public void testTakeFromEmpty() throws InterruptedException {
384          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
385          Thread t = new Thread(new Runnable() {          Thread t = new ThreadShouldThrow(InterruptedException.class) {
386                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
387                          q.take();                          q.take();
388                          threadShouldThrow();              }};
389                      } catch (InterruptedException success) { }  
                 }  
             });  
         try {  
390              t.start();              t.start();
391              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
392              t.interrupt();              t.interrupt();
393              t.join();              t.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
394      }      }
395    
396      /**      /**
397       * Take removes existing elements until empty, then blocks interruptibly       * Take removes existing elements until empty, then blocks interruptibly
398       */       */
399      public void testBlockingTake() {      public void testBlockingTake() throws InterruptedException {
400          Thread t = new Thread(new Runnable() {          Thread t = new ThreadShouldThrow(InterruptedException.class) {
401                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
402                          ArrayBlockingQueue q = populatedQueue(SIZE);                          ArrayBlockingQueue q = populatedQueue(SIZE);
403                          for (int i = 0; i < SIZE; ++i) {                          for (int i = 0; i < SIZE; ++i) {
404                              threadAssertEquals(i, ((Integer)q.take()).intValue());                              threadAssertEquals(i, ((Integer)q.take()).intValue());
405                          }                          }
406                          q.take();                          q.take();
407                          threadShouldThrow();              }};
408                      } catch (InterruptedException success) {  
                     }  
                 }});  
         try {  
409              t.start();              t.start();
410              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
411              t.interrupt();              t.interrupt();
412              t.join();              t.join();
413          }          }
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
414    
415    
416      /**      /**
# Line 486  Line 427 
427      /**      /**
428       * timed pool with zero timeout succeeds when non-empty, else times out       * timed pool with zero timeout succeeds when non-empty, else times out
429       */       */
430      public void testTimedPoll0() {      public void testTimedPoll0() throws InterruptedException {
         try {  
431              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
432              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
433                  assertEquals(i, ((Integer)q.poll(0, MILLISECONDS)).intValue());                  assertEquals(i, ((Integer)q.poll(0, MILLISECONDS)).intValue());
434              }              }
435              assertNull(q.poll(0, MILLISECONDS));              assertNull(q.poll(0, MILLISECONDS));
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
436      }      }
437    
438      /**      /**
439       * timed pool with nonzero timeout succeeds when non-empty, else times out       * timed pool with nonzero timeout succeeds when non-empty, else times out
440       */       */
441      public void testTimedPoll() {      public void testTimedPoll() throws InterruptedException {
         try {  
442              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
443              for (int i = 0; i < SIZE; ++i) {              for (int i = 0; i < SIZE; ++i) {
444                  assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());                  assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
445              }              }
446              assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));              assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
447      }      }
448    
449      /**      /**
450       * Interrupted timed poll throws InterruptedException instead of       * Interrupted timed poll throws InterruptedException instead of
451       * returning timeout status       * returning timeout status
452       */       */
453      public void testInterruptedTimedPoll() {      public void testInterruptedTimedPoll() throws InterruptedException {
454          Thread t = new Thread(new Runnable() {          Thread t = new ThreadShouldThrow(InterruptedException.class) {
455                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
456                          ArrayBlockingQueue q = populatedQueue(SIZE);                          ArrayBlockingQueue q = populatedQueue(SIZE);
457                          for (int i = 0; i < SIZE; ++i) {                          for (int i = 0; i < SIZE; ++i) {
458                              threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());                              threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
459                          }                          }
460                          threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));                  q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
461                      } catch (InterruptedException success) {              }};
462                      }  
                 }});  
         try {  
463              t.start();              t.start();
464              Thread.sleep(SHORT_DELAY_MS);          Thread.sleep(SMALL_DELAY_MS);
465              t.interrupt();              t.interrupt();
466              t.join();              t.join();
467          }          }
         catch (InterruptedException ie) {  
             unexpectedException();  
         }  
     }  
468    
469      /**      /**
470       *  timed poll before a delayed offer fails; after offer succeeds;       *  timed poll before a delayed offer fails; after offer succeeds;
471       *  on interruption throws       *  on interruption throws
472       */       */
473      public void testTimedPollWithOffer() {      public void testTimedPollWithOffer() throws InterruptedException {
474          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
475          Thread t = new Thread(new Runnable() {          Thread t = new ThreadShouldThrow(InterruptedException.class) {
476                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
477                          threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));                          threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
478                          q.poll(LONG_DELAY_MS, MILLISECONDS);                          q.poll(LONG_DELAY_MS, MILLISECONDS);
479                          q.poll(LONG_DELAY_MS, MILLISECONDS);                          q.poll(LONG_DELAY_MS, MILLISECONDS);
480                          threadShouldThrow();              }};
481                      } catch (InterruptedException success) { }  
                 }  
             });  
         try {  
482              t.start();              t.start();
483              Thread.sleep(SMALL_DELAY_MS);              Thread.sleep(SMALL_DELAY_MS);
484              assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));              assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
485              t.interrupt();              t.interrupt();
486              t.join();              t.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
487      }      }
488    
489    
# Line 594  Line 513 
513          try {          try {
514              q.element();              q.element();
515              shouldThrow();              shouldThrow();
516          }          } catch (NoSuchElementException success) {}
         catch (NoSuchElementException success) {}  
517      }      }
518    
519      /**      /**
# Line 609  Line 527 
527          try {          try {
528              q.remove();              q.remove();
529              shouldThrow();              shouldThrow();
530          } catch (NoSuchElementException success) {          } catch (NoSuchElementException success) {}
         }  
531      }      }
532    
533      /**      /**
# Line 708  Line 625 
625      /**      /**
626       *  toArray contains all elements       *  toArray contains all elements
627       */       */
628      public void testToArray() {      public void testToArray() throws InterruptedException {
629          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
630          Object[] o = q.toArray();          Object[] o = q.toArray();
         try {  
631          for (int i = 0; i < o.length; i++)          for (int i = 0; i < o.length; i++)
632              assertEquals(o[i], q.take());              assertEquals(o[i], q.take());
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
633      }      }
634    
635      /**      /**
636       * toArray(a) contains all elements       * toArray(a) contains all elements
637       */       */
638      public void testToArray2() {      public void testToArray2() throws InterruptedException {
639          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
640          Integer[] ints = new Integer[SIZE];          Integer[] ints = new Integer[SIZE];
641          ints = (Integer[])q.toArray(ints);          ints = (Integer[])q.toArray(ints);
         try {  
642              for (int i = 0; i < ints.length; i++)              for (int i = 0; i < ints.length; i++)
643                  assertEquals(ints[i], q.take());                  assertEquals(ints[i], q.take());
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
644      }      }
645    
646      /**      /**
# Line 760  Line 669 
669      /**      /**
670       * iterator iterates through all elements       * iterator iterates through all elements
671       */       */
672      public void testIterator() {      public void testIterator() throws InterruptedException {
673          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
674          Iterator it = q.iterator();          Iterator it = q.iterator();
         try {  
675              while (it.hasNext()) {              while (it.hasNext()) {
676                  assertEquals(it.next(), q.take());                  assertEquals(it.next(), q.take());
677              }              }
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
678      }      }
679    
680      /**      /**
# Line 818  Line 723 
723          q.add(one);          q.add(one);
724          q.add(two);          q.add(two);
725          q.add(three);          q.add(three);
         try {  
726              for (Iterator it = q.iterator(); it.hasNext();) {              for (Iterator it = q.iterator(); it.hasNext();) {
727                  q.remove();                  q.remove();
728                  it.next();                  it.next();
729              }              }
         }  
         catch (ConcurrentModificationException e) {  
             unexpectedException();  
         }  
730          assertEquals(0, q.size());          assertEquals(0, q.size());
731      }      }
732    
# Line 851  Line 751 
751          q.add(one);          q.add(one);
752          q.add(two);          q.add(two);
753          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
754          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
755              public void run() {              public void realRun() throws InterruptedException {
756                  threadAssertFalse(q.offer(three));                  threadAssertFalse(q.offer(three));
                 try {  
757                      threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));                      threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));
758                      threadAssertEquals(0, q.remainingCapacity());                      threadAssertEquals(0, q.remainingCapacity());
759                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
760    
761          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
762              public void run() {              public void realRun() throws InterruptedException {
                 try {  
763                      Thread.sleep(SMALL_DELAY_MS);                      Thread.sleep(SMALL_DELAY_MS);
764                      threadAssertEquals(one, q.take());                      threadAssertEquals(one, q.take());
765                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
766    
767          joinPool(executor);          joinPool(executor);
768    
# Line 886  Line 774 
774      public void testPollInExecutor() {      public void testPollInExecutor() {
775          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
776          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
777          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
778              public void run() {              public void realRun() throws InterruptedException {
779                  threadAssertNull(q.poll());                  threadAssertNull(q.poll());
                 try {  
780                      threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, MILLISECONDS));                      threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
781                      threadAssertTrue(q.isEmpty());                      threadAssertTrue(q.isEmpty());
782                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
783    
784          executor.execute(new Runnable() {          executor.execute(new CheckedRunnable() {
785              public void run() {              public void realRun() throws InterruptedException {
                 try {  
786                      Thread.sleep(SMALL_DELAY_MS);                      Thread.sleep(SMALL_DELAY_MS);
787                      q.put(one);                      q.put(one);
788                  }              }});
                 catch (InterruptedException e) {  
                     threadUnexpectedException();  
                 }  
             }  
         });  
789    
790          joinPool(executor);          joinPool(executor);
791      }      }
# Line 917  Line 793 
793      /**      /**
794       * A deserialized serialized queue has same elements in same order       * A deserialized serialized queue has same elements in same order
795       */       */
796      public void testSerialization() {      public void testSerialization() throws Exception {
797          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
798    
         try {  
799              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
800              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
801              out.writeObject(q);              out.writeObject(q);
# Line 932  Line 807 
807              assertEquals(q.size(), r.size());              assertEquals(q.size(), r.size());
808              while (!q.isEmpty())              while (!q.isEmpty())
809                  assertEquals(q.remove(), r.remove());                  assertEquals(q.remove(), r.remove());
         } catch (Exception e) {  
             unexpectedException();  
         }  
810      }      }
811    
812      /**      /**
# Line 945  Line 817 
817          try {          try {
818              q.drainTo(null);              q.drainTo(null);
819              shouldThrow();              shouldThrow();
820          } catch (NullPointerException success) {          } catch (NullPointerException success) {}
         }  
821      }      }
822    
823      /**      /**
# Line 957  Line 828 
828          try {          try {
829              q.drainTo(q);              q.drainTo(q);
830              shouldThrow();              shouldThrow();
831          } catch (IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         }  
832      }      }
833    
834      /**      /**
# Line 988  Line 858 
858      /**      /**
859       * drainTo empties full queue, unblocking a waiting put.       * drainTo empties full queue, unblocking a waiting put.
860       */       */
861      public void testDrainToWithActivePut() {      public void testDrainToWithActivePut() throws InterruptedException {
862          final ArrayBlockingQueue q = populatedQueue(SIZE);          final ArrayBlockingQueue q = populatedQueue(SIZE);
863          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
864                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
865                          q.put(new Integer(SIZE+1));                          q.put(new Integer(SIZE+1));
866                      } catch (InterruptedException ie) {              }});
867                          threadUnexpectedException();  
                     }  
                 }  
             });  
         try {  
868              t.start();              t.start();
869              ArrayList l = new ArrayList();              ArrayList l = new ArrayList();
870              q.drainTo(l);              q.drainTo(l);
# Line 1008  Line 873 
873                  assertEquals(l.get(i), new Integer(i));                  assertEquals(l.get(i), new Integer(i));
874              t.join();              t.join();
875              assertTrue(q.size() + l.size() >= SIZE);              assertTrue(q.size() + l.size() >= SIZE);
         } catch (Exception e) {  
             unexpectedException();  
         }  
876      }      }
877    
878      /**      /**
# Line 1021  Line 883 
883          try {          try {
884              q.drainTo(null, 0);              q.drainTo(null, 0);
885              shouldThrow();              shouldThrow();
886          } catch (NullPointerException success) {          } catch (NullPointerException success) {}
         }  
887      }      }
888    
889      /**      /**
# Line 1033  Line 894 
894          try {          try {
895              q.drainTo(q, 0);              q.drainTo(q, 0);
896              shouldThrow();              shouldThrow();
897          } catch (IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         }  
898      }      }
899    
900      /**      /**
# Line 1056  Line 916 
916          }          }
917      }      }
918    
   
919  }  }

Legend:
Removed from v.1.16  
changed lines
  Added in v.1.17

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8