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.17 by dl, Thu Dec 15 17:34:51 2016 UTC vs.
Revision 1.22 by dl, Sat Nov 4 12:49:58 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());
169      }
170  
171      /**
172 <     * A null Executor argument to SubmissionPublisher constructor throws NPE
172 >     * A null Executor argument to SubmissionPublisher constructor
173 >     * throws NullPointerException
174       */
175      public void testConstructor3() {
176          try {
# Line 180 | Line 181 | public class SubmissionPublisherTest ext
181  
182      /**
183       * A negative capacity argument to SubmissionPublisher constructor
184 <     * throws IAE
184 >     * throws IllegalArgumentException
185       */
186      public void testConstructor4() {
187          Executor e = Executors.newFixedThreadPool(1);
# Line 192 | Line 193 | public class SubmissionPublisherTest ext
193  
194      /**
195       * A closed publisher reports isClosed with no closedException and
196 <     * throws ISE upon attempted submission; a subsequent close or
197 <     * closeExceptionally has no additional effect.
196 >     * throws IllegalStateException upon attempted submission; a
197 >     * subsequent close or closeExceptionally has no additional
198 >     * effect.
199       */
200      public void testClose() {
201          SubmissionPublisher<Integer> p = basicPublisher();
# Line 213 | Line 215 | public class SubmissionPublisherTest ext
215  
216      /**
217       * A publisher closedExceptionally reports isClosed with the
218 <     * closedException and throws ISE upon attempted submission; a
219 <     * subsequent close or closeExceptionally has no additional
220 <     * effect.
218 >     * closedException and throws IllegalStateException upon attempted
219 >     * submission; a subsequent close or closeExceptionally has no
220 >     * additional effect.
221       */
222      public void testCloseExceptionally() {
223          SubmissionPublisher<Integer> p = basicPublisher();
# Line 444 | Line 446 | public class SubmissionPublisherTest ext
446       */
447      public void testThrowOnNextHandler() {
448          AtomicInteger calls = new AtomicInteger();
449 <        SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>
450 <            (basicExecutor, 8,
449 <             (s, e) -> calls.getAndIncrement());
449 >        SubmissionPublisher<Integer> p = new SubmissionPublisher<>(
450 >            basicExecutor, 8, (s, e) -> calls.getAndIncrement());
451          TestSubscriber s1 = new TestSubscriber();
452          TestSubscriber s2 = new TestSubscriber();
453          p.subscribe(s1);
# Line 493 | Line 494 | public class SubmissionPublisherTest ext
494          s1.request = false;
495          p.subscribe(s1);
496          s1.awaitSubscribe();
497 <        assertTrue(p.estimateMinimumDemand() == 0);
497 >        assertEquals(0, p.estimateMinimumDemand());
498          TestSubscriber s2 = new TestSubscriber();
499          p.subscribe(s2);
500          p.submit(1);
# Line 534 | Line 535 | public class SubmissionPublisherTest ext
535      }
536  
537      /**
538 <     * Negative request causes error
538 >     * Non-positive request causes error
539       */
540      public void testRequest3() {
541          SubmissionPublisher<Integer> p = basicPublisher();
542          TestSubscriber s1 = new TestSubscriber();
543          TestSubscriber s2 = new TestSubscriber();
544 +        TestSubscriber s3 = new TestSubscriber();
545          p.subscribe(s1);
546          p.subscribe(s2);
547 +        p.subscribe(s3);
548 +        s3.awaitSubscribe();
549          s2.awaitSubscribe();
550          s1.awaitSubscribe();
551          s1.sn.request(-1L);
552 +        s3.sn.request(0L);
553          p.submit(1);
554          p.submit(2);
555          p.close();
# Line 554 | Line 559 | public class SubmissionPublisherTest ext
559          s1.awaitError();
560          assertEquals(1, s1.errors);
561          assertTrue(s1.lastError instanceof IllegalArgumentException);
562 +        s3.awaitError();
563 +        assertEquals(1, s3.errors);
564 +        assertTrue(s3.lastError instanceof IllegalArgumentException);
565      }
566  
567      /**
568       * estimateMinimumDemand reports 0 until request, nonzero after
569 <     * request, and zero again after delivery
569 >     * request
570       */
571      public void testEstimateMinimumDemand() {
572          TestSubscriber s = new TestSubscriber();
# Line 569 | Line 577 | public class SubmissionPublisherTest ext
577          assertEquals(0, p.estimateMinimumDemand());
578          s.sn.request(1);
579          assertEquals(1, p.estimateMinimumDemand());
572 –        p.submit(1);
573 –        s.awaitNext(1);
574 –        assertEquals(0, p.estimateMinimumDemand());
580      }
581  
582      /**
# Line 627 | Line 632 | public class SubmissionPublisherTest ext
632       * submit eventually issues requested items when buffer capacity is 1
633       */
634      public void testCap1Submit() {
635 <        SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(
636 <            basicExecutor, 1);
635 >        SubmissionPublisher<Integer> p
636 >            = new SubmissionPublisher<>(basicExecutor, 1);
637          TestSubscriber s1 = new TestSubscriber();
638          TestSubscriber s2 = new TestSubscriber();
639          p.subscribe(s1);
# Line 706 | Line 711 | public class SubmissionPublisherTest ext
711       * offer reports drops if saturated
712       */
713      public void testDroppedOffer() {
714 <        SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(
715 <            basicExecutor, 4);
714 >        SubmissionPublisher<Integer> p
715 >            = new SubmissionPublisher<>(basicExecutor, 4);
716          TestSubscriber s1 = new TestSubscriber();
717          s1.request = false;
718          TestSubscriber s2 = new TestSubscriber();
# Line 735 | Line 740 | public class SubmissionPublisherTest ext
740       */
741      public void testHandledDroppedOffer() {
742          AtomicInteger calls = new AtomicInteger();
743 <        SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(
744 <            basicExecutor, 4);
743 >        SubmissionPublisher<Integer> p
744 >            = new SubmissionPublisher<>(basicExecutor, 4);
745          TestSubscriber s1 = new TestSubscriber();
746          s1.request = false;
747          TestSubscriber s2 = new TestSubscriber();
# Line 763 | Line 768 | public class SubmissionPublisherTest ext
768       */
769      public void testRecoveredHandledDroppedOffer() {
770          AtomicInteger calls = new AtomicInteger();
771 <        SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(
772 <            basicExecutor, 4);
771 >        SubmissionPublisher<Integer> p
772 >            = new SubmissionPublisher<>(basicExecutor, 4);
773          TestSubscriber s1 = new TestSubscriber();
774          s1.request = false;
775          TestSubscriber s2 = new TestSubscriber();
# Line 844 | Line 849 | public class SubmissionPublisherTest ext
849       * Timed offer reports drops if saturated
850       */
851      public void testDroppedTimedOffer() {
852 <        SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(
853 <            basicExecutor, 4);
852 >        SubmissionPublisher<Integer> p
853 >            = new SubmissionPublisher<>(basicExecutor, 4);
854          TestSubscriber s1 = new TestSubscriber();
855          s1.request = false;
856          TestSubscriber s2 = new TestSubscriber();
# Line 876 | Line 881 | public class SubmissionPublisherTest ext
881       */
882      public void testHandledDroppedTimedOffer() {
883          AtomicInteger calls = new AtomicInteger();
884 <        SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(
885 <            basicExecutor, 4);
884 >        SubmissionPublisher<Integer> p
885 >            = new SubmissionPublisher<>(basicExecutor, 4);
886          TestSubscriber s1 = new TestSubscriber();
887          s1.request = false;
888          TestSubscriber s2 = new TestSubscriber();
# Line 906 | Line 911 | public class SubmissionPublisherTest ext
911       */
912      public void testRecoveredHandledDroppedTimedOffer() {
913          AtomicInteger calls = new AtomicInteger();
914 <        SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(
915 <            basicExecutor, 4);
914 >        SubmissionPublisher<Integer> p
915 >            = new SubmissionPublisher<>(basicExecutor, 4);
916          TestSubscriber s1 = new TestSubscriber();
917          s1.request = false;
918          TestSubscriber s2 = new TestSubscriber();

Diff Legend

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