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

Comparing jsr166/src/test/tck/SynchronousQueueTest.java (file contents):
Revision 1.36 by jsr166, Sat May 28 13:40:20 2011 UTC vs.
Revision 1.43 by jsr166, Wed Dec 31 16:44:02 2014 UTC

# Line 7 | Line 7
7   */
8  
9   import junit.framework.*;
10 < import java.util.*;
11 < import java.util.concurrent.*;
10 > import java.util.Arrays;
11 > import java.util.ArrayList;
12 > import java.util.Collection;
13 > import java.util.Iterator;
14 > import java.util.NoSuchElementException;
15 > import java.util.concurrent.BlockingQueue;
16 > import java.util.concurrent.CountDownLatch;
17 > import java.util.concurrent.Executors;
18 > import java.util.concurrent.ExecutorService;
19 > import java.util.concurrent.SynchronousQueue;
20   import static java.util.concurrent.TimeUnit.MILLISECONDS;
13 – import java.io.*;
21  
22   public class SynchronousQueueTest extends JSR166TestCase {
23  
# Line 50 | Line 57 | public class SynchronousQueueTest extend
57      }
58  
59      /**
53 –     * offer(null) throws NullPointerException
54 –     */
55 –    public void testOfferNull()      { testOfferNull(false); }
56 –    public void testOfferNull_fair() { testOfferNull(true); }
57 –    public void testOfferNull(boolean fair) {
58 –        SynchronousQueue q = new SynchronousQueue(fair);
59 –        try {
60 –            q.offer(null);
61 –            shouldThrow();
62 –        } catch (NullPointerException success) {}
63 –    }
64 –
65 –    /**
66 –     * add(null) throws NullPointerException
67 –     */
68 –    public void testAddNull()      { testAddNull(false); }
69 –    public void testAddNull_fair() { testAddNull(true); }
70 –    public void testAddNull(boolean fair) {
71 –        SynchronousQueue q = new SynchronousQueue(fair);
72 –        try {
73 –            q.add(null);
74 –            shouldThrow();
75 –        } catch (NullPointerException success) {}
76 –    }
77 –
78 –    /**
60       * offer fails if no active taker
61       */
62      public void testOffer()      { testOffer(false); }
# Line 100 | Line 81 | public class SynchronousQueueTest extend
81      }
82  
83      /**
103 –     * addAll(null) throws NullPointerException
104 –     */
105 –    public void testAddAll_null()      { testAddAll_null(false); }
106 –    public void testAddAll_null_fair() { testAddAll_null(true); }
107 –    public void testAddAll_null(boolean fair) {
108 –        SynchronousQueue q = new SynchronousQueue(fair);
109 –        try {
110 –            q.addAll(null);
111 –            shouldThrow();
112 –        } catch (NullPointerException success) {}
113 –    }
114 –
115 –    /**
84       * addAll(this) throws IllegalArgumentException
85       */
86      public void testAddAll_self()      { testAddAll_self(false); }
# Line 126 | Line 94 | public class SynchronousQueueTest extend
94      }
95  
96      /**
129 –     * addAll of a collection with null elements throws NullPointerException
130 –     */
131 –    public void testAddAll_null2()      { testAddAll_null2(false); }
132 –    public void testAddAll_null2_fair() { testAddAll_null2(true); }
133 –    public void testAddAll_null2(boolean fair) {
134 –        SynchronousQueue q = new SynchronousQueue(fair);
135 –        Collection<Integer> ints = Arrays.asList(new Integer[1]);
136 –        try {
137 –            q.addAll(ints);
138 –            shouldThrow();
139 –        } catch (NullPointerException success) {}
140 –    }
141 –
142 –    /**
97       * addAll throws ISE if no active taker
98       */
99      public void testAddAll_ISE()      { testAddAll_ISE(false); }
# Line 157 | Line 111 | public class SynchronousQueueTest extend
111      }
112  
113      /**
160 –     * put(null) throws NPE
161 –     */
162 –    public void testPutNull() throws InterruptedException {
163 –        try {
164 –            SynchronousQueue q = new SynchronousQueue();
165 –            q.put(null);
166 –            shouldThrow();
167 –        } catch (NullPointerException success) {}
168 –    }
169 –
170 –    /**
114       * put blocks interruptibly if no active taker
115       */
116      public void testBlockingPut()      { testBlockingPut(false); }
# Line 222 | Line 165 | public class SynchronousQueueTest extend
165              }});
166  
167          await(pleaseTake);
168 <        assertEquals(q.remainingCapacity(), 0);
168 >        assertEquals(0, q.remainingCapacity());
169          try { assertSame(one, q.take()); }
170          catch (InterruptedException e) { threadUnexpectedException(e); }
171  
# Line 230 | Line 173 | public class SynchronousQueueTest extend
173          assertThreadStaysAlive(t);
174          t.interrupt();
175          awaitTermination(t);
176 <        assertEquals(q.remainingCapacity(), 0);
176 >        assertEquals(0, q.remainingCapacity());
177      }
178  
179      /**
# Line 378 | Line 321 | public class SynchronousQueueTest extend
321      }
322  
323      /**
381 –     * remove(x) returns false
382 –     */
383 –    public void testRemoveElement()      { testRemoveElement(false); }
384 –    public void testRemoveElement_fair() { testRemoveElement(true); }
385 –    public void testRemoveElement(boolean fair) {
386 –        final SynchronousQueue q = new SynchronousQueue(fair);
387 –        assertFalse(q.remove(zero));
388 –        assertTrue(q.isEmpty());
389 –    }
390 –
391 –    /**
324       * contains returns false
325       */
326      public void testContains()      { testContains(false); }
# Line 456 | Line 388 | public class SynchronousQueueTest extend
388      public void testToArray(boolean fair) {
389          final SynchronousQueue q = new SynchronousQueue(fair);
390          Object[] o = q.toArray();
391 <        assertEquals(o.length, 0);
391 >        assertEquals(0, o.length);
392      }
393  
394      /**
395 <     * toArray(a) is nulled at position 0
395 >     * toArray(Integer array) returns its argument with the first
396 >     * element (if present) nulled out
397       */
398      public void testToArray2()      { testToArray2(false); }
399      public void testToArray2_fair() { testToArray2(true); }
400      public void testToArray2(boolean fair) {
401 <        final SynchronousQueue q = new SynchronousQueue(fair);
402 <        Integer[] ints = new Integer[1];
403 <        assertNull(ints[0]);
401 >        final SynchronousQueue<Integer> q
402 >            = new SynchronousQueue<Integer>(fair);
403 >        Integer[] a;
404 >
405 >        a = new Integer[0];
406 >        assertSame(a, q.toArray(a));
407 >
408 >        a = new Integer[3];
409 >        Arrays.fill(a, 42);
410 >        assertSame(a, q.toArray(a));
411 >        assertNull(a[0]);
412 >        for (int i = 1; i < a.length; i++)
413 >            assertEquals(42, (int) a[i]);
414      }
415  
416      /**
# Line 579 | Line 522 | public class SynchronousQueueTest extend
522      /**
523       * a deserialized serialized queue is usable
524       */
525 <    public void testSerialization()      { testSerialization(false); }
526 <    public void testSerialization_fair() { testSerialization(true); }
527 <    public void testSerialization(boolean fair) {
528 <        final SynchronousQueue q = new SynchronousQueue(fair);
529 <        final SynchronousQueue r = serialClone(q);
530 <        assertTrue(q != r);
531 <        assertEquals(q.size(), r.size());
532 <        while (!q.isEmpty())
533 <            assertEquals(q.remove(), r.remove());
534 <    }
535 <
536 <    /**
537 <     * drainTo(null) throws NPE
538 <     */
539 <    public void testDrainToNull()      { testDrainToNull(false); }
540 <    public void testDrainToNull_fair() { testDrainToNull(true); }
598 <    public void testDrainToNull(boolean fair) {
599 <        final SynchronousQueue q = new SynchronousQueue(fair);
600 <        try {
601 <            q.drainTo(null);
602 <            shouldThrow();
603 <        } catch (NullPointerException success) {}
604 <    }
605 <
606 <    /**
607 <     * drainTo(this) throws IAE
608 <     */
609 <    public void testDrainToSelf()      { testDrainToSelf(false); }
610 <    public void testDrainToSelf_fair() { testDrainToSelf(true); }
611 <    public void testDrainToSelf(boolean fair) {
612 <        final SynchronousQueue q = new SynchronousQueue(fair);
613 <        try {
614 <            q.drainTo(q);
615 <            shouldThrow();
616 <        } catch (IllegalArgumentException success) {}
525 >    public void testSerialization() {
526 >        final SynchronousQueue x = new SynchronousQueue();
527 >        final SynchronousQueue y = new SynchronousQueue(false);
528 >        final SynchronousQueue z = new SynchronousQueue(true);
529 >        assertSerialEquals(x, y);
530 >        assertNotSerialEquals(x, z);
531 >        SynchronousQueue[] qs = { x, y, z };
532 >        for (SynchronousQueue q : qs) {
533 >            SynchronousQueue clone = serialClone(q);
534 >            assertNotSame(q, clone);
535 >            assertSerialEquals(q, clone);
536 >            assertTrue(clone.isEmpty());
537 >            assertEquals(0, clone.size());
538 >            assertEquals(0, clone.remainingCapacity());
539 >            assertFalse(clone.offer(zero));
540 >        }
541      }
542  
543      /**
# Line 625 | Line 549 | public class SynchronousQueueTest extend
549          final SynchronousQueue q = new SynchronousQueue(fair);
550          ArrayList l = new ArrayList();
551          q.drainTo(l);
552 <        assertEquals(q.size(), 0);
553 <        assertEquals(l.size(), 0);
552 >        assertEquals(0, q.size());
553 >        assertEquals(0, l.size());
554      }
555  
556      /**
# Line 655 | Line 579 | public class SynchronousQueueTest extend
579      }
580  
581      /**
658 –     * drainTo(null, n) throws NullPointerException
659 –     */
660 –    public void testDrainToNullN()      { testDrainToNullN(false); }
661 –    public void testDrainToNullN_fair() { testDrainToNullN(true); }
662 –    public void testDrainToNullN(boolean fair) {
663 –        final SynchronousQueue q = new SynchronousQueue(fair);
664 –        try {
665 –            q.drainTo(null, 0);
666 –            shouldThrow();
667 –        } catch (NullPointerException success) {}
668 –    }
669 –
670 –    /**
671 –     * drainTo(this, n) throws IllegalArgumentException
672 –     */
673 –    public void testDrainToSelfN()      { testDrainToSelfN(false); }
674 –    public void testDrainToSelfN_fair() { testDrainToSelfN(true); }
675 –    public void testDrainToSelfN(boolean fair) {
676 –        final SynchronousQueue q = new SynchronousQueue(fair);
677 –        try {
678 –            q.drainTo(q, 0);
679 –            shouldThrow();
680 –        } catch (IllegalArgumentException success) {}
681 –    }
682 –
683 –    /**
582       * drainTo(c, n) empties up to n elements of queue into c
583       */
584      public void testDrainToN() throws InterruptedException {
# Line 707 | Line 605 | public class SynchronousQueueTest extend
605          awaitTermination(t2);
606      }
607  
608 +    /**
609 +     * remove(null), contains(null) always return false
610 +     */
611 +    public void testNeverContainsNull() {
612 +        Collection<?> q = new SynchronousQueue();
613 +        assertFalse(q.contains(null));
614 +        assertFalse(q.remove(null));
615 +    }
616 +
617   }

Diff Legend

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