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.35 by jsr166, Fri May 27 20:07:24 2011 UTC vs.
Revision 1.50 by jsr166, Thu Oct 8 00:26:16 2015 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 – import junit.framework.*;
10 – import java.util.*;
11 – import java.util.concurrent.*;
9   import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 < import java.io.*;
10 >
11 > import java.util.ArrayList;
12 > import java.util.Arrays;
13 > import java.util.Collection;
14 > import java.util.Iterator;
15 > import java.util.NoSuchElementException;
16 > import java.util.concurrent.BlockingQueue;
17 > import java.util.concurrent.CountDownLatch;
18 > import java.util.concurrent.Executors;
19 > import java.util.concurrent.ExecutorService;
20 > import java.util.concurrent.SynchronousQueue;
21 >
22 > import junit.framework.Test;
23  
24   public class SynchronousQueueTest extends JSR166TestCase {
25  
# Line 27 | Line 36 | public class SynchronousQueueTest extend
36      }
37  
38      public static void main(String[] args) {
39 <        junit.textui.TestRunner.run(suite());
39 >        main(suite(), args);
40      }
41  
42      public static Test suite() {
# Line 50 | Line 59 | public class SynchronousQueueTest extend
59      }
60  
61      /**
53 –     * offer(null) throws NPE
54 –     */
55 –    public void testOfferNull() {
56 –        try {
57 –            SynchronousQueue q = new SynchronousQueue();
58 –            q.offer(null);
59 –            shouldThrow();
60 –        } catch (NullPointerException success) {}
61 –    }
62 –
63 –    /**
64 –     * add(null) throws NPE
65 –     */
66 –    public void testAddNull() {
67 –        try {
68 –            SynchronousQueue q = new SynchronousQueue();
69 –            q.add(null);
70 –            shouldThrow();
71 –        } catch (NullPointerException success) {}
72 –    }
73 –
74 –    /**
62       * offer fails if no active taker
63       */
64 <    public void testOffer() {
65 <        SynchronousQueue q = new SynchronousQueue();
64 >    public void testOffer()      { testOffer(false); }
65 >    public void testOffer_fair() { testOffer(true); }
66 >    public void testOffer(boolean fair) {
67 >        SynchronousQueue q = new SynchronousQueue(fair);
68          assertFalse(q.offer(one));
69      }
70  
71      /**
72 <     * add throws ISE if no active taker
72 >     * add throws IllegalStateException if no active taker
73       */
74 <    public void testAdd() {
74 >    public void testAdd()      { testAdd(false); }
75 >    public void testAdd_fair() { testAdd(true); }
76 >    public void testAdd(boolean fair) {
77 >        SynchronousQueue q = new SynchronousQueue(fair);
78 >        assertEquals(0, q.remainingCapacity());
79          try {
87 –            SynchronousQueue q = new SynchronousQueue();
88 –            assertEquals(0, q.remainingCapacity());
80              q.add(one);
81              shouldThrow();
82          } catch (IllegalStateException success) {}
83      }
84  
85      /**
86 <     * addAll(null) throws NPE
86 >     * addAll(this) throws IllegalArgumentException
87       */
88 <    public void testAddAll1() {
88 >    public void testAddAll_self()      { testAddAll_self(false); }
89 >    public void testAddAll_self_fair() { testAddAll_self(true); }
90 >    public void testAddAll_self(boolean fair) {
91 >        SynchronousQueue q = new SynchronousQueue(fair);
92          try {
99 –            SynchronousQueue q = new SynchronousQueue();
100 –            q.addAll(null);
101 –            shouldThrow();
102 –        } catch (NullPointerException success) {}
103 –    }
104 –
105 –    /**
106 –     * addAll(this) throws IAE
107 –     */
108 –    public void testAddAllSelf() {
109 –        try {
110 –            SynchronousQueue q = new SynchronousQueue();
93              q.addAll(q);
94              shouldThrow();
95          } catch (IllegalArgumentException success) {}
96      }
97  
98      /**
117 –     * addAll of a collection with null elements throws NPE
118 –     */
119 –    public void testAddAll2() {
120 –        try {
121 –            SynchronousQueue q = new SynchronousQueue();
122 –            Integer[] ints = new Integer[1];
123 –            q.addAll(Arrays.asList(ints));
124 –            shouldThrow();
125 –        } catch (NullPointerException success) {}
126 –    }
127 –
128 –    /**
99       * addAll throws ISE if no active taker
100       */
101 <    public void testAddAll4() {
101 >    public void testAddAll_ISE()      { testAddAll_ISE(false); }
102 >    public void testAddAll_ISE_fair() { testAddAll_ISE(true); }
103 >    public void testAddAll_ISE(boolean fair) {
104 >        SynchronousQueue q = new SynchronousQueue(fair);
105 >        Integer[] ints = new Integer[1];
106 >        for (int i = 0; i < ints.length; i++)
107 >            ints[i] = i;
108 >        Collection<Integer> coll = Arrays.asList(ints);
109          try {
110 <            SynchronousQueue q = new SynchronousQueue();
134 <            Integer[] ints = new Integer[1];
135 <            for (int i = 0; i < 1; ++i)
136 <                ints[i] = new Integer(i);
137 <            q.addAll(Arrays.asList(ints));
110 >            q.addAll(coll);
111              shouldThrow();
112          } catch (IllegalStateException success) {}
113      }
114  
115      /**
143 –     * put(null) throws NPE
144 –     */
145 –    public void testPutNull() throws InterruptedException {
146 –        try {
147 –            SynchronousQueue q = new SynchronousQueue();
148 –            q.put(null);
149 –            shouldThrow();
150 –        } catch (NullPointerException success) {}
151 –    }
152 –
153 –    /**
116       * put blocks interruptibly if no active taker
117       */
118      public void testBlockingPut()      { testBlockingPut(false); }
# Line 205 | Line 167 | public class SynchronousQueueTest extend
167              }});
168  
169          await(pleaseTake);
170 <        assertEquals(q.remainingCapacity(), 0);
170 >        assertEquals(0, q.remainingCapacity());
171          try { assertSame(one, q.take()); }
172          catch (InterruptedException e) { threadUnexpectedException(e); }
173  
# Line 213 | Line 175 | public class SynchronousQueueTest extend
175          assertThreadStaysAlive(t);
176          t.interrupt();
177          awaitTermination(t);
178 <        assertEquals(q.remainingCapacity(), 0);
178 >        assertEquals(0, q.remainingCapacity());
179      }
180  
181      /**
# Line 245 | Line 207 | public class SynchronousQueueTest extend
207      /**
208       * poll return null if no active putter
209       */
210 <    public void testPoll() {
211 <        SynchronousQueue q = new SynchronousQueue();
210 >    public void testPoll()      { testPoll(false); }
211 >    public void testPoll_fair() { testPoll(true); }
212 >    public void testPoll(boolean fair) {
213 >        final SynchronousQueue q = new SynchronousQueue(fair);
214          assertNull(q.poll());
215      }
216  
217      /**
218       * timed poll with zero timeout times out if no active putter
219       */
220 <    public void testTimedPoll0() throws InterruptedException {
221 <        SynchronousQueue q = new SynchronousQueue();
222 <        assertNull(q.poll(0, MILLISECONDS));
220 >    public void testTimedPoll0()      { testTimedPoll0(false); }
221 >    public void testTimedPoll0_fair() { testTimedPoll0(true); }
222 >    public void testTimedPoll0(boolean fair) {
223 >        final SynchronousQueue q = new SynchronousQueue(fair);
224 >        try { assertNull(q.poll(0, MILLISECONDS)); }
225 >        catch (InterruptedException e) { threadUnexpectedException(e); }
226      }
227  
228      /**
229       * timed poll with nonzero timeout times out if no active putter
230       */
231 <    public void testTimedPoll() throws InterruptedException {
232 <        SynchronousQueue q = new SynchronousQueue();
231 >    public void testTimedPoll()      { testTimedPoll(false); }
232 >    public void testTimedPoll_fair() { testTimedPoll(true); }
233 >    public void testTimedPoll(boolean fair) {
234 >        final SynchronousQueue q = new SynchronousQueue(fair);
235          long startTime = System.nanoTime();
236 <        assertNull(q.poll(timeoutMillis(), MILLISECONDS));
236 >        try { assertNull(q.poll(timeoutMillis(), MILLISECONDS)); }
237 >        catch (InterruptedException e) { threadUnexpectedException(e); }
238          assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
239      }
240  
# Line 272 | Line 242 | public class SynchronousQueueTest extend
242       * timed poll before a delayed offer times out, returning null;
243       * after offer succeeds; on interruption throws
244       */
245 <    public void testFairTimedPollWithOffer() throws InterruptedException {
246 <        final SynchronousQueue q = new SynchronousQueue(true);
245 >    public void testTimedPollWithOffer()      { testTimedPollWithOffer(false); }
246 >    public void testTimedPollWithOffer_fair() { testTimedPollWithOffer(true); }
247 >    public void testTimedPollWithOffer(boolean fair) {
248 >        final SynchronousQueue q = new SynchronousQueue(fair);
249          final CountDownLatch pleaseOffer = new CountDownLatch(1);
250 +        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
251          Thread t = newStartedThread(new CheckedRunnable() {
252              public void realRun() throws InterruptedException {
253 <                long t0 = System.nanoTime();
254 <                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
255 <                assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
253 >                long startTime = System.nanoTime();
254 >                assertNull(q.poll(timeoutMillis(), MILLISECONDS));
255 >                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
256  
257                  pleaseOffer.countDown();
258 <                t0 = System.nanoTime();
258 >                startTime = System.nanoTime();
259                  assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
287 –                assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
260  
261 <                t0 = System.nanoTime();
261 >                Thread.currentThread().interrupt();
262 >                try {
263 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
264 >                    shouldThrow();
265 >                } catch (InterruptedException success) {}
266 >                assertFalse(Thread.interrupted());
267 >
268 >                pleaseInterrupt.countDown();
269                  try {
270                      q.poll(LONG_DELAY_MS, MILLISECONDS);
271                      shouldThrow();
272                  } catch (InterruptedException success) {}
273 <                assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
273 >                assertFalse(Thread.interrupted());
274 >
275 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
276              }});
277  
278 <        assertTrue(pleaseOffer.await(MEDIUM_DELAY_MS, MILLISECONDS));
279 <        long t0 = System.nanoTime();
280 <        assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS));
281 <        assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
278 >        await(pleaseOffer);
279 >        long startTime = System.nanoTime();
280 >        try { assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS)); }
281 >        catch (InterruptedException e) { threadUnexpectedException(e); }
282 >        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
283  
284 +        await(pleaseInterrupt);
285 +        assertThreadStaysAlive(t);
286          t.interrupt();
287 <        awaitTermination(t, MEDIUM_DELAY_MS);
287 >        awaitTermination(t);
288      }
289  
290      /**
291       * peek() returns null if no active putter
292       */
293 <    public void testPeek() {
294 <        SynchronousQueue q = new SynchronousQueue();
293 >    public void testPeek()      { testPeek(false); }
294 >    public void testPeek_fair() { testPeek(true); }
295 >    public void testPeek(boolean fair) {
296 >        final SynchronousQueue q = new SynchronousQueue(fair);
297          assertNull(q.peek());
298      }
299  
300      /**
301 <     * element() throws NSEE if no active putter
301 >     * element() throws NoSuchElementException if no active putter
302       */
303 <    public void testElement() {
304 <        SynchronousQueue q = new SynchronousQueue();
303 >    public void testElement()      { testElement(false); }
304 >    public void testElement_fair() { testElement(true); }
305 >    public void testElement(boolean fair) {
306 >        final SynchronousQueue q = new SynchronousQueue(fair);
307          try {
308              q.element();
309              shouldThrow();
# Line 323 | Line 311 | public class SynchronousQueueTest extend
311      }
312  
313      /**
314 <     * remove() throws NSEE if no active putter
314 >     * remove() throws NoSuchElementException if no active putter
315       */
316 <    public void testRemove() {
317 <        SynchronousQueue q = new SynchronousQueue();
316 >    public void testRemove()      { testRemove(false); }
317 >    public void testRemove_fair() { testRemove(true); }
318 >    public void testRemove(boolean fair) {
319 >        final SynchronousQueue q = new SynchronousQueue(fair);
320          try {
321              q.remove();
322              shouldThrow();
# Line 334 | Line 324 | public class SynchronousQueueTest extend
324      }
325  
326      /**
337 –     * remove(x) returns false
338 –     */
339 –    public void testRemoveElement() {
340 –        SynchronousQueue q = new SynchronousQueue();
341 –        assertFalse(q.remove(zero));
342 –        assertTrue(q.isEmpty());
343 –    }
344 –
345 –    /**
327       * contains returns false
328       */
329 <    public void testContains() {
330 <        SynchronousQueue q = new SynchronousQueue();
329 >    public void testContains()      { testContains(false); }
330 >    public void testContains_fair() { testContains(true); }
331 >    public void testContains(boolean fair) {
332 >        final SynchronousQueue q = new SynchronousQueue(fair);
333          assertFalse(q.contains(zero));
334      }
335  
336      /**
337       * clear ensures isEmpty
338       */
339 <    public void testClear() {
340 <        SynchronousQueue q = new SynchronousQueue();
339 >    public void testClear()      { testClear(false); }
340 >    public void testClear_fair() { testClear(true); }
341 >    public void testClear(boolean fair) {
342 >        final SynchronousQueue q = new SynchronousQueue(fair);
343          q.clear();
344          assertTrue(q.isEmpty());
345      }
# Line 362 | Line 347 | public class SynchronousQueueTest extend
347      /**
348       * containsAll returns false unless empty
349       */
350 <    public void testContainsAll() {
351 <        SynchronousQueue q = new SynchronousQueue();
350 >    public void testContainsAll()      { testContainsAll(false); }
351 >    public void testContainsAll_fair() { testContainsAll(true); }
352 >    public void testContainsAll(boolean fair) {
353 >        final SynchronousQueue q = new SynchronousQueue(fair);
354          Integer[] empty = new Integer[0];
355          assertTrue(q.containsAll(Arrays.asList(empty)));
356          Integer[] ints = new Integer[1]; ints[0] = zero;
# Line 373 | Line 360 | public class SynchronousQueueTest extend
360      /**
361       * retainAll returns false
362       */
363 <    public void testRetainAll() {
364 <        SynchronousQueue q = new SynchronousQueue();
363 >    public void testRetainAll()      { testRetainAll(false); }
364 >    public void testRetainAll_fair() { testRetainAll(true); }
365 >    public void testRetainAll(boolean fair) {
366 >        final SynchronousQueue q = new SynchronousQueue(fair);
367          Integer[] empty = new Integer[0];
368          assertFalse(q.retainAll(Arrays.asList(empty)));
369          Integer[] ints = new Integer[1]; ints[0] = zero;
# Line 384 | Line 373 | public class SynchronousQueueTest extend
373      /**
374       * removeAll returns false
375       */
376 <    public void testRemoveAll() {
377 <        SynchronousQueue q = new SynchronousQueue();
376 >    public void testRemoveAll()      { testRemoveAll(false); }
377 >    public void testRemoveAll_fair() { testRemoveAll(true); }
378 >    public void testRemoveAll(boolean fair) {
379 >        final SynchronousQueue q = new SynchronousQueue(fair);
380          Integer[] empty = new Integer[0];
381          assertFalse(q.removeAll(Arrays.asList(empty)));
382          Integer[] ints = new Integer[1]; ints[0] = zero;
# Line 395 | Line 386 | public class SynchronousQueueTest extend
386      /**
387       * toArray is empty
388       */
389 <    public void testToArray() {
390 <        SynchronousQueue q = new SynchronousQueue();
389 >    public void testToArray()      { testToArray(false); }
390 >    public void testToArray_fair() { testToArray(true); }
391 >    public void testToArray(boolean fair) {
392 >        final SynchronousQueue q = new SynchronousQueue(fair);
393          Object[] o = q.toArray();
394 <        assertEquals(o.length, 0);
394 >        assertEquals(0, o.length);
395      }
396  
397      /**
398 <     * toArray(a) is nulled at position 0
398 >     * toArray(Integer array) returns its argument with the first
399 >     * element (if present) nulled out
400       */
401 <    public void testToArray2() {
402 <        SynchronousQueue q = new SynchronousQueue();
403 <        Integer[] ints = new Integer[1];
404 <        assertNull(ints[0]);
401 >    public void testToArray2()      { testToArray2(false); }
402 >    public void testToArray2_fair() { testToArray2(true); }
403 >    public void testToArray2(boolean fair) {
404 >        final SynchronousQueue<Integer> q
405 >            = new SynchronousQueue<Integer>(fair);
406 >        Integer[] a;
407 >
408 >        a = new Integer[0];
409 >        assertSame(a, q.toArray(a));
410 >
411 >        a = new Integer[3];
412 >        Arrays.fill(a, 42);
413 >        assertSame(a, q.toArray(a));
414 >        assertNull(a[0]);
415 >        for (int i = 1; i < a.length; i++)
416 >            assertEquals(42, (int) a[i]);
417      }
418  
419      /**
420       * toArray(null) throws NPE
421       */
422 <    public void testToArray_BadArg() {
423 <        SynchronousQueue q = new SynchronousQueue();
422 >    public void testToArray_null()      { testToArray_null(false); }
423 >    public void testToArray_null_fair() { testToArray_null(true); }
424 >    public void testToArray_null(boolean fair) {
425 >        final SynchronousQueue q = new SynchronousQueue(fair);
426          try {
427 <            Object o[] = q.toArray(null);
427 >            Object[] o = q.toArray(null);
428              shouldThrow();
429          } catch (NullPointerException success) {}
430      }
# Line 424 | Line 432 | public class SynchronousQueueTest extend
432      /**
433       * iterator does not traverse any elements
434       */
435 <    public void testIterator() {
436 <        SynchronousQueue q = new SynchronousQueue();
437 <        Iterator it = q.iterator();
438 <        assertFalse(it.hasNext());
431 <        try {
432 <            Object x = it.next();
433 <            shouldThrow();
434 <        } catch (NoSuchElementException success) {}
435 >    public void testIterator()      { testIterator(false); }
436 >    public void testIterator_fair() { testIterator(true); }
437 >    public void testIterator(boolean fair) {
438 >        assertIteratorExhausted(new SynchronousQueue(fair).iterator());
439      }
440  
441      /**
442       * iterator remove throws ISE
443       */
444 <    public void testIteratorRemove() {
445 <        SynchronousQueue q = new SynchronousQueue();
444 >    public void testIteratorRemove()      { testIteratorRemove(false); }
445 >    public void testIteratorRemove_fair() { testIteratorRemove(true); }
446 >    public void testIteratorRemove(boolean fair) {
447 >        final SynchronousQueue q = new SynchronousQueue(fair);
448          Iterator it = q.iterator();
449          try {
450              it.remove();
# Line 449 | Line 455 | public class SynchronousQueueTest extend
455      /**
456       * toString returns a non-null string
457       */
458 <    public void testToString() {
459 <        SynchronousQueue q = new SynchronousQueue();
458 >    public void testToString()      { testToString(false); }
459 >    public void testToString_fair() { testToString(true); }
460 >    public void testToString(boolean fair) {
461 >        final SynchronousQueue q = new SynchronousQueue(fair);
462          String s = q.toString();
463          assertNotNull(s);
464      }
# Line 458 | Line 466 | public class SynchronousQueueTest extend
466      /**
467       * offer transfers elements across Executor tasks
468       */
469 <    public void testOfferInExecutor() {
470 <        final SynchronousQueue q = new SynchronousQueue();
471 <        ExecutorService executor = Executors.newFixedThreadPool(2);
469 >    public void testOfferInExecutor()      { testOfferInExecutor(false); }
470 >    public void testOfferInExecutor_fair() { testOfferInExecutor(true); }
471 >    public void testOfferInExecutor(boolean fair) {
472 >        final SynchronousQueue q = new SynchronousQueue(fair);
473          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
474 +        final ExecutorService executor = Executors.newFixedThreadPool(2);
475 +        try (PoolCleaner cleaner = cleaner(executor)) {
476  
477 <        executor.execute(new CheckedRunnable() {
478 <            public void realRun() throws InterruptedException {
479 <                assertFalse(q.offer(one));
480 <                threadsStarted.await();
481 <                assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
482 <                assertEquals(0, q.remainingCapacity());
483 <            }});
484 <
485 <        executor.execute(new CheckedRunnable() {
486 <            public void realRun() throws InterruptedException {
487 <                threadsStarted.await();
488 <                assertSame(one, q.take());
489 <            }});
490 <
480 <        joinPool(executor);
477 >            executor.execute(new CheckedRunnable() {
478 >                public void realRun() throws InterruptedException {
479 >                    assertFalse(q.offer(one));
480 >                    threadsStarted.await();
481 >                    assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
482 >                    assertEquals(0, q.remainingCapacity());
483 >                }});
484 >
485 >            executor.execute(new CheckedRunnable() {
486 >                public void realRun() throws InterruptedException {
487 >                    threadsStarted.await();
488 >                    assertSame(one, q.take());
489 >                }});
490 >        }
491      }
492  
493      /**
494       * timed poll retrieves elements across Executor threads
495       */
496 <    public void testPollInExecutor() {
497 <        final SynchronousQueue q = new SynchronousQueue();
496 >    public void testPollInExecutor()      { testPollInExecutor(false); }
497 >    public void testPollInExecutor_fair() { testPollInExecutor(true); }
498 >    public void testPollInExecutor(boolean fair) {
499 >        final SynchronousQueue q = new SynchronousQueue(fair);
500          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
501 <        ExecutorService executor = Executors.newFixedThreadPool(2);
502 <        executor.execute(new CheckedRunnable() {
503 <            public void realRun() throws InterruptedException {
504 <                assertNull(q.poll());
505 <                threadsStarted.await();
506 <                assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
507 <                assertTrue(q.isEmpty());
508 <            }});
509 <
510 <        executor.execute(new CheckedRunnable() {
511 <            public void realRun() throws InterruptedException {
512 <                threadsStarted.await();
513 <                q.put(one);
514 <            }});
515 <
516 <        joinPool(executor);
501 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
502 >        try (PoolCleaner cleaner = cleaner(executor)) {
503 >            executor.execute(new CheckedRunnable() {
504 >                public void realRun() throws InterruptedException {
505 >                    assertNull(q.poll());
506 >                    threadsStarted.await();
507 >                    assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
508 >                    assertTrue(q.isEmpty());
509 >                }});
510 >
511 >            executor.execute(new CheckedRunnable() {
512 >                public void realRun() throws InterruptedException {
513 >                    threadsStarted.await();
514 >                    q.put(one);
515 >                }});
516 >        }
517      }
518  
519      /**
520       * a deserialized serialized queue is usable
521       */
522 <    public void testSerialization() throws Exception {
523 <        SynchronousQueue q = new SynchronousQueue();
524 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
525 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
526 <        out.writeObject(q);
527 <        out.close();
528 <
529 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
530 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
531 <        SynchronousQueue r = (SynchronousQueue)in.readObject();
532 <        assertEquals(q.size(), r.size());
533 <        while (!q.isEmpty())
534 <            assertEquals(q.remove(), r.remove());
535 <    }
536 <
537 <    /**
526 <     * drainTo(null) throws NPE
527 <     */
528 <    public void testDrainToNull() {
529 <        SynchronousQueue q = new SynchronousQueue();
530 <        try {
531 <            q.drainTo(null);
532 <            shouldThrow();
533 <        } catch (NullPointerException success) {}
534 <    }
535 <
536 <    /**
537 <     * drainTo(this) throws IAE
538 <     */
539 <    public void testDrainToSelf() {
540 <        SynchronousQueue q = new SynchronousQueue();
541 <        try {
542 <            q.drainTo(q);
543 <            shouldThrow();
544 <        } catch (IllegalArgumentException success) {}
522 >    public void testSerialization() {
523 >        final SynchronousQueue x = new SynchronousQueue();
524 >        final SynchronousQueue y = new SynchronousQueue(false);
525 >        final SynchronousQueue z = new SynchronousQueue(true);
526 >        assertSerialEquals(x, y);
527 >        assertNotSerialEquals(x, z);
528 >        SynchronousQueue[] qs = { x, y, z };
529 >        for (SynchronousQueue q : qs) {
530 >            SynchronousQueue clone = serialClone(q);
531 >            assertNotSame(q, clone);
532 >            assertSerialEquals(q, clone);
533 >            assertTrue(clone.isEmpty());
534 >            assertEquals(0, clone.size());
535 >            assertEquals(0, clone.remainingCapacity());
536 >            assertFalse(clone.offer(zero));
537 >        }
538      }
539  
540      /**
541       * drainTo(c) of empty queue doesn't transfer elements
542       */
543 <    public void testDrainTo() {
544 <        SynchronousQueue q = new SynchronousQueue();
543 >    public void testDrainTo()      { testDrainTo(false); }
544 >    public void testDrainTo_fair() { testDrainTo(true); }
545 >    public void testDrainTo(boolean fair) {
546 >        final SynchronousQueue q = new SynchronousQueue(fair);
547          ArrayList l = new ArrayList();
548          q.drainTo(l);
549 <        assertEquals(q.size(), 0);
550 <        assertEquals(l.size(), 0);
549 >        assertEquals(0, q.size());
550 >        assertEquals(0, l.size());
551      }
552  
553      /**
554       * drainTo empties queue, unblocking a waiting put.
555       */
556 <    public void testDrainToWithActivePut() throws InterruptedException {
557 <        final SynchronousQueue q = new SynchronousQueue();
556 >    public void testDrainToWithActivePut()      { testDrainToWithActivePut(false); }
557 >    public void testDrainToWithActivePut_fair() { testDrainToWithActivePut(true); }
558 >    public void testDrainToWithActivePut(boolean fair) {
559 >        final SynchronousQueue q = new SynchronousQueue(fair);
560          Thread t = newStartedThread(new CheckedRunnable() {
561              public void realRun() throws InterruptedException {
562                  q.put(one);
# Line 579 | Line 576 | public class SynchronousQueueTest extend
576      }
577  
578      /**
582 –     * drainTo(null, n) throws NPE
583 –     */
584 –    public void testDrainToNullN() {
585 –        SynchronousQueue q = new SynchronousQueue();
586 –        try {
587 –            q.drainTo(null, 0);
588 –            shouldThrow();
589 –        } catch (NullPointerException success) {}
590 –    }
591 –
592 –    /**
593 –     * drainTo(this, n) throws IAE
594 –     */
595 –    public void testDrainToSelfN() {
596 –        SynchronousQueue q = new SynchronousQueue();
597 –        try {
598 –            q.drainTo(q, 0);
599 –            shouldThrow();
600 –        } catch (IllegalArgumentException success) {}
601 –    }
602 –
603 –    /**
579       * drainTo(c, n) empties up to n elements of queue into c
580       */
581      public void testDrainToN() throws InterruptedException {
# Line 616 | Line 591 | public class SynchronousQueueTest extend
591              }});
592  
593          ArrayList l = new ArrayList();
594 <        delay(SHORT_DELAY_MS);
595 <        q.drainTo(l, 1);
594 >        int drained;
595 >        while ((drained = q.drainTo(l, 1)) == 0) Thread.yield();
596 >        assertEquals(1, drained);
597          assertEquals(1, l.size());
598 <        q.drainTo(l, 1);
598 >        while ((drained = q.drainTo(l, 1)) == 0) Thread.yield();
599 >        assertEquals(1, drained);
600          assertEquals(2, l.size());
601          assertTrue(l.contains(one));
602          assertTrue(l.contains(two));
# Line 627 | Line 604 | public class SynchronousQueueTest extend
604          awaitTermination(t2);
605      }
606  
607 +    /**
608 +     * remove(null), contains(null) always return false
609 +     */
610 +    public void testNeverContainsNull() {
611 +        Collection<?> q = new SynchronousQueue();
612 +        assertFalse(q.contains(null));
613 +        assertFalse(q.remove(null));
614 +    }
615 +
616   }

Diff Legend

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