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.15 by jsr166, Sun Nov 6 22:50:32 2016 UTC vs.
Revision 1.20 by jsr166, Sat Mar 18 20:42:20 2017 UTC

# Line 146 | Line 146 | public class SubmissionPublisherTest ext
146       * defaultExecutor
147       */
148      public void testConstructor1() {
149 <        SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>();
149 >        SubmissionPublisher<Integer> p = new SubmissionPublisher<>();
150          checkInitialState(p);
151          assertEquals(p.getMaxBufferCapacity(), Flow.defaultBufferSize());
152          Executor e = p.getExecutor(), c = ForkJoinPool.commonPool();
# Line 162 | Line 162 | public class SubmissionPublisherTest ext
162       */
163      public void testConstructor2() {
164          Executor e = Executors.newFixedThreadPool(1);
165 <        SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(e, 8);
165 >        SubmissionPublisher<Integer> p = new SubmissionPublisher<>(e, 8);
166          checkInitialState(p);
167          assertSame(p.getExecutor(), e);
168          assertEquals(8, p.getMaxBufferCapacity());
# Line 375 | Line 375 | public class SubmissionPublisherTest ext
375  
376      /**
377       * Closing a publisher exceptionally causes onError to subscribers
378 +     * after they are subscribed
379       */
380      public void testCloseExceptionallyError() {
381          SubmissionPublisher<Integer> p = basicPublisher();
# Line 385 | Line 386 | public class SubmissionPublisherTest ext
386          p.submit(1);
387          p.closeExceptionally(new SPException());
388          assertTrue(p.isClosed());
389 +        s1.awaitSubscribe();
390          s1.awaitError();
391          assertTrue(s1.nexts <= 1);
392          assertEquals(1, s1.errors);
393 +        s2.awaitSubscribe();
394          s2.awaitError();
395          assertTrue(s2.nexts <= 1);
396          assertEquals(1, s2.errors);
# Line 441 | Line 444 | public class SubmissionPublisherTest ext
444       */
445      public void testThrowOnNextHandler() {
446          AtomicInteger calls = new AtomicInteger();
447 <        SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>
448 <            (basicExecutor, 8,
446 <             (s, e) -> calls.getAndIncrement());
447 >        SubmissionPublisher<Integer> p = new SubmissionPublisher<>(
448 >            basicExecutor, 8, (s, e) -> calls.getAndIncrement());
449          TestSubscriber s1 = new TestSubscriber();
450          TestSubscriber s2 = new TestSubscriber();
451          p.subscribe(s1);
# Line 490 | Line 492 | public class SubmissionPublisherTest ext
492          s1.request = false;
493          p.subscribe(s1);
494          s1.awaitSubscribe();
495 <        assertTrue(p.estimateMinimumDemand() == 0);
495 >        assertEquals(0, p.estimateMinimumDemand());
496          TestSubscriber s2 = new TestSubscriber();
497          p.subscribe(s2);
498          p.submit(1);
# Line 531 | Line 533 | public class SubmissionPublisherTest ext
533      }
534  
535      /**
536 <     * Negative request causes error
536 >     * Non-positive request causes error
537       */
538      public void testRequest3() {
539          SubmissionPublisher<Integer> p = basicPublisher();
540          TestSubscriber s1 = new TestSubscriber();
541          TestSubscriber s2 = new TestSubscriber();
542 +        TestSubscriber s3 = new TestSubscriber();
543          p.subscribe(s1);
544          p.subscribe(s2);
545 +        p.subscribe(s3);
546 +        s3.awaitSubscribe();
547          s2.awaitSubscribe();
548          s1.awaitSubscribe();
549          s1.sn.request(-1L);
550 +        s3.sn.request(0L);
551          p.submit(1);
552          p.submit(2);
553          p.close();
# Line 551 | Line 557 | public class SubmissionPublisherTest ext
557          s1.awaitError();
558          assertEquals(1, s1.errors);
559          assertTrue(s1.lastError instanceof IllegalArgumentException);
560 +        s3.awaitError();
561 +        assertEquals(1, s3.errors);
562 +        assertTrue(s3.lastError instanceof IllegalArgumentException);
563      }
564  
565      /**
# Line 624 | Line 633 | public class SubmissionPublisherTest ext
633       * submit eventually issues requested items when buffer capacity is 1
634       */
635      public void testCap1Submit() {
636 <        SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(
637 <            basicExecutor, 1);
636 >        SubmissionPublisher<Integer> p
637 >            = new SubmissionPublisher<>(basicExecutor, 1);
638          TestSubscriber s1 = new TestSubscriber();
639          TestSubscriber s2 = new TestSubscriber();
640          p.subscribe(s1);
# Line 703 | Line 712 | public class SubmissionPublisherTest ext
712       * offer reports drops if saturated
713       */
714      public void testDroppedOffer() {
715 <        SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(
716 <            basicExecutor, 4);
715 >        SubmissionPublisher<Integer> p
716 >            = new SubmissionPublisher<>(basicExecutor, 4);
717          TestSubscriber s1 = new TestSubscriber();
718          s1.request = false;
719          TestSubscriber s2 = new TestSubscriber();
# Line 732 | Line 741 | public class SubmissionPublisherTest ext
741       */
742      public void testHandledDroppedOffer() {
743          AtomicInteger calls = new AtomicInteger();
744 <        SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(
745 <            basicExecutor, 4);
744 >        SubmissionPublisher<Integer> p
745 >            = new SubmissionPublisher<>(basicExecutor, 4);
746          TestSubscriber s1 = new TestSubscriber();
747          s1.request = false;
748          TestSubscriber s2 = new TestSubscriber();
# Line 760 | Line 769 | public class SubmissionPublisherTest ext
769       */
770      public void testRecoveredHandledDroppedOffer() {
771          AtomicInteger calls = new AtomicInteger();
772 <        SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(
773 <            basicExecutor, 4);
772 >        SubmissionPublisher<Integer> p
773 >            = new SubmissionPublisher<>(basicExecutor, 4);
774          TestSubscriber s1 = new TestSubscriber();
775          s1.request = false;
776          TestSubscriber s2 = new TestSubscriber();
# Line 841 | Line 850 | public class SubmissionPublisherTest ext
850       * Timed offer reports drops if saturated
851       */
852      public void testDroppedTimedOffer() {
853 <        SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(
854 <            basicExecutor, 4);
853 >        SubmissionPublisher<Integer> p
854 >            = new SubmissionPublisher<>(basicExecutor, 4);
855          TestSubscriber s1 = new TestSubscriber();
856          s1.request = false;
857          TestSubscriber s2 = new TestSubscriber();
# Line 873 | Line 882 | public class SubmissionPublisherTest ext
882       */
883      public void testHandledDroppedTimedOffer() {
884          AtomicInteger calls = new AtomicInteger();
885 <        SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(
886 <            basicExecutor, 4);
885 >        SubmissionPublisher<Integer> p
886 >            = new SubmissionPublisher<>(basicExecutor, 4);
887          TestSubscriber s1 = new TestSubscriber();
888          s1.request = false;
889          TestSubscriber s2 = new TestSubscriber();
# Line 903 | Line 912 | public class SubmissionPublisherTest ext
912       */
913      public void testRecoveredHandledDroppedTimedOffer() {
914          AtomicInteger calls = new AtomicInteger();
915 <        SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(
916 <            basicExecutor, 4);
915 >        SubmissionPublisher<Integer> p
916 >            = new SubmissionPublisher<>(basicExecutor, 4);
917          TestSubscriber s1 = new TestSubscriber();
918          s1.request = false;
919          TestSubscriber s2 = new TestSubscriber();

Diff Legend

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