ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/SubmissionPublisherTest.java

Comparing jsr166/src/test/tck/SubmissionPublisherTest.java (file contents):
Revision 1.1 by dl, Mon Sep 7 17:14:06 2015 UTC vs.
Revision 1.6 by jsr166, Mon Sep 7 20:53:10 2015 UTC

#	Line 45 | Line 45 | public class SubmissionPublisherTest ext
45		return t;
46		}
47		}
48	<
48	>
49		static final Executor basicExecutor =
50		(ForkJoinPool.getCommonPoolParallelism() > 0) ?
51		ForkJoinPool.commonPool() :
52		new ThreadPoolExecutor(1, 1, 60, SECONDS,
53		new LinkedBlockingQueue<Runnable>(),
54		new DaemonThreadFactory());
55	<
55	>
56		static SubmissionPublisher<Integer> basicPublisher() {
57		return new SubmissionPublisher<Integer>(basicExecutor,
58		Flow.defaultBufferSize());
59		}
60	<
60	>
61		static class SPException extends RuntimeException {}
62
63		class TestSubscriber implements Subscriber<Integer> {
#	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 193 | Line 193 | public class SubmissionPublisherTest ext
193		*/
194		public void testConstructor3() {
195		try {
196	<	SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(null, 8);
196	>	new SubmissionPublisher<Integer>(null, 8);
197		shouldThrow();
198	<	} catch (NullPointerException success) {
199	<	}
198	>	} catch (NullPointerException success) {}
199		}
200
201		/**
#	Line 206 | Line 205 | public class SubmissionPublisherTest ext
205		public void testConstructor4() {
206		Executor e = Executors.newFixedThreadPool(1);
207		try {
208	<	SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(e, -1);
208	>	new SubmissionPublisher<Integer>(e, -1);
209		shouldThrow();
210	<	} catch (IllegalArgumentException success) {
212	<	}
210	>	} catch (IllegalArgumentException success) {}
211		}
212
213		/**
#	Line 226 | Line 224 | public class SubmissionPublisherTest ext
224		try {
225		p.submit(1);
226		shouldThrow();
227	<	}
230	<	catch(IllegalStateException success) {
231	<	}
227	>	} catch (IllegalStateException success) {}
228		Throwable ex = new SPException();
229		p.closeExceptionally(ex);
230		assertTrue(p.isClosed());
#	Line 251 | Line 247 | public class SubmissionPublisherTest ext
247		try {
248		p.submit(1);
249		shouldThrow();
250	<	}
255	<	catch(IllegalStateException success) {
256	<	}
250	>	} catch (IllegalStateException success) {}
251		p.close();
252		assertTrue(p.isClosed());
253		assertSame(p.getClosedException(), ex);
#	Line 270 | 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 303 | 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 321 | 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 334 | 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 358 | Line 352 | public class SubmissionPublisherTest ext
352		s.throwOnCall = true;
353		try {
354		p.subscribe(s);
355	<	} catch(Exception ok) {
362	<	}
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 373 | Line 366 | public class SubmissionPublisherTest ext
366		SubmissionPublisher<Integer> p = basicPublisher();
367		try {
368		p.subscribe(null);
369	<	} catch(NullPointerException success) {
370	<	}
369	>	shouldThrow();
370	>	} catch (NullPointerException success) {}
371		checkInitialState(p);
372		}
373
#	Line 392 | 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 413 | 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 435 | 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 456 | 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 480 | 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 501 | 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 522 | 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 550 | 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 572 | 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 589 | 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		/**
594	<	* Submit to a publisher with no subscribers returns lag 0
594	>	* submit to a publisher with no subscribers returns lag 0
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		/**
602	<	* Submit(null) throws NPE
602	>	* submit(null) throws NPE
603		*/
604		public void testNullSubmit() {
605		SubmissionPublisher<Integer> p = basicPublisher();
606		try {
607		p.submit(null);
608	<	} catch (NullPointerException success) {
609	<	}
608	>	shouldThrow();
609	>	} catch (NullPointerException success) {}
610		}
611
612		/**
613	<	* Submit returns number of lagged items, compatible with result
613	>	* submit returns number of lagged items, compatible with result
614		* of estimateMaximumLag.
615		*/
616		public void testLaggedSubmit() {
#	Line 630 | 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 641 | 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 663 | 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	<
664	>
665		static boolean noopHandle(AtomicInteger count) {
666		count.getAndIncrement();
667		return false;
#	Line 681 | Line 674 | public class SubmissionPublisherTest ext
674		}
675
676		/**
677	<	* Offer to a publisher with no subscribers returns lag 0
677	>	* offer to a publisher with no subscribers returns lag 0
678		*/
679		public void testEmptyOffer() {
680		SubmissionPublisher<Integer> p = basicPublisher();
681	<	assertEquals(p.offer(1, null), 0);
681	>	assertEquals(0, p.offer(1, null));
682		}
683
684		/**
685	<	* Offer(null) throws NPE
685	>	* offer(null) throws NPE
686		*/
687		public void testNullOffer() {
688		SubmissionPublisher<Integer> p = basicPublisher();
689		try {
690		p.offer(null, null);
691	<	} catch (NullPointerException success) {
692	<	}
691	>	shouldThrow();
692	>	} catch (NullPointerException success) {}
693		}
694
695		/**
696	<	* Offer returns number of lagged items if not saturated
696	>	* offer returns number of lagged items if not saturated
697		*/
698		public void testLaggedOffer() {
699		SubmissionPublisher<Integer> p = basicPublisher();
#	Line 720 | 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		/**
722	<	* Offer reports drops if saturated
722	>	* offer reports drops if saturated
723		*/
724		public void testDroppedOffer() {
725		SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(
#	Line 754 | Line 747 | public class SubmissionPublisherTest ext
747		}
748
749		/**
750	<	* Offer invokes drop handler if saturated
750	>	* offer invokes drop handler if saturated
751		*/
752		public void testHandledDroppedOffer() {
753		AtomicInteger calls = new AtomicInteger();
#	Line 781 | Line 774 | public class SubmissionPublisherTest ext
774		assertTrue(calls.get() >= 4);
775		}
776
784	–
777		/**
778	<	* Offer succeeds if drop handler forces request
778	>	* offer succeeds if drop handler forces request
779		*/
780		public void testRecoveredHandledDroppedOffer() {
781		AtomicInteger calls = new AtomicInteger();
#	Line 805 | 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
812	–
804		/**
805	<	* TimedOffer to a publisher with no subscribers returns lag 0
805	>	* Timed offer to a publisher with no subscribers returns lag 0
806		*/
807		public void testEmptyTimedOffer() {
808		SubmissionPublisher<Integer> p = basicPublisher();
809	<	assertEquals(p.offer(1, null), 0);
809	>	assertEquals(0, p.offer(1, LONG_DELAY_MS, MILLISECONDS, null));
810		}
811
812		/**
813	<	* Timed Offer with null item or TimeUnit throws NPE
813	>	* Timed offer with null item or TimeUnit throws NPE
814		*/
815		public void testNullTimedOffer() {
816		SubmissionPublisher<Integer> p = basicPublisher();
817		try {
818		p.offer(null, SHORT_DELAY_MS, MILLISECONDS, null);
819	<	} catch (NullPointerException success) {
820	<	}
819	>	shouldThrow();
820	>	} catch (NullPointerException success) {}
821		try {
822		p.offer(1, SHORT_DELAY_MS, null, null);
823	<	} catch (NullPointerException success) {
824	<	}
823	>	shouldThrow();
824	>	} catch (NullPointerException success) {}
825		}
826
827		/**
828	<	* Timed Offer returns number of lagged items if not saturated
828	>	* Timed offer returns number of lagged items if not saturated
829		*/
830		public void testLaggedTimedOffer() {
831		SubmissionPublisher<Integer> p = basicPublisher();
#	Line 854 | 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		/**
854	<	* Timed Offer reports drops if saturated
854	>	* Timed offer reports drops if saturated
855		*/
856		public void testDroppedTimedOffer() {
857		SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(
#	Line 888 | Line 879 | public class SubmissionPublisherTest ext
879		}
880
881		/**
882	<	* Timed Offer invokes drop handler if saturated
882	>	* Timed offer invokes drop handler if saturated
883		*/
884		public void testHandledDroppedTimedOffer() {
885		AtomicInteger calls = new AtomicInteger();
#	Line 916 | Line 907 | public class SubmissionPublisherTest ext
907		}
908
909		/**
910	<	* Timed Offer succeeds if drop handler forces request
910	>	* Timed offer succeeds if drop handler forces request
911		*/
912		public void testRecoveredHandledDroppedTimedOffer() {
913		AtomicInteger calls = new AtomicInteger();
#	Line 938 | 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
945	–
936		}

Diff Legend

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