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.68 by dl, Tue Jan 26 13:33:06 2021 UTC vs.
Revision 1.69 by jsr166, Wed Jan 27 01:57:24 2021 UTC

# Line 51 | Line 51 | public class SynchronousQueueTest extend
51      public void testEmptyFull()      { testEmptyFull(false); }
52      public void testEmptyFull_fair() { testEmptyFull(true); }
53      public void testEmptyFull(boolean fair) {
54 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
54 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
55          assertTrue(q.isEmpty());
56          mustEqual(0, q.size());
57          mustEqual(0, q.remainingCapacity());
# Line 64 | Line 64 | public class SynchronousQueueTest extend
64      public void testOffer()      { testOffer(false); }
65      public void testOffer_fair() { testOffer(true); }
66      public void testOffer(boolean fair) {
67 <        SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
67 >        SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
68          assertFalse(q.offer(one));
69      }
70  
# Line 74 | Line 74 | public class SynchronousQueueTest extend
74      public void testAdd()      { testAdd(false); }
75      public void testAdd_fair() { testAdd(true); }
76      public void testAdd(boolean fair) {
77 <        SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
77 >        SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
78          mustEqual(0, q.remainingCapacity());
79          try {
80              q.add(one);
# Line 88 | Line 88 | public class SynchronousQueueTest extend
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<Item> q = new SynchronousQueue<Item>(fair);
91 >        SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
92          try {
93              q.addAll(q);
94              shouldThrow();
# Line 101 | Line 101 | public class SynchronousQueueTest extend
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<Item> q = new SynchronousQueue<Item>(fair);
104 >        SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
105          Item[] items = seqItems(1);
106          Collection<Item> coll = Arrays.asList(items);
107          try {
# Line 116 | Line 116 | public class SynchronousQueueTest extend
116      public void testBlockingPut()      { testBlockingPut(false); }
117      public void testBlockingPut_fair() { testBlockingPut(true); }
118      public void testBlockingPut(boolean fair) {
119 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
119 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
120          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
121          Thread t = newStartedThread(new CheckedRunnable() {
122              public void realRun() throws InterruptedException {
# Line 148 | Line 148 | public class SynchronousQueueTest extend
148      public void testPutWithTake()      { testPutWithTake(false); }
149      public void testPutWithTake_fair() { testPutWithTake(true); }
150      public void testPutWithTake(boolean fair) {
151 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
151 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
152          final CountDownLatch pleaseTake = new CountDownLatch(1);
153          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
154          Thread t = newStartedThread(new CheckedRunnable() {
# Line 188 | Line 188 | public class SynchronousQueueTest extend
188       */
189      public void testTimedOffer() {
190          final boolean fair = randomBoolean();
191 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
191 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
192          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
193          Thread t = newStartedThread(new CheckedRunnable() {
194              public void realRun() throws InterruptedException {
# Line 224 | Line 224 | public class SynchronousQueueTest extend
224      public void testPoll()      { testPoll(false); }
225      public void testPoll_fair() { testPoll(true); }
226      public void testPoll(boolean fair) {
227 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
227 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
228          assertNull(q.poll());
229      }
230  
# Line 234 | Line 234 | public class SynchronousQueueTest extend
234      public void testTimedPoll0()      { testTimedPoll0(false); }
235      public void testTimedPoll0_fair() { testTimedPoll0(true); }
236      public void testTimedPoll0(boolean fair) {
237 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
237 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
238          try { assertNull(q.poll(0, MILLISECONDS)); }
239          catch (InterruptedException e) { threadUnexpectedException(e); }
240      }
# Line 244 | Line 244 | public class SynchronousQueueTest extend
244       */
245      public void testTimedPoll() {
246          final boolean fair = randomBoolean();
247 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
247 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
248          final long startTime = System.nanoTime();
249          try { assertNull(q.poll(timeoutMillis(), MILLISECONDS)); }
250          catch (InterruptedException e) { threadUnexpectedException(e); }
# Line 257 | Line 257 | public class SynchronousQueueTest extend
257       */
258      public void testTimedPollWithOffer() {
259          final boolean fair = randomBoolean();
260 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
260 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
261          final CountDownLatch pleaseOffer = new CountDownLatch(1);
262          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
263          Thread t = newStartedThread(new CheckedRunnable() {
# Line 305 | Line 305 | public class SynchronousQueueTest extend
305      public void testPeek()      { testPeek(false); }
306      public void testPeek_fair() { testPeek(true); }
307      public void testPeek(boolean fair) {
308 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
308 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
309          assertNull(q.peek());
310      }
311  
# Line 315 | Line 315 | public class SynchronousQueueTest extend
315      public void testElement()      { testElement(false); }
316      public void testElement_fair() { testElement(true); }
317      public void testElement(boolean fair) {
318 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
318 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
319          try {
320              q.element();
321              shouldThrow();
# Line 328 | Line 328 | public class SynchronousQueueTest extend
328      public void testRemove()      { testRemove(false); }
329      public void testRemove_fair() { testRemove(true); }
330      public void testRemove(boolean fair) {
331 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
331 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
332          try {
333              q.remove();
334              shouldThrow();
# Line 341 | Line 341 | public class SynchronousQueueTest extend
341      public void testContains()      { testContains(false); }
342      public void testContains_fair() { testContains(true); }
343      public void testContains(boolean fair) {
344 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
344 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
345          assertFalse(q.contains(zero));
346      }
347  
# Line 351 | Line 351 | public class SynchronousQueueTest extend
351      public void testClear()      { testClear(false); }
352      public void testClear_fair() { testClear(true); }
353      public void testClear(boolean fair) {
354 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
354 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
355          q.clear();
356          assertTrue(q.isEmpty());
357      }
# Line 362 | Line 362 | public class SynchronousQueueTest extend
362      public void testContainsAll()      { testContainsAll(false); }
363      public void testContainsAll_fair() { testContainsAll(true); }
364      public void testContainsAll(boolean fair) {
365 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
365 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
366          Item[] empty = new Item[0];
367          assertTrue(q.containsAll(Arrays.asList(empty)));
368          Item[] items = new Item[1]; items[0] = zero;
# Line 375 | Line 375 | public class SynchronousQueueTest extend
375      public void testRetainAll()      { testRetainAll(false); }
376      public void testRetainAll_fair() { testRetainAll(true); }
377      public void testRetainAll(boolean fair) {
378 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
378 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
379          Item[] empty = new Item[0];
380          assertFalse(q.retainAll(Arrays.asList(empty)));
381          Item[] items = new Item[1]; items[0] = zero;
# Line 388 | Line 388 | public class SynchronousQueueTest extend
388      public void testRemoveAll()      { testRemoveAll(false); }
389      public void testRemoveAll_fair() { testRemoveAll(true); }
390      public void testRemoveAll(boolean fair) {
391 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
391 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
392          Item[] empty = new Item[0];
393          assertFalse(q.removeAll(Arrays.asList(empty)));
394          Item[] items = new Item[1]; items[0] = zero;
# Line 401 | Line 401 | public class SynchronousQueueTest extend
401      public void testToArray()      { testToArray(false); }
402      public void testToArray_fair() { testToArray(true); }
403      public void testToArray(boolean fair) {
404 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
404 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
405          Object[] o = q.toArray();
406          mustEqual(0, o.length);
407      }
# Line 413 | Line 413 | public class SynchronousQueueTest extend
413      public void testToArray2()      { testToArray2(false); }
414      public void testToArray2_fair() { testToArray2(true); }
415      public void testToArray2(boolean fair) {
416 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
416 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
417          Item[] a;
418  
419          a = new Item[0];
# Line 433 | Line 433 | public class SynchronousQueueTest extend
433      public void testToArray_null()      { testToArray_null(false); }
434      public void testToArray_null_fair() { testToArray_null(true); }
435      public void testToArray_null(boolean fair) {
436 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
436 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
437          try {
438              Object[] unused = q.toArray((Object[])null);
439              shouldThrow();
# Line 455 | Line 455 | public class SynchronousQueueTest extend
455      public void testIteratorRemove()      { testIteratorRemove(false); }
456      public void testIteratorRemove_fair() { testIteratorRemove(true); }
457      public void testIteratorRemove(boolean fair) {
458 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
458 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
459          Iterator<? extends Item> it = q.iterator();
460          try {
461              it.remove();
# Line 469 | Line 469 | public class SynchronousQueueTest extend
469      public void testToString()      { testToString(false); }
470      public void testToString_fair() { testToString(true); }
471      public void testToString(boolean fair) {
472 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
472 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
473          String s = q.toString();
474          assertNotNull(s);
475      }
# Line 480 | Line 480 | public class SynchronousQueueTest extend
480      public void testOfferInExecutor()      { testOfferInExecutor(false); }
481      public void testOfferInExecutor_fair() { testOfferInExecutor(true); }
482      public void testOfferInExecutor(boolean fair) {
483 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
483 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
484          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
485          final ExecutorService executor = Executors.newFixedThreadPool(2);
486          try (PoolCleaner cleaner = cleaner(executor)) {
# Line 507 | Line 507 | public class SynchronousQueueTest extend
507      public void testPollInExecutor()      { testPollInExecutor(false); }
508      public void testPollInExecutor_fair() { testPollInExecutor(true); }
509      public void testPollInExecutor(boolean fair) {
510 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
510 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
511          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
512          final ExecutorService executor = Executors.newFixedThreadPool(2);
513          try (PoolCleaner cleaner = cleaner(executor)) {
# Line 531 | Line 531 | public class SynchronousQueueTest extend
531       * a deserialized/reserialized queue is usable
532       */
533      public void testSerialization() {
534 <        final SynchronousQueue<Item> x = new SynchronousQueue<Item>();
535 <        final SynchronousQueue<Item> y = new SynchronousQueue<Item>(false);
536 <        final SynchronousQueue<Item> z = new SynchronousQueue<Item>(true);
534 >        final SynchronousQueue<Item> x = new SynchronousQueue<>();
535 >        final SynchronousQueue<Item> y = new SynchronousQueue<>(false);
536 >        final SynchronousQueue<Item> z = new SynchronousQueue<>(true);
537          assertSerialEquals(x, y);
538          assertNotSerialEquals(x, z);
539          SynchronousQueue[] rqs = { x, y, z };
# Line 556 | Line 556 | public class SynchronousQueueTest extend
556      public void testDrainTo()      { testDrainTo(false); }
557      public void testDrainTo_fair() { testDrainTo(true); }
558      public void testDrainTo(boolean fair) {
559 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
560 <        ArrayList<Item> l = new ArrayList<Item>();
559 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
560 >        ArrayList<Item> l = new ArrayList<>();
561          q.drainTo(l);
562          mustEqual(0, q.size());
563          mustEqual(0, l.size());
# Line 569 | Line 569 | public class SynchronousQueueTest extend
569      public void testDrainToWithActivePut()      { testDrainToWithActivePut(false); }
570      public void testDrainToWithActivePut_fair() { testDrainToWithActivePut(true); }
571      public void testDrainToWithActivePut(boolean fair) {
572 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
572 >        final SynchronousQueue<Item> q = new SynchronousQueue<>(fair);
573          Thread t = newStartedThread(new CheckedRunnable() {
574              public void realRun() throws InterruptedException {
575                  q.put(one);
576              }});
577  
578 <        ArrayList<Item> l = new ArrayList<Item>();
578 >        ArrayList<Item> l = new ArrayList<>();
579          long startTime = System.nanoTime();
580          while (l.isEmpty()) {
581              q.drainTo(l);
# Line 592 | Line 592 | public class SynchronousQueueTest extend
592       * drainTo(c, n) empties up to n elements of queue into c
593       */
594      public void testDrainToN() throws InterruptedException {
595 <        final SynchronousQueue<Item> q = new SynchronousQueue<Item>();
595 >        final SynchronousQueue<Item> q = new SynchronousQueue<>();
596          Thread t1 = newStartedThread(new CheckedRunnable() {
597              public void realRun() throws InterruptedException {
598                  q.put(one);
# Line 603 | Line 603 | public class SynchronousQueueTest extend
603                  q.put(two);
604              }});
605  
606 <        ArrayList<Item> l = new ArrayList<Item>();
606 >        ArrayList<Item> l = new ArrayList<>();
607          int drained;
608          while ((drained = q.drainTo(l, 1)) == 0) Thread.yield();
609          mustEqual(1, drained);
# Line 621 | Line 621 | public class SynchronousQueueTest extend
621       * remove(null), contains(null) always return false
622       */
623      public void testNeverContainsNull() {
624 <        Collection<?> q = new SynchronousQueue<Item>();
624 >        Collection<?> q = new SynchronousQueue<>();
625          assertFalse(q.contains(null));
626          assertFalse(q.remove(null));
627      }

Diff Legend

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