[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.2, Sun Sep 7 20:39:11 2003 UTC revision 1.3, Sun Sep 14 20:42:40 2003 UTC
# Line 10  Line 10 
10  import java.util.concurrent.*;  import java.util.concurrent.*;
11  import java.io.*;  import java.io.*;
12    
13  public class ArrayBlockingQueueTest extends TestCase {  public class ArrayBlockingQueueTest extends JSR166TestCase {
   
     private static int N = 10;  
     private static long SHORT_DELAY_MS = 100;  
     private static long MEDIUM_DELAY_MS = 1000;  
     private static long LONG_DELAY_MS = 10000;  
14    
15      public static void main(String[] args) {      public static void main(String[] args) {
16          junit.textui.TestRunner.run (suite());          junit.textui.TestRunner.run (suite());
# Line 29  Line 24 
24       * Create a queue of given size containing consecutive       * Create a queue of given size containing consecutive
25       * Integers 0 ... n.       * Integers 0 ... n.
26       */       */
27      private ArrayBlockingQueue fullQueue(int n) {      private ArrayBlockingQueue populatedQueue(int n) {
28          ArrayBlockingQueue q = new ArrayBlockingQueue(n);          ArrayBlockingQueue q = new ArrayBlockingQueue(n);
29          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
30          for(int i = 0; i < n; i++)          for(int i = 0; i < n; i++)
# Line 41  Line 36 
36      }      }
37    
38      public void testConstructor1(){      public void testConstructor1(){
39          assertEquals(N, new ArrayBlockingQueue(N).remainingCapacity());          assertEquals(SIZE, new ArrayBlockingQueue(SIZE).remainingCapacity());
40      }      }
41    
42      public void testConstructor2(){      public void testConstructor2(){
# Line 63  Line 58 
58    
59      public void testConstructor4(){      public void testConstructor4(){
60          try {          try {
61              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
62              ArrayBlockingQueue q = new ArrayBlockingQueue(N, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
63              fail("Cannot make with null elements");              fail("Cannot make with null elements");
64          }          }
65          catch (NullPointerException success) {}          catch (NullPointerException success) {}
# Line 72  Line 67 
67    
68      public void testConstructor5(){      public void testConstructor5(){
69          try {          try {
70              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
71              for (int i = 0; i < N-1; ++i)              for (int i = 0; i < SIZE-1; ++i)
72                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
73              ArrayBlockingQueue q = new ArrayBlockingQueue(N, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
74              fail("Cannot make with null elements");              fail("Cannot make with null elements");
75          }          }
76          catch (NullPointerException success) {}          catch (NullPointerException success) {}
# Line 83  Line 78 
78    
79      public void testConstructor6(){      public void testConstructor6(){
80          try {          try {
81              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
82              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
83                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
84              ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(1, false, Arrays.asList(ints));
85              fail("Cannot make with insufficient capacity");              fail("Cannot make with insufficient capacity");
# Line 94  Line 89 
89    
90      public void testConstructor7(){      public void testConstructor7(){
91          try {          try {
92              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
93              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
94                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
95              ArrayBlockingQueue q = new ArrayBlockingQueue(N, true, Arrays.asList(ints));              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, Arrays.asList(ints));
96              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
97                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
98          }          }
99          finally {}          finally {}
# Line 108  Line 103 
103          ArrayBlockingQueue q = new ArrayBlockingQueue(2);          ArrayBlockingQueue q = new ArrayBlockingQueue(2);
104          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
105          assertEquals("should have room for 2", 2, q.remainingCapacity());          assertEquals("should have room for 2", 2, q.remainingCapacity());
106          q.add(new Integer(1));          q.add(one);
107          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
108          q.add(new Integer(2));          q.add(two);
109          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
110          assertEquals("queue should be full", 0, q.remainingCapacity());          assertEquals("queue should be full", 0, q.remainingCapacity());
111          assertFalse("offer should be rejected", q.offer(new Integer(3)));          assertFalse("offer should be rejected", q.offer(three));
112      }      }
113    
114      public void testRemainingCapacity(){      public void testRemainingCapacity(){
115          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
116          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
117              assertEquals(i, q.remainingCapacity());              assertEquals(i, q.remainingCapacity());
118              assertEquals(N-i, q.size());              assertEquals(SIZE-i, q.size());
119              q.remove();              q.remove();
120          }          }
121          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
122              assertEquals(N-i, q.remainingCapacity());              assertEquals(SIZE-i, q.remainingCapacity());
123              assertEquals(i, q.size());              assertEquals(i, q.size());
124              q.add(new Integer(i));              q.add(new Integer(i));
125          }          }
# Line 140  Line 135 
135    
136      public void testOffer(){      public void testOffer(){
137          ArrayBlockingQueue q = new ArrayBlockingQueue(1);          ArrayBlockingQueue q = new ArrayBlockingQueue(1);
138          assertTrue(q.offer(new Integer(0)));          assertTrue(q.offer(zero));
139          assertFalse(q.offer(new Integer(1)));          assertFalse(q.offer(one));
140      }      }
141    
142      public void testAdd(){      public void testAdd(){
143          try {          try {
144              ArrayBlockingQueue q = new ArrayBlockingQueue(N);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
145              for (int i = 0; i < N; ++i) {              for (int i = 0; i < SIZE; ++i) {
146                  assertTrue(q.add(new Integer(i)));                  assertTrue(q.add(new Integer(i)));
147              }              }
148              assertEquals(0, q.remainingCapacity());              assertEquals(0, q.remainingCapacity());
149              q.add(new Integer(N));              q.add(new Integer(SIZE));
150          } catch (IllegalStateException success){          } catch (IllegalStateException success){
151          }          }
152      }      }
# Line 166  Line 161 
161      }      }
162      public void testAddAll2(){      public void testAddAll2(){
163          try {          try {
164              ArrayBlockingQueue q = new ArrayBlockingQueue(N);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
165              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
166              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
167              fail("Cannot add null elements");              fail("Cannot add null elements");
168          }          }
# Line 175  Line 170 
170      }      }
171      public void testAddAll3(){      public void testAddAll3(){
172          try {          try {
173              ArrayBlockingQueue q = new ArrayBlockingQueue(N);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
174              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
175              for (int i = 0; i < N-1; ++i)              for (int i = 0; i < SIZE-1; ++i)
176                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
177              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
178              fail("Cannot add null elements");              fail("Cannot add null elements");
# Line 187  Line 182 
182      public void testAddAll4(){      public void testAddAll4(){
183          try {          try {
184              ArrayBlockingQueue q = new ArrayBlockingQueue(1);              ArrayBlockingQueue q = new ArrayBlockingQueue(1);
185              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
186              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
187                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
188              q.addAll(Arrays.asList(ints));              q.addAll(Arrays.asList(ints));
189              fail("Cannot add with insufficient capacity");              fail("Cannot add with insufficient capacity");
# Line 198  Line 193 
193      public void testAddAll5(){      public void testAddAll5(){
194          try {          try {
195              Integer[] empty = new Integer[0];              Integer[] empty = new Integer[0];
196              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
197              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
198                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
199              ArrayBlockingQueue q = new ArrayBlockingQueue(N);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
200              assertFalse(q.addAll(Arrays.asList(empty)));              assertFalse(q.addAll(Arrays.asList(empty)));
201              assertTrue(q.addAll(Arrays.asList(ints)));              assertTrue(q.addAll(Arrays.asList(ints)));
202              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
203                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
204          }          }
205          finally {}          finally {}
# Line 212  Line 207 
207    
208       public void testPutNull() {       public void testPutNull() {
209          try {          try {
210              ArrayBlockingQueue q = new ArrayBlockingQueue(N);              ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
211              q.put(null);              q.put(null);
212              fail("put should throw NPE");              fail("put should throw NPE");
213          }          }
# Line 225  Line 220 
220    
221       public void testPut() {       public void testPut() {
222           try {           try {
223               ArrayBlockingQueue q = new ArrayBlockingQueue(N);               ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
224               for (int i = 0; i < N; ++i) {               for (int i = 0; i < SIZE; ++i) {
225                   Integer I = new Integer(i);                   Integer I = new Integer(i);
226                   q.put(I);                   q.put(I);
227                   assertTrue(q.contains(I));                   assertTrue(q.contains(I));
# Line 243  Line 238 
238                  public void run() {                  public void run() {
239                      int added = 0;                      int added = 0;
240                      try {                      try {
241                          ArrayBlockingQueue q = new ArrayBlockingQueue(N);                          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
242                          for (int i = 0; i < N; ++i) {                          for (int i = 0; i < SIZE; ++i) {
243                              q.put(new Integer(i));                              q.put(new Integer(i));
244                              ++added;                              ++added;
245                          }                          }
246                          q.put(new Integer(N));                          q.put(new Integer(SIZE));
247                          fail("put should block");                          threadFail("put should block");
248                      } catch (InterruptedException ie){                      } catch (InterruptedException ie){
249                          assertEquals(added, N);                          threadAssertEquals(added, SIZE);
250                      }                      }
251                  }});                  }});
         t.start();  
252          try {          try {
253                t.start();
254             Thread.sleep(SHORT_DELAY_MS);             Thread.sleep(SHORT_DELAY_MS);
255             t.interrupt();             t.interrupt();
256             t.join();             t.join();
# Line 279  Line 274 
274                          ++added;                          ++added;
275                          q.put(new Object());                          q.put(new Object());
276                          ++added;                          ++added;
277                          fail("Should block");                          threadFail("Should block");
278                      } catch (InterruptedException e){                      } catch (InterruptedException e){
279                          assertTrue(added >= 2);                          threadAssertTrue(added >= 2);
280                      }                      }
281                  }                  }
282              });              });
# Line 303  Line 298 
298                      try {                      try {
299                          q.put(new Object());                          q.put(new Object());
300                          q.put(new Object());                          q.put(new Object());
301                          assertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));                          threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));
302                          q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);                          q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
303                          fail("Should block");                          threadFail("Should block");
304                      } catch (InterruptedException success){}                      } catch (InterruptedException success){}
305                  }                  }
306              });              });
# Line 322  Line 317 
317    
318      public void testTake(){      public void testTake(){
319          try {          try {
320              ArrayBlockingQueue q = fullQueue(N);              ArrayBlockingQueue q = populatedQueue(SIZE);
321              for (int i = 0; i < N; ++i) {              for (int i = 0; i < SIZE; ++i) {
322                  assertEquals(i, ((Integer)q.take()).intValue());                  assertEquals(i, ((Integer)q.take()).intValue());
323              }              }
324          } catch (InterruptedException e){          } catch (InterruptedException e){
# Line 337  Line 332 
332                  public void run(){                  public void run(){
333                      try {                      try {
334                          q.take();                          q.take();
335                          fail("Should block");                          threadFail("Should block");
336                      } catch (InterruptedException success){ }                      } catch (InterruptedException success){ }
337                  }                  }
338              });              });
# Line 355  Line 350 
350          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
351                  public void run() {                  public void run() {
352                      try {                      try {
353                          ArrayBlockingQueue q = fullQueue(N);                          ArrayBlockingQueue q = populatedQueue(SIZE);
354                          for (int i = 0; i < N; ++i) {                          for (int i = 0; i < SIZE; ++i) {
355                              assertEquals(i, ((Integer)q.take()).intValue());                              threadAssertEquals(i, ((Integer)q.take()).intValue());
356                          }                          }
357                          q.take();                          q.take();
358                          fail("take should block");                          threadFail("take should block");
359                      } catch (InterruptedException success){                      } catch (InterruptedException success){
360                      }                      }
361                  }});                  }});
         t.start();  
362          try {          try {
363                t.start();
364             Thread.sleep(SHORT_DELAY_MS);             Thread.sleep(SHORT_DELAY_MS);
365             t.interrupt();             t.interrupt();
366             t.join();             t.join();
# Line 377  Line 372 
372    
373    
374      public void testPoll(){      public void testPoll(){
375          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
376          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
377              assertEquals(i, ((Integer)q.poll()).intValue());              assertEquals(i, ((Integer)q.poll()).intValue());
378          }          }
379          assertNull(q.poll());          assertNull(q.poll());
# Line 386  Line 381 
381    
382      public void testTimedPoll0() {      public void testTimedPoll0() {
383          try {          try {
384              ArrayBlockingQueue q = fullQueue(N);              ArrayBlockingQueue q = populatedQueue(SIZE);
385              for (int i = 0; i < N; ++i) {              for (int i = 0; i < SIZE; ++i) {
386                  assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue());                  assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue());
387              }              }
388              assertNull(q.poll(0, TimeUnit.MILLISECONDS));              assertNull(q.poll(0, TimeUnit.MILLISECONDS));
# Line 398  Line 393 
393    
394      public void testTimedPoll() {      public void testTimedPoll() {
395          try {          try {
396              ArrayBlockingQueue q = fullQueue(N);              ArrayBlockingQueue q = populatedQueue(SIZE);
397              for (int i = 0; i < N; ++i) {              for (int i = 0; i < SIZE; ++i) {
398                  assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());                  assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
399              }              }
400              assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));              assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
# Line 412  Line 407 
407          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
408                  public void run() {                  public void run() {
409                      try {                      try {
410                          ArrayBlockingQueue q = fullQueue(N);                          ArrayBlockingQueue q = populatedQueue(SIZE);
411                          for (int i = 0; i < N; ++i) {                          for (int i = 0; i < SIZE; ++i) {
412                              assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());                              threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
413                          }                          }
414                          assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));                          threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
415                      } catch (InterruptedException success){                      } catch (InterruptedException success){
416                      }                      }
417                  }});                  }});
         t.start();  
418          try {          try {
419                t.start();
420             Thread.sleep(SHORT_DELAY_MS);             Thread.sleep(SHORT_DELAY_MS);
421             t.interrupt();             t.interrupt();
422             t.join();             t.join();
# Line 436  Line 431 
431          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
432                  public void run(){                  public void run(){
433                      try {                      try {
434                          assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));                          threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
435                          q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);                          q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
436                          q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);                          q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
437                          fail("Should block");                          threadFail("Should block");
438                      } catch (InterruptedException success) { }                      } catch (InterruptedException success) { }
439                  }                  }
440              });              });
441          try {          try {
442              t.start();              t.start();
443              Thread.sleep(SHORT_DELAY_MS * 2);              Thread.sleep(SMALL_DELAY_MS);
444              assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));              assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
445              t.interrupt();              t.interrupt();
446              t.join();              t.join();
447          } catch (Exception e){          } catch (Exception e){
# Line 456  Line 451 
451    
452    
453      public void testPeek(){      public void testPeek(){
454          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
455          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
456              assertEquals(i, ((Integer)q.peek()).intValue());              assertEquals(i, ((Integer)q.peek()).intValue());
457              q.poll();              q.poll();
458              assertTrue(q.peek() == null ||              assertTrue(q.peek() == null ||
# Line 467  Line 462 
462      }      }
463    
464      public void testElement(){      public void testElement(){
465          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
466          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
467              assertEquals(i, ((Integer)q.element()).intValue());              assertEquals(i, ((Integer)q.element()).intValue());
468              q.poll();              q.poll();
469          }          }
# Line 480  Line 475 
475      }      }
476    
477      public void testRemove(){      public void testRemove(){
478          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
479          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
480              assertEquals(i, ((Integer)q.remove()).intValue());              assertEquals(i, ((Integer)q.remove()).intValue());
481          }          }
482          try {          try {
# Line 492  Line 487 
487      }      }
488    
489      public void testRemoveElement(){      public void testRemoveElement(){
490          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
491          for (int i = 1; i < N; i+=2) {          for (int i = 1; i < SIZE; i+=2) {
492              assertTrue(q.remove(new Integer(i)));              assertTrue(q.remove(new Integer(i)));
493          }          }
494          for (int i = 0; i < N; i+=2) {          for (int i = 0; i < SIZE; i+=2) {
495              assertTrue(q.remove(new Integer(i)));              assertTrue(q.remove(new Integer(i)));
496              assertFalse(q.remove(new Integer(i+1)));              assertFalse(q.remove(new Integer(i+1)));
497          }          }
# Line 504  Line 499 
499      }      }
500    
501      public void testContains(){      public void testContains(){
502          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
503          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
504              assertTrue(q.contains(new Integer(i)));              assertTrue(q.contains(new Integer(i)));
505              q.poll();              q.poll();
506              assertFalse(q.contains(new Integer(i)));              assertFalse(q.contains(new Integer(i)));
# Line 513  Line 508 
508      }      }
509    
510      public void testClear(){      public void testClear(){
511          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
512          q.clear();          q.clear();
513          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
514          assertEquals(0, q.size());          assertEquals(0, q.size());
515          assertEquals(N, q.remainingCapacity());          assertEquals(SIZE, q.remainingCapacity());
516          q.add(new Integer(1));          q.add(one);
517          assertFalse(q.isEmpty());          assertFalse(q.isEmpty());
518          q.clear();          q.clear();
519          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
520      }      }
521    
522      public void testContainsAll(){      public void testContainsAll(){
523          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
524          ArrayBlockingQueue p = new ArrayBlockingQueue(N);          ArrayBlockingQueue p = new ArrayBlockingQueue(SIZE);
525          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
526              assertTrue(q.containsAll(p));              assertTrue(q.containsAll(p));
527              assertFalse(p.containsAll(q));              assertFalse(p.containsAll(q));
528              p.add(new Integer(i));              p.add(new Integer(i));
# Line 536  Line 531 
531      }      }
532    
533      public void testRetainAll(){      public void testRetainAll(){
534          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
535          ArrayBlockingQueue p = fullQueue(N);          ArrayBlockingQueue p = populatedQueue(SIZE);
536          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
537              boolean changed = q.retainAll(p);              boolean changed = q.retainAll(p);
538              if (i == 0)              if (i == 0)
539                  assertFalse(changed);                  assertFalse(changed);
# Line 546  Line 541 
541                  assertTrue(changed);                  assertTrue(changed);
542    
543              assertTrue(q.containsAll(p));              assertTrue(q.containsAll(p));
544              assertEquals(N-i, q.size());              assertEquals(SIZE-i, q.size());
545              p.remove();              p.remove();
546          }          }
547      }      }
548    
549      public void testRemoveAll(){      public void testRemoveAll(){
550          for (int i = 1; i < N; ++i) {          for (int i = 1; i < SIZE; ++i) {
551              ArrayBlockingQueue q = fullQueue(N);              ArrayBlockingQueue q = populatedQueue(SIZE);
552              ArrayBlockingQueue p = fullQueue(i);              ArrayBlockingQueue p = populatedQueue(i);
553              assertTrue(q.removeAll(p));              assertTrue(q.removeAll(p));
554              assertEquals(N-i, q.size());              assertEquals(SIZE-i, q.size());
555              for (int j = 0; j < i; ++j) {              for (int j = 0; j < i; ++j) {
556                  Integer I = (Integer)(p.remove());                  Integer I = (Integer)(p.remove());
557                  assertFalse(q.contains(I));                  assertFalse(q.contains(I));
# Line 566  Line 561 
561    
562    
563      public void testToArray(){      public void testToArray(){
564          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
565          Object[] o = q.toArray();          Object[] o = q.toArray();
566          try {          try {
567          for(int i = 0; i < o.length; i++)          for(int i = 0; i < o.length; i++)
# Line 577  Line 572 
572      }      }
573    
574      public void testToArray2(){      public void testToArray2(){
575          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
576          Integer[] ints = new Integer[N];          Integer[] ints = new Integer[SIZE];
577          ints = (Integer[])q.toArray(ints);          ints = (Integer[])q.toArray(ints);
578          try {          try {
579              for(int i = 0; i < ints.length; i++)              for(int i = 0; i < ints.length; i++)
# Line 589  Line 584 
584      }      }
585    
586      public void testIterator(){      public void testIterator(){
587          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
588          Iterator it = q.iterator();          Iterator it = q.iterator();
589          try {          try {
590              while(it.hasNext()){              while(it.hasNext()){
# Line 604  Line 599 
599    
600          final ArrayBlockingQueue q = new ArrayBlockingQueue(3);          final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
601    
602          q.add(new Integer(1));          q.add(one);
603          q.add(new Integer(2));          q.add(two);
604          q.add(new Integer(3));          q.add(three);
605    
606          assertEquals("queue should be full", 0, q.remainingCapacity());          assertEquals("queue should be full", 0, q.remainingCapacity());
607    
# Line 623  Line 618 
618    
619          final ArrayBlockingQueue q = new ArrayBlockingQueue(3);          final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
620    
621          q.add(new Integer(1));          q.add(one);
622          q.add(new Integer(2));          q.add(two);
623          q.add(new Integer(3));          q.add(three);
624    
625          try {          try {
626              for (Iterator it = q.iterator(); it.hasNext();) {              for (Iterator it = q.iterator(); it.hasNext();) {
# Line 642  Line 637 
637    
638    
639      public void testToString(){      public void testToString(){
640          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
641          String s = q.toString();          String s = q.toString();
642          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
643              assertTrue(s.indexOf(String.valueOf(i)) >= 0);              assertTrue(s.indexOf(String.valueOf(i)) >= 0);
644          }          }
645      }      }
# Line 654  Line 649 
649    
650          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
651    
652          q.add(new Integer(1));          q.add(one);
653          q.add(new Integer(2));          q.add(two);
654    
655          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
656    
657          executor.execute(new Runnable() {          executor.execute(new Runnable() {
658              public void run() {              public void run() {
659                  assertFalse("offer should be rejected", q.offer(new Integer(3)));                  threadAssertFalse(q.offer(three));
660                  try {                  try {
661                      assertTrue("offer should be accepted", q.offer(new Integer(3), MEDIUM_DELAY_MS * 2, TimeUnit.MILLISECONDS));                      threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
662                      assertEquals(0, q.remainingCapacity());                      threadAssertEquals(0, q.remainingCapacity());
663                  }                  }
664                  catch (InterruptedException e) {                  catch (InterruptedException e) {
665                      fail("should not be interrupted");                      threadFail("should not be interrupted");
666                  }                  }
667              }              }
668          });          });
# Line 675  Line 670 
670          executor.execute(new Runnable() {          executor.execute(new Runnable() {
671              public void run() {              public void run() {
672                  try {                  try {
673                      Thread.sleep(MEDIUM_DELAY_MS);                      Thread.sleep(SMALL_DELAY_MS);
674                      assertEquals("first item in queue should be 1", new Integer(1), q.take());                      threadAssertEquals(one, q.take());
675                  }                  }
676                  catch (InterruptedException e) {                  catch (InterruptedException e) {
677                      fail("should not be interrupted");                      threadFail("should not be interrupted");
678                  }                  }
679              }              }
680          });          });
681    
682          executor.shutdown();          joinPool(executor);
683    
684      }      }
685    
# Line 696  Line 691 
691    
692          executor.execute(new Runnable() {          executor.execute(new Runnable() {
693              public void run() {              public void run() {
694                  assertNull("poll should fail", q.poll());                  threadAssertNull(q.poll());
695                  try {                  try {
696                      assertTrue(null != q.poll(MEDIUM_DELAY_MS * 2, TimeUnit.MILLISECONDS));                      threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
697                      assertTrue(q.isEmpty());                      threadAssertTrue(q.isEmpty());
698                  }                  }
699                  catch (InterruptedException e) {                  catch (InterruptedException e) {
700                      fail("should not be interrupted");                      threadFail("should not be interrupted");
701                  }                  }
702              }              }
703          });          });
# Line 710  Line 705 
705          executor.execute(new Runnable() {          executor.execute(new Runnable() {
706              public void run() {              public void run() {
707                  try {                  try {
708                      Thread.sleep(MEDIUM_DELAY_MS);                      Thread.sleep(SMALL_DELAY_MS);
709                      q.put(new Integer(1));                      q.put(one);
710                  }                  }
711                  catch (InterruptedException e) {                  catch (InterruptedException e) {
712                      fail("should not be interrupted");                      threadFail("should not be interrupted");
713                  }                  }
714              }              }
715          });          });
716    
717          executor.shutdown();          joinPool(executor);
718    
719      }      }
720    
721      public void testSerialization() {      public void testSerialization() {
722          ArrayBlockingQueue q = fullQueue(N);          ArrayBlockingQueue q = populatedQueue(SIZE);
723    
724          try {          try {
725              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8