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

Comparing jsr166/src/test/tck/SubmissionPublisherTest.java (file contents):
Revision 1.5 by jsr166, Mon Sep 7 20:34:34 2015 UTC vs.
Revision 1.6 by jsr166, Mon Sep 7 20:53:10 2015 UTC

# Line 153 | Line 153 | public class SubmissionPublisherTest ext
153       */
154      void checkInitialState(SubmissionPublisher<?> p) {
155          assertFalse(p.hasSubscribers());
156 <        assertEquals(p.getNumberOfSubscribers(), 0);
156 >        assertEquals(0, p.getNumberOfSubscribers());
157          assertTrue(p.getSubscribers().isEmpty());
158          assertFalse(p.isClosed());
159          assertNull(p.getClosedException());
160          int n = p.getMaxBufferCapacity();
161          assertTrue((n & (n - 1)) == 0); // power of two
162          assertNotNull(p.getExecutor());
163 <        assertEquals(p.estimateMinimumDemand(), 0);
164 <        assertEquals(p.estimateMaximumLag(), 0);
163 >        assertEquals(0, p.estimateMinimumDemand());
164 >        assertEquals(0, p.estimateMaximumLag());
165      }
166  
167      /**
# Line 185 | Line 185 | public class SubmissionPublisherTest ext
185          SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(e, 8);
186          checkInitialState(p);
187          assertSame(p.getExecutor(), e);
188 <        assertEquals(p.getMaxBufferCapacity(), 8);
188 >        assertEquals(8, p.getMaxBufferCapacity());
189      }
190  
191      /**
# Line 264 | Line 264 | public class SubmissionPublisherTest ext
264          SubmissionPublisher<Integer> p = basicPublisher();
265          p.subscribe(s);
266          assertTrue(p.hasSubscribers());
267 <        assertEquals(p.getNumberOfSubscribers(), 1);
267 >        assertEquals(1, p.getNumberOfSubscribers());
268          assertTrue(p.getSubscribers().contains(s));
269          assertTrue(p.isSubscribed(s));
270          s.awaitSubscribe();
271          assertNotNull(s.sn);
272 <        assertEquals(s.nexts, 0);
273 <        assertEquals(s.errors, 0);
274 <        assertEquals(s.completes, 0);
272 >        assertEquals(0, s.nexts);
273 >        assertEquals(0, s.errors);
274 >        assertEquals(0, s.completes);
275          TestSubscriber s2 = new TestSubscriber();
276          p.subscribe(s2);
277          assertTrue(p.hasSubscribers());
278 <        assertEquals(p.getNumberOfSubscribers(), 2);
278 >        assertEquals(2, p.getNumberOfSubscribers());
279          assertTrue(p.getSubscribers().contains(s));
280          assertTrue(p.getSubscribers().contains(s2));
281          assertTrue(p.isSubscribed(s));
282          assertTrue(p.isSubscribed(s2));
283          s2.awaitSubscribe();
284          assertNotNull(s2.sn);
285 <        assertEquals(s2.nexts, 0);
286 <        assertEquals(s2.errors, 0);
287 <        assertEquals(s2.completes, 0);
285 >        assertEquals(0, s2.nexts);
286 >        assertEquals(0, s2.errors);
287 >        assertEquals(0, s2.completes);
288      }
289  
290      /**
# Line 297 | Line 297 | public class SubmissionPublisherTest ext
297          p.close();
298          p.subscribe(s);
299          s.awaitComplete();
300 <        assertEquals(s.nexts, 0);
301 <        assertEquals(s.errors, 0);
302 <        assertEquals(s.completes, 1);
300 >        assertEquals(0, s.nexts);
301 >        assertEquals(0, s.errors);
302 >        assertEquals(1, s.completes, 1);
303      }
304  
305      /**
# Line 315 | Line 315 | public class SubmissionPublisherTest ext
315          assertSame(p.getClosedException(), ex);
316          p.subscribe(s);
317          s.awaitError();
318 <        assertEquals(s.nexts, 0);
319 <        assertEquals(s.errors, 1);
318 >        assertEquals(0, s.nexts);
319 >        assertEquals(1, s.errors);
320      }
321  
322      /**
# Line 328 | Line 328 | public class SubmissionPublisherTest ext
328          SubmissionPublisher<Integer> p = basicPublisher();
329          p.subscribe(s);
330          assertTrue(p.hasSubscribers());
331 <        assertEquals(p.getNumberOfSubscribers(), 1);
331 >        assertEquals(1, p.getNumberOfSubscribers());
332          assertTrue(p.getSubscribers().contains(s));
333          assertTrue(p.isSubscribed(s));
334          s.awaitSubscribe();
335          assertNotNull(s.sn);
336 <        assertEquals(s.nexts, 0);
337 <        assertEquals(s.errors, 0);
338 <        assertEquals(s.completes, 0);
336 >        assertEquals(0, s.nexts);
337 >        assertEquals(0, s.errors);
338 >        assertEquals(0, s.completes);
339          p.subscribe(s);
340          s.awaitError();
341 <        assertEquals(s.nexts, 0);
342 <        assertEquals(s.errors, 1);
341 >        assertEquals(0, s.nexts);
342 >        assertEquals(1, s.errors);
343          assertFalse(p.isSubscribed(s));
344      }
345  
# Line 354 | Line 354 | public class SubmissionPublisherTest ext
354              p.subscribe(s);
355          } catch (Exception ok) {}
356          s.awaitError();
357 <        assertEquals(s.nexts, 0);
358 <        assertEquals(s.errors, 1);
359 <        assertEquals(s.completes, 0);
357 >        assertEquals(0, s.nexts);
358 >        assertEquals(1, s.errors);
359 >        assertEquals(0, s.completes);
360      }
361  
362      /**
# Line 385 | Line 385 | public class SubmissionPublisherTest ext
385          assertTrue(p.isClosed());
386          assertNull(p.getClosedException());
387          s1.awaitComplete();
388 <        assertEquals(s1.nexts, 1);
389 <        assertEquals(s1.completes, 1);
388 >        assertEquals(1, s1.nexts);
389 >        assertEquals(1, s1.completes);
390          s2.awaitComplete();
391 <        assertEquals(s2.nexts, 1);
392 <        assertEquals(s2.completes, 1);
391 >        assertEquals(1, s2.nexts);
392 >        assertEquals(1, s2.completes);
393      }
394  
395      /**
# Line 406 | Line 406 | public class SubmissionPublisherTest ext
406          assertTrue(p.isClosed());
407          s1.awaitError();
408          assertTrue(s1.nexts <= 1);
409 <        assertEquals(s1.errors, 1);
409 >        assertEquals(1, s1.errors);
410          s2.awaitError();
411          assertTrue(s2.nexts <= 1);
412 <        assertEquals(s2.errors, 1);
412 >        assertEquals(1, s2.errors);
413      }
414  
415      /**
# Line 428 | Line 428 | public class SubmissionPublisherTest ext
428              p.submit(i);
429          p.close();
430          s2.awaitComplete();
431 <        assertEquals(s2.nexts, 20);
432 <        assertEquals(s2.completes, 1);
431 >        assertEquals(20, s2.nexts);
432 >        assertEquals(1, s2.completes);
433          assertTrue(s1.nexts < 20);
434          assertFalse(p.isSubscribed(s1));
435      }
# Line 449 | Line 449 | public class SubmissionPublisherTest ext
449          p.submit(2);
450          p.close();
451          s2.awaitComplete();
452 <        assertEquals(s2.nexts, 2);
452 >        assertEquals(2, s2.nexts);
453          s1.awaitComplete();
454 <        assertEquals(s1.errors, 1);
454 >        assertEquals(1, s1.errors);
455      }
456  
457      /**
# Line 473 | Line 473 | public class SubmissionPublisherTest ext
473          p.submit(2);
474          p.close();
475          s2.awaitComplete();
476 <        assertEquals(s2.nexts, 2);
477 <        assertEquals(s2.completes, 1);
476 >        assertEquals(2, s2.nexts);
477 >        assertEquals(1, s2.completes);
478          s1.awaitError();
479 <        assertEquals(s1.errors, 1);
480 <        assertEquals(calls.get(), 1);
479 >        assertEquals(1, s1.errors);
480 >        assertEquals(1, calls.get());
481      }
482  
483      /**
# Line 494 | Line 494 | public class SubmissionPublisherTest ext
494          p.close();
495          s2.awaitComplete();
496          s1.awaitComplete();
497 <        assertEquals(s2.nexts, 20);
498 <        assertEquals(s2.completes, 1);
499 <        assertEquals(s1.nexts, 20);
500 <        assertEquals(s1.completes, 1);
497 >        assertEquals(20, s2.nexts);
498 >        assertEquals(1, s2.completes);
499 >        assertEquals(20, s1.nexts);
500 >        assertEquals(1, s1.completes);
501      }
502  
503      /**
# Line 515 | Line 515 | public class SubmissionPublisherTest ext
515          p.submit(1);
516          p.submit(2);
517          s2.awaitNext(1);
518 <        assertEquals(s1.nexts, 0);
518 >        assertEquals(0, s1.nexts);
519          s1.sn.request(3);
520          p.submit(3);
521          p.close();
522          s2.awaitComplete();
523 <        assertEquals(s2.nexts, 3);
524 <        assertEquals(s2.completes, 1);
523 >        assertEquals(3, s2.nexts);
524 >        assertEquals(1, s2.completes);
525          s1.awaitComplete();
526          assertTrue(s1.nexts > 0);
527 <        assertEquals(s1.completes, 1);
527 >        assertEquals(1, s1.completes);
528      }
529  
530      /**
# Line 543 | Line 543 | public class SubmissionPublisherTest ext
543          p.submit(2);
544          p.close();
545          s2.awaitComplete();
546 <        assertEquals(s2.nexts, 2);
547 <        assertEquals(s2.completes, 1);
546 >        assertEquals(2, s2.nexts);
547 >        assertEquals(1, s2.completes);
548          s1.awaitNext(1);
549 <        assertEquals(s1.nexts, 1);
549 >        assertEquals(1, s1.nexts);
550      }
551  
552      /**
# Line 565 | Line 565 | public class SubmissionPublisherTest ext
565          p.submit(2);
566          p.close();
567          s2.awaitComplete();
568 <        assertEquals(s2.nexts, 2);
569 <        assertEquals(s2.completes, 1);
568 >        assertEquals(2, s2.nexts);
569 >        assertEquals(1, s2.completes);
570          s1.awaitError();
571 <        assertEquals(s1.errors, 1);
571 >        assertEquals(1, s1.errors);
572          assertTrue(s1.lastError instanceof IllegalArgumentException);
573      }
574  
# Line 582 | Line 582 | public class SubmissionPublisherTest ext
582          s.request = false;
583          p.subscribe(s);
584          s.awaitSubscribe();
585 <        assertEquals(p.estimateMinimumDemand(), 0);
585 >        assertEquals(0, p.estimateMinimumDemand());
586          s.sn.request(1);
587 <        assertEquals(p.estimateMinimumDemand(), 1);
587 >        assertEquals(1, p.estimateMinimumDemand());
588          p.submit(1);
589          s.awaitNext(1);
590 <        assertEquals(p.estimateMinimumDemand(), 0);
590 >        assertEquals(0, p.estimateMinimumDemand());
591      }
592  
593      /**
# Line 595 | Line 595 | public class SubmissionPublisherTest ext
595       */
596      public void testEmptySubmit() {
597          SubmissionPublisher<Integer> p = basicPublisher();
598 <        assertEquals(p.submit(1), 0);
598 >        assertEquals(0, p.submit(1));
599      }
600  
601      /**
# Line 623 | Line 623 | public class SubmissionPublisherTest ext
623          p.subscribe(s2);
624          s2.awaitSubscribe();
625          s1.awaitSubscribe();
626 <        assertEquals(p.submit(1), 1);
626 >        assertEquals(1, p.submit(1));
627          assertTrue(p.estimateMaximumLag() >= 1);
628          assertTrue(p.submit(2) >= 2);
629          assertTrue(p.estimateMaximumLag() >= 2);
# Line 634 | Line 634 | public class SubmissionPublisherTest ext
634          p.submit(4);
635          p.close();
636          s2.awaitComplete();
637 <        assertEquals(s2.nexts, 4);
637 >        assertEquals(4, s2.nexts);
638          s1.awaitComplete();
639 <        assertEquals(s2.nexts, 4);
639 >        assertEquals(4, s2.nexts);
640      }
641  
642      /**
# Line 656 | Line 656 | public class SubmissionPublisherTest ext
656          p.close();
657          s2.awaitComplete();
658          s1.awaitComplete();
659 <        assertEquals(s2.nexts, 20);
660 <        assertEquals(s2.completes, 1);
661 <        assertEquals(s1.nexts, 20);
662 <        assertEquals(s1.completes, 1);
659 >        assertEquals(20, s2.nexts);
660 >        assertEquals(1, s2.completes);
661 >        assertEquals(20, s1.nexts);
662 >        assertEquals(1, s1.completes);
663      }
664  
665      static boolean noopHandle(AtomicInteger count) {
# Line 713 | Line 713 | public class SubmissionPublisherTest ext
713          p.offer(4, null);
714          p.close();
715          s2.awaitComplete();
716 <        assertEquals(s2.nexts, 4);
716 >        assertEquals(4, s2.nexts);
717          s1.awaitComplete();
718 <        assertEquals(s2.nexts, 4);
718 >        assertEquals(4, s2.nexts);
719      }
720  
721      /**
# Line 797 | Line 797 | public class SubmissionPublisherTest ext
797          p.close();
798          s2.awaitComplete();
799          s1.awaitComplete();
800 <        assertEquals(s1.nexts + s2.nexts, n);
800 >        assertEquals(n, s1.nexts + s2.nexts);
801          assertTrue(calls.get() >= 2);
802      }
803  
# Line 845 | Line 845 | public class SubmissionPublisherTest ext
845          p.offer(4, SHORT_DELAY_MS, MILLISECONDS, null);
846          p.close();
847          s2.awaitComplete();
848 <        assertEquals(s2.nexts, 4);
848 >        assertEquals(4, s2.nexts);
849          s1.awaitComplete();
850 <        assertEquals(s2.nexts, 4);
850 >        assertEquals(4, s2.nexts);
851      }
852  
853      /**
# Line 929 | Line 929 | public class SubmissionPublisherTest ext
929          p.close();
930          s2.awaitComplete();
931          s1.awaitComplete();
932 <        assertEquals(s1.nexts + s2.nexts, n);
932 >        assertEquals(n, s1.nexts + s2.nexts);
933          assertTrue(calls.get() >= 2);
934      }
935  

Diff Legend

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