ViewVC Help

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

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

Comparing jsr166/src/test/tck/CountedCompleterTest.java (file contents):
Revision 1.23 by jsr166, Sun Oct 18 19:12:45 2015 UTC vs.
Revision 1.37 by jsr166, Sun Jul 22 20:23:28 2018 UTC

#	Line 5 | Line 5
5		*/
6
7		import static java.util.concurrent.TimeUnit.MILLISECONDS;
8	–	import static java.util.concurrent.TimeUnit.SECONDS;
8
9		import java.util.HashSet;
10		import java.util.concurrent.CancellationException;
#	Line 77 | Line 76 | public class CountedCompleterTest extend
76		assertNull(a.getRawResult());
77
78		try {
79	<	a.get(0L, SECONDS);
79	>	a.get(randomExpiredTimeout(), randomTimeUnit());
80		shouldThrow();
81		} catch (TimeoutException success) {
82		} catch (Throwable fail) { threadUnexpectedException(fail); }
#	Line 95 | Line 94 | public class CountedCompleterTest extend
94		Thread.currentThread().interrupt();
95		long startTime = System.nanoTime();
96		assertNull(a.join());
97	<	assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
97	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
98		Thread.interrupted();
99		}
100
#	Line 103 | Line 102 | public class CountedCompleterTest extend
102		Thread.currentThread().interrupt();
103		long startTime = System.nanoTime();
104		a.quietlyJoin();        // should be no-op
105	<	assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
105	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
106		Thread.interrupted();
107		}
108
109		assertFalse(a.cancel(false));
110		assertFalse(a.cancel(true));
111	+
112	+	Object v1 = null, v2 = null;
113		try {
114	<	assertNull(a.get());
115	<	} catch (Throwable fail) { threadUnexpectedException(fail); }
115	<	try {
116	<	assertNull(a.get(5L, SECONDS));
114	>	v1 = a.get();
115	>	v2 = a.get(randomTimeout(), randomTimeUnit());
116		} catch (Throwable fail) { threadUnexpectedException(fail); }
117	+	assertNull(v1);
118	+	assertNull(v2);
119		}
120
121		void checkCancelled(CountedCompleter a) {
#	Line 138 | Line 139 | public class CountedCompleterTest extend
139		{
140		long startTime = System.nanoTime();
141		a.quietlyJoin();        // should be no-op
142	<	assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
142	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
143		}
144
145		try {
#	Line 148 | Line 149 | public class CountedCompleterTest extend
149		} catch (Throwable fail) { threadUnexpectedException(fail); }
150
151		try {
152	<	a.get(5L, SECONDS);
152	>	a.get(randomTimeout(), randomTimeUnit());
153		shouldThrow();
154		} catch (CancellationException success) {
155		} catch (Throwable fail) { threadUnexpectedException(fail); }
#	Line 176 | Line 177 | public class CountedCompleterTest extend
177		{
178		long startTime = System.nanoTime();
179		a.quietlyJoin();        // should be no-op
180	<	assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
180	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
181		}
182
183		try {
#	Line 187 | Line 188 | public class CountedCompleterTest extend
188		} catch (Throwable fail) { threadUnexpectedException(fail); }
189
190		try {
191	<	a.get(5L, SECONDS);
191	>	a.get(randomTimeout(), randomTimeUnit());
192		shouldThrow();
193		} catch (ExecutionException success) {
194		assertSame(t.getClass(), success.getCause().getClass());
#	Line 210 | Line 211 | public class CountedCompleterTest extend
211		final AtomicInteger onCompletionN = new AtomicInteger(0);
212		final AtomicInteger onExceptionalCompletionN = new AtomicInteger(0);
213		final AtomicInteger setRawResultN = new AtomicInteger(0);
214	<	final AtomicReference<Object> rawResult = new AtomicReference<Object>(null);
214	>	final AtomicReference<Object> rawResult = new AtomicReference<>(null);
215		int computeN() { return computeN.get(); }
216		int onCompletionN() { return onCompletionN.get(); }
217		int onExceptionalCompletionN() { return onExceptionalCompletionN.get(); }
#	Line 335 | Line 336 | public class CountedCompleterTest extend
336		public void testSetPendingCount() {
337		NoopCC a = new NoopCC();
338		assertEquals(0, a.getPendingCount());
339	<	a.setPendingCount(1);
340	<	assertEquals(1, a.getPendingCount());
341	<	a.setPendingCount(27);
342	<	assertEquals(27, a.getPendingCount());
339	>	int[] vals = {
340	>	-1, 0, 1,
341	>	Integer.MIN_VALUE,
342	>	Integer.MAX_VALUE,
343	>	};
344	>	for (int val : vals) {
345	>	a.setPendingCount(val);
346	>	assertEquals(val, a.getPendingCount());
347	>	}
348		}
349
350		/**
#	Line 351 | Line 357 | public class CountedCompleterTest extend
357		assertEquals(1, a.getPendingCount());
358		a.addToPendingCount(27);
359		assertEquals(28, a.getPendingCount());
360	+	a.addToPendingCount(-28);
361	+	assertEquals(0, a.getPendingCount());
362		}
363
364		/**
#	Line 492 | Line 500 | public class CountedCompleterTest extend
500		}
501
502		/**
503	<	* quietlyCompleteRoot completes root task
503	>	* quietlyCompleteRoot completes root task and only root task
504		*/
505		public void testQuietlyCompleteRoot() {
506		NoopCC a = new NoopCC();
#	Line 695 | Line 703 | public class CountedCompleterTest extend
703		CCF f = new LCCF(8);
704		assertSame(f, f.fork());
705		try {
706	<	f.get(5L, null);
706	>	f.get(randomTimeout(), null);
707		shouldThrow();
708		} catch (NullPointerException success) {}
709		}};
#	Line 727 | Line 735 | public class CountedCompleterTest extend
735		CCF f = new LCCF(8);
736		assertSame(f, f.fork());
737		helpQuiesce();
738	+	while (!f.isDone()) // wait out race
739	+	;
740		assertEquals(21, f.number);
741		assertEquals(0, getQueuedTaskCount());
742		checkCompletedNormally(f);
#	Line 1417 | Line 1427 | public class CountedCompleterTest extend
1427		CCF f = new LCCF(8);
1428		assertSame(f, f.fork());
1429		try {
1430	<	f.get(5L, null);
1430	>	f.get(randomTimeout(), null);
1431		shouldThrow();
1432		} catch (NullPointerException success) {}
1433		}};

Diff Legend

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