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.2 by jsr166, Mon Sep 7 20:20:40 2015 UTC vs.
Revision 1.9 by dl, Tue Sep 8 19:44:10 2015 UTC

#	Line 47 | Line 47 | public class SubmissionPublisherTest ext
47		}
48
49		static final Executor basicExecutor =
50	<	(ForkJoinPool.getCommonPoolParallelism() > 0) ?
50	>	(ForkJoinPool.getCommonPoolParallelism() > 1) ?
51		ForkJoinPool.commonPool() :
52		new ThreadPoolExecutor(1, 1, 60, SECONDS,
53		new LinkedBlockingQueue<Runnable>(),
#	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	>	p.close();
289		}
290
291		/**
#	Line 297 | Line 298 | public class SubmissionPublisherTest ext
298		p.close();
299		p.subscribe(s);
300		s.awaitComplete();
301	<	assertEquals(s.nexts, 0);
302	<	assertEquals(s.errors, 0);
303	<	assertEquals(s.completes, 1);
301	>	assertEquals(0, s.nexts);
302	>	assertEquals(0, s.errors);
303	>	assertEquals(1, s.completes, 1);
304		}
305
306		/**
#	Line 315 | Line 316 | public class SubmissionPublisherTest ext
316		assertSame(p.getClosedException(), ex);
317		p.subscribe(s);
318		s.awaitError();
319	<	assertEquals(s.nexts, 0);
320	<	assertEquals(s.errors, 1);
319	>	assertEquals(0, s.nexts);
320	>	assertEquals(1, s.errors);
321		}
322
323		/**
#	Line 328 | Line 329 | public class SubmissionPublisherTest ext
329		SubmissionPublisher<Integer> p = basicPublisher();
330		p.subscribe(s);
331		assertTrue(p.hasSubscribers());
332	<	assertEquals(p.getNumberOfSubscribers(), 1);
332	>	assertEquals(1, p.getNumberOfSubscribers());
333		assertTrue(p.getSubscribers().contains(s));
334		assertTrue(p.isSubscribed(s));
335		s.awaitSubscribe();
336		assertNotNull(s.sn);
337	<	assertEquals(s.nexts, 0);
338	<	assertEquals(s.errors, 0);
339	<	assertEquals(s.completes, 0);
337	>	assertEquals(0, s.nexts);
338	>	assertEquals(0, s.errors);
339	>	assertEquals(0, s.completes);
340		p.subscribe(s);
341		s.awaitError();
342	<	assertEquals(s.nexts, 0);
343	<	assertEquals(s.errors, 1);
342	>	assertEquals(0, s.nexts);
343	>	assertEquals(1, s.errors);
344		assertFalse(p.isSubscribed(s));
345		}
346
#	Line 354 | Line 355 | public class SubmissionPublisherTest ext
355		p.subscribe(s);
356		} catch (Exception ok) {}
357		s.awaitError();
358	<	assertEquals(s.nexts, 0);
359	<	assertEquals(s.errors, 1);
360	<	assertEquals(s.completes, 0);
358	>	assertEquals(0, s.nexts);
359	>	assertEquals(1, s.errors);
360	>	assertEquals(0, s.completes);
361		}
362
363		/**
364	<	* subscribe(null) thows NPE
364	>	* subscribe(null) throws NPE
365		*/
366		public void testSubscribe6() {
367		SubmissionPublisher<Integer> p = basicPublisher();
#	Line 385 | Line 386 | public class SubmissionPublisherTest ext
386		assertTrue(p.isClosed());
387		assertNull(p.getClosedException());
388		s1.awaitComplete();
389	<	assertEquals(s1.nexts, 1);
390	<	assertEquals(s1.completes, 1);
389	>	assertEquals(1, s1.nexts);
390	>	assertEquals(1, s1.completes);
391		s2.awaitComplete();
392	<	assertEquals(s2.nexts, 1);
393	<	assertEquals(s2.completes, 1);
392	>	assertEquals(1, s2.nexts);
393	>	assertEquals(1, s2.completes);
394		}
395
396		/**
#	Line 406 | Line 407 | public class SubmissionPublisherTest ext
407		assertTrue(p.isClosed());
408		s1.awaitError();
409		assertTrue(s1.nexts <= 1);
410	<	assertEquals(s1.errors, 1);
410	>	assertEquals(1, s1.errors);
411		s2.awaitError();
412		assertTrue(s2.nexts <= 1);
413	<	assertEquals(s2.errors, 1);
413	>	assertEquals(1, s2.errors);
414		}
415
416		/**
#	Line 428 | Line 429 | public class SubmissionPublisherTest ext
429		p.submit(i);
430		p.close();
431		s2.awaitComplete();
432	<	assertEquals(s2.nexts, 20);
433	<	assertEquals(s2.completes, 1);
432	>	assertEquals(20, s2.nexts);
433	>	assertEquals(1, s2.completes);
434		assertTrue(s1.nexts < 20);
435		assertFalse(p.isSubscribed(s1));
436		}
#	Line 449 | Line 450 | public class SubmissionPublisherTest ext
450		p.submit(2);
451		p.close();
452		s2.awaitComplete();
453	<	assertEquals(s2.nexts, 2);
453	>	assertEquals(2, s2.nexts);
454		s1.awaitComplete();
455	<	assertEquals(s1.errors, 1);
455	>	assertEquals(1, s1.errors);
456		}
457
458		/**
459	<	* If a handler is supplied in conctructor, it is invoked when
459	>	* If a handler is supplied in constructor, it is invoked when
460		* subscriber throws an exception in onNext
461		*/
462		public void testThrowOnNextHandler() {
#	Line 473 | Line 474 | public class SubmissionPublisherTest ext
474		p.submit(2);
475		p.close();
476		s2.awaitComplete();
477	<	assertEquals(s2.nexts, 2);
478	<	assertEquals(s2.completes, 1);
477	>	assertEquals(2, s2.nexts);
478	>	assertEquals(1, s2.completes);
479		s1.awaitError();
480	<	assertEquals(s1.errors, 1);
481	<	assertEquals(calls.get(), 1);
480	>	assertEquals(1, s1.errors);
481	>	assertEquals(1, calls.get());
482		}
483
484		/**
#	Line 494 | Line 495 | public class SubmissionPublisherTest ext
495		p.close();
496		s2.awaitComplete();
497		s1.awaitComplete();
498	<	assertEquals(s2.nexts, 20);
499	<	assertEquals(s2.completes, 1);
500	<	assertEquals(s1.nexts, 20);
501	<	assertEquals(s1.completes, 1);
498	>	assertEquals(20, s2.nexts);
499	>	assertEquals(1, s2.completes);
500	>	assertEquals(20, s1.nexts);
501	>	assertEquals(1, s1.completes);
502		}
503
504		/**
#	Line 515 | Line 516 | public class SubmissionPublisherTest ext
516		p.submit(1);
517		p.submit(2);
518		s2.awaitNext(1);
519	<	assertEquals(s1.nexts, 0);
519	>	assertEquals(0, s1.nexts);
520		s1.sn.request(3);
521		p.submit(3);
522		p.close();
523		s2.awaitComplete();
524	<	assertEquals(s2.nexts, 3);
525	<	assertEquals(s2.completes, 1);
524	>	assertEquals(3, s2.nexts);
525	>	assertEquals(1, s2.completes);
526		s1.awaitComplete();
527		assertTrue(s1.nexts > 0);
528	<	assertEquals(s1.completes, 1);
528	>	assertEquals(1, s1.completes);
529		}
530
531		/**
#	Line 543 | Line 544 | public class SubmissionPublisherTest ext
544		p.submit(2);
545		p.close();
546		s2.awaitComplete();
547	<	assertEquals(s2.nexts, 2);
548	<	assertEquals(s2.completes, 1);
547	>	assertEquals(2, s2.nexts);
548	>	assertEquals(1, s2.completes);
549		s1.awaitNext(1);
550	<	assertEquals(s1.nexts, 1);
550	>	assertEquals(1, s1.nexts);
551		}
552
553		/**
#	Line 565 | Line 566 | public class SubmissionPublisherTest ext
566		p.submit(2);
567		p.close();
568		s2.awaitComplete();
569	<	assertEquals(s2.nexts, 2);
570	<	assertEquals(s2.completes, 1);
569	>	assertEquals(2, s2.nexts);
570	>	assertEquals(1, s2.completes);
571		s1.awaitError();
572	<	assertEquals(s1.errors, 1);
572	>	assertEquals(1, s1.errors);
573		assertTrue(s1.lastError instanceof IllegalArgumentException);
574		}
575
#	Line 582 | Line 583 | public class SubmissionPublisherTest ext
583		s.request = false;
584		p.subscribe(s);
585		s.awaitSubscribe();
586	<	assertEquals(p.estimateMinimumDemand(), 0);
586	>	assertEquals(0, p.estimateMinimumDemand());
587		s.sn.request(1);
588	<	assertEquals(p.estimateMinimumDemand(), 1);
588	>	assertEquals(1, p.estimateMinimumDemand());
589		p.submit(1);
590		s.awaitNext(1);
591	<	assertEquals(p.estimateMinimumDemand(), 0);
591	>	assertEquals(0, p.estimateMinimumDemand());
592		}
593
594		/**
595	<	* Submit to a publisher with no subscribers returns lag 0
595	>	* submit to a publisher with no subscribers returns lag 0
596		*/
597		public void testEmptySubmit() {
598		SubmissionPublisher<Integer> p = basicPublisher();
599	<	assertEquals(p.submit(1), 0);
599	>	assertEquals(0, p.submit(1));
600		}
601
602		/**
603	<	* Submit(null) throws NPE
603	>	* submit(null) throws NPE
604		*/
605		public void testNullSubmit() {
606		SubmissionPublisher<Integer> p = basicPublisher();
#	Line 610 | Line 611 | public class SubmissionPublisherTest ext
611		}
612
613		/**
614	<	* Submit returns number of lagged items, compatible with result
614	>	* submit returns number of lagged items, compatible with result
615		* of estimateMaximumLag.
616		*/
617		public void testLaggedSubmit() {
#	Line 623 | Line 624 | public class SubmissionPublisherTest ext
624		p.subscribe(s2);
625		s2.awaitSubscribe();
626		s1.awaitSubscribe();
627	<	assertEquals(p.submit(1), 1);
627	>	assertEquals(1, p.submit(1));
628		assertTrue(p.estimateMaximumLag() >= 1);
629		assertTrue(p.submit(2) >= 2);
630		assertTrue(p.estimateMaximumLag() >= 2);
#	Line 634 | Line 635 | public class SubmissionPublisherTest ext
635		p.submit(4);
636		p.close();
637		s2.awaitComplete();
638	<	assertEquals(s2.nexts, 4);
638	>	assertEquals(4, s2.nexts);
639		s1.awaitComplete();
640	<	assertEquals(s2.nexts, 4);
640	>	assertEquals(4, s2.nexts);
641		}
642
643		/**
#	Line 656 | Line 657 | public class SubmissionPublisherTest ext
657		p.close();
658		s2.awaitComplete();
659		s1.awaitComplete();
660	<	assertEquals(s2.nexts, 20);
661	<	assertEquals(s2.completes, 1);
662	<	assertEquals(s1.nexts, 20);
663	<	assertEquals(s1.completes, 1);
660	>	assertEquals(20, s2.nexts);
661	>	assertEquals(1, s2.completes);
662	>	assertEquals(20, s1.nexts);
663	>	assertEquals(1, s1.completes);
664		}
665
666		static boolean noopHandle(AtomicInteger count) {
#	Line 674 | Line 675 | public class SubmissionPublisherTest ext
675		}
676
677		/**
678	<	* Offer to a publisher with no subscribers returns lag 0
678	>	* offer to a publisher with no subscribers returns lag 0
679		*/
680		public void testEmptyOffer() {
681		SubmissionPublisher<Integer> p = basicPublisher();
682	<	assertEquals(p.offer(1, null), 0);
682	>	assertEquals(0, p.offer(1, null));
683		}
684
685		/**
686	<	* Offer(null) throws NPE
686	>	* offer(null) throws NPE
687		*/
688		public void testNullOffer() {
689		SubmissionPublisher<Integer> p = basicPublisher();
#	Line 693 | Line 694 | public class SubmissionPublisherTest ext
694		}
695
696		/**
697	<	* Offer returns number of lagged items if not saturated
697	>	* offer returns number of lagged items if not saturated
698		*/
699		public void testLaggedOffer() {
700		SubmissionPublisher<Integer> p = basicPublisher();
#	Line 713 | Line 714 | public class SubmissionPublisherTest ext
714		p.offer(4, null);
715		p.close();
716		s2.awaitComplete();
717	<	assertEquals(s2.nexts, 4);
717	>	assertEquals(4, s2.nexts);
718		s1.awaitComplete();
719	<	assertEquals(s2.nexts, 4);
719	>	assertEquals(4, s2.nexts);
720		}
721
722		/**
723	<	* Offer reports drops if saturated
723	>	* offer reports drops if saturated
724		*/
725		public void testDroppedOffer() {
726		SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(
#	Line 747 | Line 748 | public class SubmissionPublisherTest ext
748		}
749
750		/**
751	<	* Offer invokes drop handler if saturated
751	>	* offer invokes drop handler if saturated
752		*/
753		public void testHandledDroppedOffer() {
754		AtomicInteger calls = new AtomicInteger();
#	Line 774 | Line 775 | public class SubmissionPublisherTest ext
775		assertTrue(calls.get() >= 4);
776		}
777
777	–
778		/**
779	<	* Offer succeeds if drop handler forces request
779	>	* offer succeeds if drop handler forces request
780		*/
781		public void testRecoveredHandledDroppedOffer() {
782		AtomicInteger calls = new AtomicInteger();
#	Line 798 | Line 798 | public class SubmissionPublisherTest ext
798		p.close();
799		s2.awaitComplete();
800		s1.awaitComplete();
801	<	assertEquals(s1.nexts + s2.nexts, n);
801	>	assertEquals(n, s1.nexts + s2.nexts);
802		assertTrue(calls.get() >= 2);
803		}
804
805	–
805		/**
806	<	* TimedOffer to a publisher with no subscribers returns lag 0
806	>	* Timed offer to a publisher with no subscribers returns lag 0
807		*/
808		public void testEmptyTimedOffer() {
809		SubmissionPublisher<Integer> p = basicPublisher();
810	<	assertEquals(p.offer(1, null), 0);
810	>	long startTime = System.nanoTime();
811	>	assertEquals(0, p.offer(1, LONG_DELAY_MS, MILLISECONDS, null));
812	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);
813		}
814
815		/**
816	<	* Timed Offer with null item or TimeUnit throws NPE
816	>	* Timed offer with null item or TimeUnit throws NPE
817		*/
818		public void testNullTimedOffer() {
819		SubmissionPublisher<Integer> p = basicPublisher();
820	+	long startTime = System.nanoTime();
821		try {
822	<	p.offer(null, SHORT_DELAY_MS, MILLISECONDS, null);
822	>	p.offer(null, LONG_DELAY_MS, MILLISECONDS, null);
823		shouldThrow();
824		} catch (NullPointerException success) {}
825		try {
826	<	p.offer(1, SHORT_DELAY_MS, null, null);
826	>	p.offer(1, LONG_DELAY_MS, null, null);
827		shouldThrow();
828		} catch (NullPointerException success) {}
829	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);
830		}
831
832		/**
833	<	* Timed Offer returns number of lagged items if not saturated
833	>	* Timed offer returns number of lagged items if not saturated
834		*/
835		public void testLaggedTimedOffer() {
836		SubmissionPublisher<Integer> p = basicPublisher();
#	Line 839 | Line 842 | public class SubmissionPublisherTest ext
842		p.subscribe(s2);
843		s2.awaitSubscribe();
844		s1.awaitSubscribe();
845	<	assertTrue(p.offer(1, SHORT_DELAY_MS, MILLISECONDS, null) >= 1);
846	<	assertTrue(p.offer(2, SHORT_DELAY_MS, MILLISECONDS, null) >= 2);
845	>	long startTime = System.nanoTime();
846	>	assertTrue(p.offer(1, LONG_DELAY_MS, MILLISECONDS, null) >= 1);
847	>	assertTrue(p.offer(2, LONG_DELAY_MS, MILLISECONDS, null) >= 2);
848		s1.sn.request(4);
849	<	assertTrue(p.offer(3, SHORT_DELAY_MS, MILLISECONDS, null) >= 3);
849	>	assertTrue(p.offer(3, LONG_DELAY_MS, MILLISECONDS, null) >= 3);
850		s2.sn.request(4);
851	<	p.offer(4, SHORT_DELAY_MS, MILLISECONDS, null);
851	>	p.offer(4, LONG_DELAY_MS, MILLISECONDS, null);
852		p.close();
853		s2.awaitComplete();
854	<	assertEquals(s2.nexts, 4);
854	>	assertEquals(4, s2.nexts);
855		s1.awaitComplete();
856	<	assertEquals(s2.nexts, 4);
856	>	assertEquals(4, s2.nexts);
857	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);
858		}
859
860		/**
861	<	* Timed Offer reports drops if saturated
861	>	* Timed offer reports drops if saturated
862		*/
863		public void testDroppedTimedOffer() {
864		SubmissionPublisher<Integer> p = new SubmissionPublisher<Integer>(
#	Line 866 | Line 871 | public class SubmissionPublisherTest ext
871		p.subscribe(s2);
872		s2.awaitSubscribe();
873		s1.awaitSubscribe();
874	+	long delay = timeoutMillis();
875		for (int i = 1; i <= 4; ++i)
876	<	assertTrue(p.offer(i, SHORT_DELAY_MS, MILLISECONDS, null) >= 0);
877	<	p.offer(5, SHORT_DELAY_MS, MILLISECONDS, null);
878	<	assertTrue(p.offer(6, SHORT_DELAY_MS, MILLISECONDS, null) < 0);
876	>	assertTrue(p.offer(i, delay, MILLISECONDS, null) >= 0);
877	>	long startTime = System.nanoTime();
878	>	assertTrue(p.offer(5, delay, MILLISECONDS, null) < 0);
879		s1.sn.request(64);
880	<	assertTrue(p.offer(7, SHORT_DELAY_MS, MILLISECONDS, null) < 0);
880	>	assertTrue(p.offer(6, delay, MILLISECONDS, null) < 0);
881	>	// 2 * delay should elapse but check only 1 * delay to allow timer slop
882	>	assertTrue(millisElapsedSince(startTime) >= delay);
883		s2.sn.request(64);
884		p.close();
885		s2.awaitComplete();
#	Line 881 | Line 889 | public class SubmissionPublisherTest ext
889		}
890
891		/**
892	<	* Timed Offer invokes drop handler if saturated
892	>	* Timed offer invokes drop handler if saturated
893		*/
894		public void testHandledDroppedTimedOffer() {
895		AtomicInteger calls = new AtomicInteger();
#	Line 895 | Line 903 | public class SubmissionPublisherTest ext
903		p.subscribe(s2);
904		s2.awaitSubscribe();
905		s1.awaitSubscribe();
906	+	long delay = timeoutMillis();
907		for (int i = 1; i <= 4; ++i)
908	<	assertTrue(p.offer(i, SHORT_DELAY_MS, MILLISECONDS, (s, x) -> noopHandle(calls)) >= 0);
909	<	p.offer(5, (s, x) -> noopHandle(calls));
910	<	assertTrue(p.offer(6, SHORT_DELAY_MS, MILLISECONDS, (s, x) -> noopHandle(calls)) < 0);
908	>	assertTrue(p.offer(i, delay, MILLISECONDS, (s, x) -> noopHandle(calls)) >= 0);
909	>	long startTime = System.nanoTime();
910	>	assertTrue(p.offer(5, delay, MILLISECONDS, (s, x) -> noopHandle(calls)) < 0);
911		s1.sn.request(64);
912	<	assertTrue(p.offer(7, SHORT_DELAY_MS, MILLISECONDS, (s, x) -> noopHandle(calls)) < 0);
912	>	assertTrue(p.offer(6, delay, MILLISECONDS, (s, x) -> noopHandle(calls)) < 0);
913	>	assertTrue(millisElapsedSince(startTime) >= delay);
914		s2.sn.request(64);
915		p.close();
916		s2.awaitComplete();
#	Line 909 | Line 919 | public class SubmissionPublisherTest ext
919		}
920
921		/**
922	<	* Timed Offer succeeds if drop handler forces request
922	>	* Timed offer succeeds if drop handler forces request
923		*/
924		public void testRecoveredHandledDroppedTimedOffer() {
925		AtomicInteger calls = new AtomicInteger();
#	Line 924 | Line 934 | public class SubmissionPublisherTest ext
934		s2.awaitSubscribe();
935		s1.awaitSubscribe();
936		int n = 0;
937	<	for (int i = 1; i <= 8; ++i) {
938	<	int d = p.offer(i, SHORT_DELAY_MS, MILLISECONDS, (s, x) -> reqHandle(calls, s));
937	>	long delay = timeoutMillis();
938	>	long startTime = System.nanoTime();
939	>	for (int i = 1; i <= 6; ++i) {
940	>	int d = p.offer(i, delay, MILLISECONDS, (s, x) -> reqHandle(calls, s));
941		n = n + 2 + (d < 0 ? d : 0);
942		}
943	+	assertTrue(millisElapsedSince(startTime) >= delay);
944		p.close();
945		s2.awaitComplete();
946		s1.awaitComplete();
947	<	assertEquals(s1.nexts + s2.nexts, n);
947	>	assertEquals(n, s1.nexts + s2.nexts);
948		assertTrue(calls.get() >= 2);
949		}
950
938	–
951		}

Diff Legend

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