ViewVC Help

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

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

Comparing jsr166/src/test/tck/ReentrantLockTest.java (file contents):
Revision 1.52 by jsr166, Thu May 30 03:28:55 2013 UTC vs.
Revision 1.60 by jsr166, Fri Jul 3 00:23:43 2015 UTC

#	Line 6 | Line 6
6		* Pat Fisher, Mike Judd.
7		*/
8
9	<	import junit.framework.*;
10	<	import java.util.concurrent.locks.Condition;
11	<	import java.util.concurrent.locks.ReentrantLock;
9	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
10	>
11	>	import java.util.Arrays;
12	>	import java.util.Collection;
13	>	import java.util.HashSet;
14		import java.util.concurrent.CountDownLatch;
15		import java.util.concurrent.CyclicBarrier;
16	<	import static java.util.concurrent.TimeUnit.MILLISECONDS;
17	<	import java.util.*;
16	>	import java.util.concurrent.locks.Condition;
17	>	import java.util.concurrent.locks.ReentrantLock;
18	>
19	>	import junit.framework.AssertionFailedError;
20	>	import junit.framework.Test;
21	>	import junit.framework.TestSuite;
22
23		public class ReentrantLockTest extends JSR166TestCase {
24		public static void main(String[] args) {
25	<	junit.textui.TestRunner.run(suite());
25	>	main(suite(), args);
26		}
27		public static Test suite() {
28		return new TestSuite(ReentrantLockTest.class);
29		}
30
31		/**
32	<	* A runnable calling lockInterruptibly
32	>	* A checked runnable calling lockInterruptibly
33		*/
34		class InterruptibleLockRunnable extends CheckedRunnable {
35		final ReentrantLock lock;
36	<	InterruptibleLockRunnable(ReentrantLock l) { lock = l; }
36	>	InterruptibleLockRunnable(ReentrantLock lock) { this.lock = lock; }
37		public void realRun() throws InterruptedException {
38		lock.lockInterruptibly();
39		}
40		}
41
42		/**
43	<	* A runnable calling lockInterruptibly that expects to be
43	>	* A checked runnable calling lockInterruptibly that expects to be
44		* interrupted
45		*/
46		class InterruptedLockRunnable extends CheckedInterruptedRunnable {
47		final ReentrantLock lock;
48	<	InterruptedLockRunnable(ReentrantLock l) { lock = l; }
48	>	InterruptedLockRunnable(ReentrantLock lock) { this.lock = lock; }
49		public void realRun() throws InterruptedException {
50		lock.lockInterruptibly();
51		}
#	Line 137 | Line 143 | public class ReentrantLockTest extends J
143		lock.unlock();
144		}
145
146	<	enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil };
146	>	enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil }
147
148		/**
149	<	* Awaits condition using the specified AwaitMethod.
149	>	* Awaits condition "indefinitely" using the specified AwaitMethod.
150		*/
151		void await(Condition c, AwaitMethod awaitMethod)
152		throws InterruptedException {
#	Line 153 | Line 159 | public class ReentrantLockTest extends J
159		assertTrue(c.await(timeoutMillis, MILLISECONDS));
160		break;
161		case awaitNanos:
162	<	long nanosTimeout = MILLISECONDS.toNanos(timeoutMillis);
163	<	long nanosRemaining = c.awaitNanos(nanosTimeout);
162	>	long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
163	>	long nanosRemaining = c.awaitNanos(timeoutNanos);
164		assertTrue(nanosRemaining > 0);
165	+	assertTrue(nanosRemaining <= timeoutNanos);
166		break;
167		case awaitUntil:
168		assertTrue(c.awaitUntil(delayedDate(timeoutMillis)));
169		break;
170	+	default:
171	+	throw new AssertionError();
172		}
173		}
174
#	Line 416 | Line 425 | public class ReentrantLockTest extends J
425		}
426		for (int i = SIZE; i > 0; i--) {
427		lock.unlock();
428	<	assertEquals(i-1, lock.getHoldCount());
428	>	assertEquals(i - 1, lock.getHoldCount());
429		}
430		}
431
#	Line 452 | Line 461 | public class ReentrantLockTest extends J
461		barrier.await();
462		awaitTermination(t);
463		assertFalse(lock.isLocked());
464	<	} catch (Exception e) {
456	<	threadUnexpectedException(e);
457	<	}
464	>	} catch (Exception fail) { threadUnexpectedException(fail); }
465		}
466
467		/**
#	Line 466 | Line 473 | public class ReentrantLockTest extends J
473		final PublicReentrantLock lock = new PublicReentrantLock(fair);
474		try {
475		lock.lockInterruptibly();
476	<	} catch (InterruptedException ie) {
470	<	threadUnexpectedException(ie);
471	<	}
476	>	} catch (InterruptedException fail) { threadUnexpectedException(fail); }
477		assertLockedByMoi(lock);
478		Thread t = newStartedThread(new InterruptedLockRunnable(lock));
479		waitForQueuedThread(lock, t);
#	Line 529 | Line 534 | public class ReentrantLockTest extends J
534		assertTrue(nanosRemaining <= 0);
535		assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
536		lock.unlock();
537	<	} catch (InterruptedException e) {
533	<	threadUnexpectedException(e);
534	<	}
537	>	} catch (InterruptedException fail) { threadUnexpectedException(fail); }
538		}
539
540		/**
#	Line 549 | Line 552 | public class ReentrantLockTest extends J
552		assertFalse(c.await(timeoutMillis, MILLISECONDS));
553		assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
554		lock.unlock();
555	<	} catch (InterruptedException e) {
553	<	threadUnexpectedException(e);
554	<	}
555	>	} catch (InterruptedException fail) { threadUnexpectedException(fail); }
556		}
557
558		/**
#	Line 570 | Line 571 | public class ReentrantLockTest extends J
571		assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + timeoutMillis)));
572		assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
573		lock.unlock();
574	<	} catch (InterruptedException e) {
574	<	threadUnexpectedException(e);
575	<	}
574	>	} catch (InterruptedException fail) { threadUnexpectedException(fail); }
575		}
576
577		/**

Diff Legend

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