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.2 by dl, Sat Sep 6 19:36:05 2003 UTC vs.
Revision 1.9 by dl, Mon Nov 3 13:50:07 2003 UTC

#	Line 8 | Line 8
8		import junit.framework.*;
9		import java.util.concurrent.locks.*;
10		import java.util.concurrent.*;
11	+	import java.util.*;
12	+	import java.io.*;
13
14	<	public class ReentrantLockTest extends TestCase {
13	<	static int HOLD_COUNT_TEST_LIMIT = 20;
14	<
14	>	public class ReentrantLockTest extends JSR166TestCase {
15		public static void main(String[] args) {
16		junit.textui.TestRunner.run (suite());
17		}
18	–
18		public static Test suite() {
19		return new TestSuite(ReentrantLockTest.class);
20		}
21
22	<	private static long SHORT_DELAY_MS = 100;
23	<	private static long MEDIUM_DELAY_MS = 1000;
25	<	private static long LONG_DELAY_MS = 10000;
26	<
27	<	/*
28	<	* Unlocks an unlocked lock, throws Illegal Monitor State
29	<	*
22	>	/**
23	>	* A runnable calling lockInterruptibly
24		*/
25	<
26	<	public void testIllegalMonitorStateException(){
25	>	class InterruptibleLockRunnable implements Runnable {
26	>	final ReentrantLock lock;
27	>	InterruptibleLockRunnable(ReentrantLock l) { lock = l; }
28	>	public void run() {
29	>	try {
30	>	lock.lockInterruptibly();
31	>	} catch(InterruptedException success){}
32	>	}
33	>	}
34	>
35	>
36	>	/**
37	>	* A runnable calling lockInterruptibly that expects to be
38	>	* interrupted
39	>	*/
40	>	class InterruptedLockRunnable implements Runnable {
41	>	final ReentrantLock lock;
42	>	InterruptedLockRunnable(ReentrantLock l) { lock = l; }
43	>	public void run() {
44	>	try {
45	>	lock.lockInterruptibly();
46	>	threadShouldThrow();
47	>	} catch(InterruptedException success){}
48	>	}
49	>	}
50	>
51	>	/**
52	>	* Subclass to expose protected methods
53	>	*/
54	>	static class PublicReentrantLock extends ReentrantLock {
55	>	PublicReentrantLock() { super(); }
56	>	public Collection<Thread> getQueuedThreads() {
57	>	return super.getQueuedThreads();
58	>	}
59	>	public ConditionObject newCondition() {
60	>	return new PublicCondition(this);
61	>	}
62	>
63	>	static class PublicCondition extends ReentrantLock.ConditionObject {
64	>	PublicCondition(PublicReentrantLock l) { super(l); }
65	>	public Collection<Thread> getWaitingThreads() {
66	>	return super.getWaitingThreads();
67	>	}
68	>	}
69	>
70	>	}
71	>
72	>	/**
73	>	* Constructor sets given fairness
74	>	*/
75	>	public void testConstructor() {
76		ReentrantLock rl = new ReentrantLock();
77	<	try{
78	<	rl.unlock();
79	<	fail("Should of thown Illegal Monitor State Exception");
77	>	assertFalse(rl.isFair());
78	>	ReentrantLock r2 = new ReentrantLock(true);
79	>	assertTrue(r2.isFair());
80	>	}
81
82	<	}catch(IllegalMonitorStateException sucess){}
82	>	/**
83	>	* locking an unlocked lock succeeds
84	>	*/
85	>	public void testLock() {
86	>	ReentrantLock rl = new ReentrantLock();
87	>	rl.lock();
88	>	assertTrue(rl.isLocked());
89	>	rl.unlock();
90	>	}
91
92	+	/**
93	+	* locking an unlocked fair lock succeeds
94	+	*/
95	+	public void testFairLock() {
96	+	ReentrantLock rl = new ReentrantLock(true);
97	+	rl.lock();
98	+	assertTrue(rl.isLocked());
99	+	rl.unlock();
100	+	}
101
102	+	/**
103	+	* Unlocking an unlocked lock throws IllegalMonitorStateException
104	+	*/
105	+	public void testUnlock_IllegalMonitorStateException() {
106	+	ReentrantLock rl = new ReentrantLock();
107	+	try {
108	+	rl.unlock();
109	+	shouldThrow();
110	+
111	+	} catch(IllegalMonitorStateException success){}
112		}
113	<
114	<	/*
115	<	* makes a lock, locks it, tries to aquire the lock in another thread
45	<	* interrupts that thread and waits for an interrupted Exception to
46	<	* be thrown.
113	>
114	>	/**
115	>	* trylock on an unlocked lock succeeds
116		*/
117	+	public void testTryLock() {
118	+	ReentrantLock rl = new ReentrantLock();
119	+	assertTrue(rl.tryLock());
120	+	assertTrue(rl.isLocked());
121	+	rl.unlock();
122	+	}
123
124	<	public void testInterruptedException(){
124	>
125	>	/**
126	>	* getQueueLength reports number of waiting threads
127	>	*/
128	>	public void testGetQueueLength() {
129	>	final ReentrantLock lock = new ReentrantLock();
130	>	Thread t1 = new Thread(new InterruptedLockRunnable(lock));
131	>	Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
132	>	try {
133	>	assertEquals(0, lock.getQueueLength());
134	>	lock.lock();
135	>	t1.start();
136	>	Thread.sleep(SHORT_DELAY_MS);
137	>	assertEquals(1, lock.getQueueLength());
138	>	t2.start();
139	>	Thread.sleep(SHORT_DELAY_MS);
140	>	assertEquals(2, lock.getQueueLength());
141	>	t1.interrupt();
142	>	Thread.sleep(SHORT_DELAY_MS);
143	>	assertEquals(1, lock.getQueueLength());
144	>	lock.unlock();
145	>	Thread.sleep(SHORT_DELAY_MS);
146	>	assertEquals(0, lock.getQueueLength());
147	>	t1.join();
148	>	t2.join();
149	>	} catch(Exception e){
150	>	unexpectedException();
151	>	}
152	>	}
153	>
154	>	/**
155	>	* getQueuedThreads includes waiting threads
156	>	*/
157	>	public void testGetQueuedThreads() {
158	>	final PublicReentrantLock lock = new PublicReentrantLock();
159	>	Thread t1 = new Thread(new InterruptedLockRunnable(lock));
160	>	Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
161	>	try {
162	>	assertTrue(lock.getQueuedThreads().isEmpty());
163	>	lock.lock();
164	>	assertTrue(lock.getQueuedThreads().isEmpty());
165	>	t1.start();
166	>	Thread.sleep(SHORT_DELAY_MS);
167	>	assertTrue(lock.getQueuedThreads().contains(t1));
168	>	t2.start();
169	>	Thread.sleep(SHORT_DELAY_MS);
170	>	assertTrue(lock.getQueuedThreads().contains(t1));
171	>	assertTrue(lock.getQueuedThreads().contains(t2));
172	>	t1.interrupt();
173	>	Thread.sleep(SHORT_DELAY_MS);
174	>	assertFalse(lock.getQueuedThreads().contains(t1));
175	>	assertTrue(lock.getQueuedThreads().contains(t2));
176	>	lock.unlock();
177	>	Thread.sleep(SHORT_DELAY_MS);
178	>	assertTrue(lock.getQueuedThreads().isEmpty());
179	>	t1.join();
180	>	t2.join();
181	>	} catch(Exception e){
182	>	unexpectedException();
183	>	}
184	>	}
185	>
186	>
187	>	/**
188	>	* timed trylock is interruptible.
189	>	*/
190	>	public void testInterruptedException2() {
191		final ReentrantLock lock = new ReentrantLock();
192		lock.lock();
193		Thread t = new Thread(new Runnable() {
194	<	public void run(){
195	<	try{
196	<	lock.lockInterruptibly();
197	<	fail("should throw");
198	<	}catch(InterruptedException sucess){}
194	>	public void run() {
195	>	try {
196	>	lock.tryLock(MEDIUM_DELAY_MS,TimeUnit.MILLISECONDS);
197	>	threadShouldThrow();
198	>	} catch(InterruptedException success){}
199		}
200		});
201	<	t.start();
202	<	t.interrupt();
203	<	lock.unlock();
204	<	}
201	>	try {
202	>	t.start();
203	>	t.interrupt();
204	>	} catch(Exception e){
205	>	unexpectedException();
206	>	}
207	>	}
208
65	–	/*
66	–	* tests for interrupted exception on a timed wait
67	–	*
68	–	*/
69	–
209
210	<	public void testInterruptedException2(){
210	>	/**
211	>	* Trylock on a locked lock fails
212	>	*/
213	>	public void testTryLockWhenLocked() {
214		final ReentrantLock lock = new ReentrantLock();
215		lock.lock();
216		Thread t = new Thread(new Runnable() {
217	<	public void run(){
218	<	try{
77	<	lock.tryLock(1000,TimeUnit.MILLISECONDS);
78	<	fail("should throw");
79	<	}catch(InterruptedException sucess){}
217	>	public void run() {
218	>	threadAssertFalse(lock.tryLock());
219		}
220		});
221	<	t.start();
222	<	t.interrupt();
223	<	}
221	>	try {
222	>	t.start();
223	>	t.join();
224	>	lock.unlock();
225	>	} catch(Exception e){
226	>	unexpectedException();
227	>	}
228	>	}
229
230	+	/**
231	+	* Timed trylock on a locked lock times out
232	+	*/
233	+	public void testTryLock_Timeout() {
234	+	final ReentrantLock lock = new ReentrantLock();
235	+	lock.lock();
236	+	Thread t = new Thread(new Runnable() {
237	+	public void run() {
238	+	try {
239	+	threadAssertFalse(lock.tryLock(1, TimeUnit.MILLISECONDS));
240	+	} catch (Exception ex) {
241	+	threadUnexpectedException();
242	+	}
243	+	}
244	+	});
245	+	try {
246	+	t.start();
247	+	t.join();
248	+	lock.unlock();
249	+	} catch(Exception e){
250	+	unexpectedException();
251	+	}
252	+	}
253
254	+	/**
255	+	* getHoldCount returns number of recursive holds
256	+	*/
257		public void testGetHoldCount() {
258		ReentrantLock lock = new ReentrantLock();
259	<	for(int i = 1; i <= ReentrantLockTest.HOLD_COUNT_TEST_LIMIT;i++) {
259	>	for(int i = 1; i <= SIZE; i++) {
260		lock.lock();
261		assertEquals(i,lock.getHoldCount());
262		}
263	<	for(int i = ReentrantLockTest.HOLD_COUNT_TEST_LIMIT; i > 0; i--) {
263	>	for(int i = SIZE; i > 0; i--) {
264		lock.unlock();
265		assertEquals(i-1,lock.getHoldCount());
266		}
267		}
268
269
270	<
271	<
270	>	/**
271	>	* isLocked is true when locked and false when not
272	>	*/
273		public void testIsLocked() {
274		final ReentrantLock lock = new ReentrantLock();
275		lock.lock();
#	Line 109 | Line 280 | public class ReentrantLockTest extends T
280		public void run() {
281		lock.lock();
282		try {
283	<	Thread.sleep(SHORT_DELAY_MS * 2);
283	>	Thread.sleep(SMALL_DELAY_MS);
284		}
285	<	catch(Exception e) {}
285	>	catch(Exception e) {
286	>	threadUnexpectedException();
287	>	}
288		lock.unlock();
289		}
290		});
291	<	try{
291	>	try {
292		t.start();
293		Thread.sleep(SHORT_DELAY_MS);
294		assertTrue(lock.isLocked());
295		t.join();
296		assertFalse(lock.isLocked());
297		} catch(Exception e){
298	<	fail("unexpected exception");
298	>	unexpectedException();
299		}
127	–
300		}
301
302	<	/*
303	<	* current thread locks interruptibly the thread
304	<	* another thread tries to aquire the lock and blocks
133	<	* on the call. interrupt the attempted aquireLock
134	<	* assert that the first lock() call actually locked the lock
135	<	* assert that the current thread is the one holding the lock
302	>
303	>	/**
304	>	* lockInterruptibly is interruptible.
305		*/
306	+	public void testLockInterruptibly1() {
307	+	final ReentrantLock lock = new ReentrantLock();
308	+	lock.lock();
309	+	Thread t = new Thread(new InterruptedLockRunnable(lock));
310	+	try {
311	+	t.start();
312	+	t.interrupt();
313	+	lock.unlock();
314	+	t.join();
315	+	} catch(Exception e){
316	+	unexpectedException();
317	+	}
318	+	}
319
320	<	public void testLockedInterruptibly() {
320	>	/**
321	>	* lockInterruptibly succeeds when unlocked, else is interruptible
322	>	*/
323	>	public void testLockInterruptibly2() {
324		final ReentrantLock lock = new ReentrantLock();
325	<	try {lock.lockInterruptibly();} catch(Exception e) {}
326	<	Thread t = new Thread(new Runnable() {
327	<	public void run() {
328	<	try {
329	<	lock.lockInterruptibly();
330	<	fail("Failed to generate an Interrupted Exception");
331	<	}
332	<	catch(InterruptedException e) {}
333	<	}
334	<	});
335	<	t.start();
336	<	t.interrupt();
337	<	assertTrue(lock.isLocked());
338	<	assertTrue(lock.isHeldByCurrentThread());
325	>	try {
326	>	lock.lockInterruptibly();
327	>	} catch(Exception e) {
328	>	unexpectedException();
329	>	}
330	>	Thread t = new Thread(new InterruptedLockRunnable(lock));
331	>	try {
332	>	t.start();
333	>	t.interrupt();
334	>	assertTrue(lock.isLocked());
335	>	assertTrue(lock.isHeldByCurrentThread());
336	>	t.join();
337	>	} catch(Exception e){
338	>	unexpectedException();
339	>	}
340		}
341
342	+	/**
343	+	* Calling await without holding lock throws IllegalMonitorStateException
344	+	*/
345		public void testAwait_IllegalMonitor() {
346		final ReentrantLock lock = new ReentrantLock();
347		final Condition c = lock.newCondition();
348		try {
349		c.await();
350	<	fail("should throw");
350	>	shouldThrow();
351		}
352		catch (IllegalMonitorStateException success) {
353		}
354		catch (Exception ex) {
355	<	fail("should throw IMSE");
355	>	unexpectedException();
356		}
357		}
358
359	+	/**
360	+	* Calling signal without holding lock throws IllegalMonitorStateException
361	+	*/
362		public void testSignal_IllegalMonitor() {
363		final ReentrantLock lock = new ReentrantLock();
364		final Condition c = lock.newCondition();
365		try {
366		c.signal();
367	<	fail("should throw");
367	>	shouldThrow();
368		}
369		catch (IllegalMonitorStateException success) {
370		}
371		catch (Exception ex) {
372	<	fail("should throw IMSE");
372	>	unexpectedException();
373		}
374		}
375
376	+	/**
377	+	* awaitNanos without a signal times out
378	+	*/
379		public void testAwaitNanos_Timeout() {
380		final ReentrantLock lock = new ReentrantLock();
381		final Condition c = lock.newCondition();
#	Line 191 | Line 386 | public class ReentrantLockTest extends T
386		lock.unlock();
387		}
388		catch (Exception ex) {
389	<	fail("unexpected exception");
389	>	unexpectedException();
390		}
391		}
392
393	+	/**
394	+	*  timed await without a signal times out
395	+	*/
396		public void testAwait_Timeout() {
397		final ReentrantLock lock = new ReentrantLock();
398		final Condition c = lock.newCondition();
399		try {
400		lock.lock();
401	<	assertFalse(c.await(10, TimeUnit.MILLISECONDS));
401	>	assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
402		lock.unlock();
403		}
404		catch (Exception ex) {
405	<	fail("unexpected exception");
405	>	unexpectedException();
406		}
407		}
408
409	+	/**
410	+	* awaitUntil without a signal times out
411	+	*/
412		public void testAwaitUntil_Timeout() {
413		final ReentrantLock lock = new ReentrantLock();
414		final Condition c = lock.newCondition();
#	Line 218 | Line 419 | public class ReentrantLockTest extends T
419		lock.unlock();
420		}
421		catch (Exception ex) {
422	<	fail("unexpected exception");
422	>	unexpectedException();
423		}
424		}
425
426	+	/**
427	+	* await returns when signalled
428	+	*/
429		public void testAwait() {
430		final ReentrantLock lock = new ReentrantLock();
431	<	final Condition c = lock.newCondition();
431	>	final ReentrantLock.ConditionObject c = lock.newCondition();
432		Thread t = new Thread(new Runnable() {
433		public void run() {
434		try {
#	Line 233 | Line 437 | public class ReentrantLockTest extends T
437		lock.unlock();
438		}
439		catch(InterruptedException e) {
440	<	fail("unexpected exception");
440	>	threadUnexpectedException();
441		}
442		}
443		});
#	Line 248 | Line 452 | public class ReentrantLockTest extends T
452		assertFalse(t.isAlive());
453		}
454		catch (Exception ex) {
455	<	fail("unexpected exception");
455	>	unexpectedException();
456		}
457		}
458
459	+	/**
460	+	* hasWaiters returns true when a thread is waiting, else false
461	+	*/
462	+	public void testHasWaiters() {
463	+	final ReentrantLock lock = new ReentrantLock();
464	+	final ReentrantLock.ConditionObject c = lock.newCondition();
465	+	Thread t = new Thread(new Runnable() {
466	+	public void run() {
467	+	try {
468	+	lock.lock();
469	+	threadAssertFalse(c.hasWaiters());
470	+	threadAssertEquals(0, c.getWaitQueueLength());
471	+	c.await();
472	+	lock.unlock();
473	+	}
474	+	catch(InterruptedException e) {
475	+	threadUnexpectedException();
476	+	}
477	+	}
478	+	});
479	+
480	+	try {
481	+	t.start();
482	+	Thread.sleep(SHORT_DELAY_MS);
483	+	lock.lock();
484	+	assertTrue(c.hasWaiters());
485	+	assertEquals(1, c.getWaitQueueLength());
486	+	c.signal();
487	+	lock.unlock();
488	+	Thread.sleep(SHORT_DELAY_MS);
489	+	lock.lock();
490	+	assertFalse(c.hasWaiters());
491	+	assertEquals(0, c.getWaitQueueLength());
492	+	lock.unlock();
493	+	t.join(SHORT_DELAY_MS);
494	+	assertFalse(t.isAlive());
495	+	}
496	+	catch (Exception ex) {
497	+	unexpectedException();
498	+	}
499	+	}
500	+
501	+	/**
502	+	* getWaitQueueLength returns number of waiting threads
503	+	*/
504	+	public void testGetWaitQueueLength() {
505	+	final ReentrantLock lock = new ReentrantLock();
506	+	final ReentrantLock.ConditionObject c = lock.newCondition();
507	+	Thread t1 = new Thread(new Runnable() {
508	+	public void run() {
509	+	try {
510	+	lock.lock();
511	+	threadAssertFalse(c.hasWaiters());
512	+	threadAssertEquals(0, c.getWaitQueueLength());
513	+	c.await();
514	+	lock.unlock();
515	+	}
516	+	catch(InterruptedException e) {
517	+	threadUnexpectedException();
518	+	}
519	+	}
520	+	});
521	+
522	+	Thread t2 = new Thread(new Runnable() {
523	+	public void run() {
524	+	try {
525	+	lock.lock();
526	+	threadAssertTrue(c.hasWaiters());
527	+	threadAssertEquals(1, c.getWaitQueueLength());
528	+	c.await();
529	+	lock.unlock();
530	+	}
531	+	catch(InterruptedException e) {
532	+	threadUnexpectedException();
533	+	}
534	+	}
535	+	});
536	+
537	+	try {
538	+	t1.start();
539	+	Thread.sleep(SHORT_DELAY_MS);
540	+	t2.start();
541	+	Thread.sleep(SHORT_DELAY_MS);
542	+	lock.lock();
543	+	assertTrue(c.hasWaiters());
544	+	assertEquals(2, c.getWaitQueueLength());
545	+	c.signalAll();
546	+	lock.unlock();
547	+	Thread.sleep(SHORT_DELAY_MS);
548	+	lock.lock();
549	+	assertFalse(c.hasWaiters());
550	+	assertEquals(0, c.getWaitQueueLength());
551	+	lock.unlock();
552	+	t1.join(SHORT_DELAY_MS);
553	+	t2.join(SHORT_DELAY_MS);
554	+	assertFalse(t1.isAlive());
555	+	assertFalse(t2.isAlive());
556	+	}
557	+	catch (Exception ex) {
558	+	unexpectedException();
559	+	}
560	+	}
561	+
562	+	/**
563	+	* getWaitingThreads returns only and all waiting threads
564	+	*/
565	+	public void testGetWaitingThreads() {
566	+	final PublicReentrantLock lock = new PublicReentrantLock();
567	+	final PublicReentrantLock.PublicCondition c = (PublicReentrantLock.PublicCondition)lock.newCondition();
568	+	Thread t1 = new Thread(new Runnable() {
569	+	public void run() {
570	+	try {
571	+	lock.lock();
572	+	threadAssertTrue(c.getWaitingThreads().isEmpty());
573	+	c.await();
574	+	lock.unlock();
575	+	}
576	+	catch(InterruptedException e) {
577	+	threadUnexpectedException();
578	+	}
579	+	}
580	+	});
581	+
582	+	Thread t2 = new Thread(new Runnable() {
583	+	public void run() {
584	+	try {
585	+	lock.lock();
586	+	threadAssertFalse(c.getWaitingThreads().isEmpty());
587	+	c.await();
588	+	lock.unlock();
589	+	}
590	+	catch(InterruptedException e) {
591	+	threadUnexpectedException();
592	+	}
593	+	}
594	+	});
595	+
596	+	try {
597	+	lock.lock();
598	+	assertTrue(c.getWaitingThreads().isEmpty());
599	+	lock.unlock();
600	+	t1.start();
601	+	Thread.sleep(SHORT_DELAY_MS);
602	+	t2.start();
603	+	Thread.sleep(SHORT_DELAY_MS);
604	+	lock.lock();
605	+	assertTrue(c.hasWaiters());
606	+	assertTrue(c.getWaitingThreads().contains(t1));
607	+	assertTrue(c.getWaitingThreads().contains(t2));
608	+	c.signalAll();
609	+	lock.unlock();
610	+	Thread.sleep(SHORT_DELAY_MS);
611	+	lock.lock();
612	+	assertFalse(c.hasWaiters());
613	+	assertTrue(c.getWaitingThreads().isEmpty());
614	+	lock.unlock();
615	+	t1.join(SHORT_DELAY_MS);
616	+	t2.join(SHORT_DELAY_MS);
617	+	assertFalse(t1.isAlive());
618	+	assertFalse(t2.isAlive());
619	+	}
620	+	catch (Exception ex) {
621	+	unexpectedException();
622	+	}
623	+	}
624	+
625	+	/**
626	+	* awaitUninterruptibly doesn't abort on interrupt
627	+	*/
628		public void testAwaitUninterruptibly() {
629		final ReentrantLock lock = new ReentrantLock();
630		final Condition c = lock.newCondition();
#	Line 270 | Line 643 | public class ReentrantLockTest extends T
643		lock.lock();
644		c.signal();
645		lock.unlock();
646	+	assert(t.isInterrupted());
647		t.join(SHORT_DELAY_MS);
648		assertFalse(t.isAlive());
649		}
650		catch (Exception ex) {
651	<	fail("unexpected exception");
651	>	unexpectedException();
652		}
653		}
654
655	+	/**
656	+	* await is interruptible
657	+	*/
658		public void testAwait_Interrupt() {
659		final ReentrantLock lock = new ReentrantLock();
660		final Condition c = lock.newCondition();
#	Line 287 | Line 664 | public class ReentrantLockTest extends T
664		lock.lock();
665		c.await();
666		lock.unlock();
667	<	fail("should throw");
667	>	threadShouldThrow();
668		}
669		catch(InterruptedException success) {
670		}
#	Line 302 | Line 679 | public class ReentrantLockTest extends T
679		assertFalse(t.isAlive());
680		}
681		catch (Exception ex) {
682	<	fail("unexpected exception");
682	>	unexpectedException();
683		}
684		}
685
686	+	/**
687	+	* awaitNanos is interruptible
688	+	*/
689		public void testAwaitNanos_Interrupt() {
690		final ReentrantLock lock = new ReentrantLock();
691		final Condition c = lock.newCondition();
#	Line 315 | Line 695 | public class ReentrantLockTest extends T
695		lock.lock();
696		c.awaitNanos(SHORT_DELAY_MS * 2 * 1000000);
697		lock.unlock();
698	<	fail("should throw");
698	>	threadShouldThrow();
699		}
700		catch(InterruptedException success) {
701		}
#	Line 330 | Line 710 | public class ReentrantLockTest extends T
710		assertFalse(t.isAlive());
711		}
712		catch (Exception ex) {
713	<	fail("unexpected exception");
713	>	unexpectedException();
714		}
715		}
716
717	+	/**
718	+	* awaitUntil is interruptible
719	+	*/
720		public void testAwaitUntil_Interrupt() {
721		final ReentrantLock lock = new ReentrantLock();
722		final Condition c = lock.newCondition();
#	Line 344 | Line 727 | public class ReentrantLockTest extends T
727		java.util.Date d = new java.util.Date();
728		c.awaitUntil(new java.util.Date(d.getTime() + 10000));
729		lock.unlock();
730	<	fail("should throw");
730	>	threadShouldThrow();
731		}
732		catch(InterruptedException success) {
733		}
#	Line 359 | Line 742 | public class ReentrantLockTest extends T
742		assertFalse(t.isAlive());
743		}
744		catch (Exception ex) {
745	<	fail("unexpected exception");
745	>	unexpectedException();
746		}
747		}
748
749	+	/**
750	+	* signalAll wakes up all threads
751	+	*/
752		public void testSignalAll() {
753		final ReentrantLock lock = new ReentrantLock();
754		final Condition c = lock.newCondition();
#	Line 374 | Line 760 | public class ReentrantLockTest extends T
760		lock.unlock();
761		}
762		catch(InterruptedException e) {
763	<	fail("unexpected exception");
763	>	threadUnexpectedException();
764		}
765		}
766		});
#	Line 387 | Line 773 | public class ReentrantLockTest extends T
773		lock.unlock();
774		}
775		catch(InterruptedException e) {
776	<	fail("unexpected exception");
776	>	threadUnexpectedException();
777		}
778		}
779		});
#	Line 405 | Line 791 | public class ReentrantLockTest extends T
791		assertFalse(t2.isAlive());
792		}
793		catch (Exception ex) {
794	<	fail("unexpected exception");
794	>	unexpectedException();
795	>	}
796	>	}
797	>
798	>	/**
799	>	* A serialized lock deserializes as unlocked
800	>	*/
801	>	public void testSerialization() {
802	>	ReentrantLock l = new ReentrantLock();
803	>	l.lock();
804	>	l.unlock();
805	>
806	>	try {
807	>	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
808	>	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
809	>	out.writeObject(l);
810	>	out.close();
811	>
812	>	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
813	>	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
814	>	ReentrantLock r = (ReentrantLock) in.readObject();
815	>	r.lock();
816	>	r.unlock();
817	>	} catch(Exception e){
818	>	e.printStackTrace();
819	>	unexpectedException();
820		}
821		}
822

Diff Legend

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