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.37 by jsr166, Mon May 30 22:43:20 2011 UTC vs.
Revision 1.46 by jsr166, Sat Jan 17 22:55:06 2015 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 < import junit.framework.*;
10 < import java.util.Arrays;
9 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
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;
# Line 17 | Line 18 | import java.util.concurrent.CountDownLat
18   import java.util.concurrent.Executors;
19   import java.util.concurrent.ExecutorService;
20   import java.util.concurrent.SynchronousQueue;
21 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
22 < import java.io.*;
21 >
22 > import junit.framework.Test;
23  
24   public class SynchronousQueueTest extends JSR166TestCase {
25  
# Line 166 | 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 174 | 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 322 | Line 323 | public class SynchronousQueueTest extend
323      }
324  
325      /**
325 –     * remove(x) returns false
326 –     */
327 –    public void testRemoveElement()      { testRemoveElement(false); }
328 –    public void testRemoveElement_fair() { testRemoveElement(true); }
329 –    public void testRemoveElement(boolean fair) {
330 –        final SynchronousQueue q = new SynchronousQueue(fair);
331 –        assertFalse(q.remove(zero));
332 –        assertTrue(q.isEmpty());
333 –    }
334 –
335 –    /**
326       * contains returns false
327       */
328      public void testContains()      { testContains(false); }
# Line 400 | Line 390 | public class SynchronousQueueTest extend
390      public void testToArray(boolean fair) {
391          final SynchronousQueue q = new SynchronousQueue(fair);
392          Object[] o = q.toArray();
393 <        assertEquals(o.length, 0);
393 >        assertEquals(0, o.length);
394      }
395  
396      /**
397 <     * toArray(a) is nulled at position 0
397 >     * toArray(Integer array) returns its argument with the first
398 >     * element (if present) nulled out
399       */
400      public void testToArray2()      { testToArray2(false); }
401      public void testToArray2_fair() { testToArray2(true); }
402      public void testToArray2(boolean fair) {
403 <        final SynchronousQueue q = new SynchronousQueue(fair);
404 <        Integer[] ints = new Integer[1];
405 <        assertNull(ints[0]);
403 >        final SynchronousQueue<Integer> q
404 >            = new SynchronousQueue<Integer>(fair);
405 >        Integer[] a;
406 >
407 >        a = new Integer[0];
408 >        assertSame(a, q.toArray(a));
409 >
410 >        a = new Integer[3];
411 >        Arrays.fill(a, 42);
412 >        assertSame(a, q.toArray(a));
413 >        assertNull(a[0]);
414 >        for (int i = 1; i < a.length; i++)
415 >            assertEquals(42, (int) a[i]);
416      }
417  
418      /**
# Line 422 | Line 423 | public class SynchronousQueueTest extend
423      public void testToArray_null(boolean fair) {
424          final SynchronousQueue q = new SynchronousQueue(fair);
425          try {
426 <            Object o[] = q.toArray(null);
426 >            Object[] o = q.toArray(null);
427              shouldThrow();
428          } catch (NullPointerException success) {}
429      }
# Line 433 | Line 434 | public class SynchronousQueueTest extend
434      public void testIterator()      { testIterator(false); }
435      public void testIterator_fair() { testIterator(true); }
436      public void testIterator(boolean fair) {
437 <        final SynchronousQueue q = new SynchronousQueue(fair);
437 <        Iterator it = q.iterator();
438 <        assertFalse(it.hasNext());
439 <        try {
440 <            Object x = it.next();
441 <            shouldThrow();
442 <        } catch (NoSuchElementException success) {}
437 >        assertIteratorExhausted(new SynchronousQueue(fair).iterator());
438      }
439  
440      /**
# Line 523 | Line 518 | public class SynchronousQueueTest extend
518      /**
519       * a deserialized serialized queue is usable
520       */
521 <    public void testSerialization()      { testSerialization(false); }
522 <    public void testSerialization_fair() { testSerialization(true); }
523 <    public void testSerialization(boolean fair) {
524 <        final SynchronousQueue q = new SynchronousQueue(fair);
525 <        final SynchronousQueue r = serialClone(q);
526 <        assertTrue(q != r);
527 <        assertEquals(q.size(), r.size());
528 <        while (!q.isEmpty())
529 <            assertEquals(q.remove(), r.remove());
521 >    public void testSerialization() {
522 >        final SynchronousQueue x = new SynchronousQueue();
523 >        final SynchronousQueue y = new SynchronousQueue(false);
524 >        final SynchronousQueue z = new SynchronousQueue(true);
525 >        assertSerialEquals(x, y);
526 >        assertNotSerialEquals(x, z);
527 >        SynchronousQueue[] qs = { x, y, z };
528 >        for (SynchronousQueue q : qs) {
529 >            SynchronousQueue clone = serialClone(q);
530 >            assertNotSame(q, clone);
531 >            assertSerialEquals(q, clone);
532 >            assertTrue(clone.isEmpty());
533 >            assertEquals(0, clone.size());
534 >            assertEquals(0, clone.remainingCapacity());
535 >            assertFalse(clone.offer(zero));
536 >        }
537      }
538  
539      /**
# Line 543 | Line 545 | public class SynchronousQueueTest extend
545          final SynchronousQueue q = new SynchronousQueue(fair);
546          ArrayList l = new ArrayList();
547          q.drainTo(l);
548 <        assertEquals(q.size(), 0);
549 <        assertEquals(l.size(), 0);
548 >        assertEquals(0, q.size());
549 >        assertEquals(0, l.size());
550      }
551  
552      /**
# Line 599 | Line 601 | public class SynchronousQueueTest extend
601          awaitTermination(t2);
602      }
603  
604 +    /**
605 +     * remove(null), contains(null) always return false
606 +     */
607 +    public void testNeverContainsNull() {
608 +        Collection<?> q = new SynchronousQueue();
609 +        assertFalse(q.contains(null));
610 +        assertFalse(q.remove(null));
611 +    }
612 +
613   }

Diff Legend

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