ViewVC Help

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

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

Comparing jsr166/src/test/tck/ReentrantReadWriteLockTest.java (file contents):
Revision 1.52 by jsr166, Mon May 2 00:34:12 2011 UTC vs.
Revision 1.53 by jsr166, Mon May 2 00:49:26 2011 UTC

#	Line 207 | Line 207 | public class ReentrantReadWriteLockTest
207
208		Thread.sleep(SHORT_DELAY_MS);
209		t.interrupt();
210	<	t.join();
210	>	awaitTermination(t, LONG_DELAY_MS);
211		releaseLock(lock.writeLock());
212		}
213
#	Line 224 | Line 224 | public class ReentrantReadWriteLockTest
224
225		Thread.sleep(SHORT_DELAY_MS);
226		t.interrupt();
227	<	t.join();
227	>	awaitTermination(t, LONG_DELAY_MS);
228		releaseLock(lock.writeLock());
229		}
230
#	Line 241 | Line 241 | public class ReentrantReadWriteLockTest
241
242		Thread.sleep(SHORT_DELAY_MS);
243		t.interrupt();
244	<	t.join();
244	>	awaitTermination(t, LONG_DELAY_MS);
245		releaseLock(lock.writeLock());
246		}
247
#	Line 258 | Line 258 | public class ReentrantReadWriteLockTest
258
259		Thread.sleep(SHORT_DELAY_MS);
260		t.interrupt();
261	<	t.join();
261	>	awaitTermination(t, LONG_DELAY_MS);
262		releaseLock(lock.writeLock());
263		}
264
#	Line 274 | Line 274 | public class ReentrantReadWriteLockTest
274		assertFalse(lock.writeLock().tryLock());
275		}});
276
277	<	t.join();
277	>	awaitTermination(t, LONG_DELAY_MS);
278		lock.writeLock().unlock();
279		}
280
#	Line 289 | Line 289 | public class ReentrantReadWriteLockTest
289		assertFalse(lock.readLock().tryLock());
290		}});
291
292	<	t.join();
292	>	awaitTermination(t, LONG_DELAY_MS);
293		lock.writeLock().unlock();
294		}
295
#	Line 305 | Line 305 | public class ReentrantReadWriteLockTest
305		lock.readLock().unlock();
306		}});
307
308	<	t.join();
308	>	awaitTermination(t, LONG_DELAY_MS);
309		lock.readLock().unlock();
310		}
311
#	Line 328 | Line 328 | public class ReentrantReadWriteLockTest
328
329		Thread.sleep(SHORT_DELAY_MS);
330		lock.readLock().unlock();
331	<	t1.join(MEDIUM_DELAY_MS);
332	<	t2.join(MEDIUM_DELAY_MS);
333	<	assertTrue(!t1.isAlive());
334	<	assertTrue(!t2.isAlive());
331	>	awaitTermination(t1, LONG_DELAY_MS);
332	>	awaitTermination(t2, LONG_DELAY_MS);
333		}
334
335		/**
#	Line 353 | Line 351 | public class ReentrantReadWriteLockTest
351
352		Thread.sleep(SHORT_DELAY_MS);
353		lock.writeLock().unlock();
354	<	t1.join(MEDIUM_DELAY_MS);
355	<	t2.join(MEDIUM_DELAY_MS);
358	<	assertTrue(!t1.isAlive());
359	<	assertTrue(!t2.isAlive());
354	>	awaitTermination(t1, LONG_DELAY_MS);
355	>	awaitTermination(t2, LONG_DELAY_MS);
356		}
357
358		/**
#	Line 394 | Line 390 | public class ReentrantReadWriteLockTest
390		lock.readLock().lock();
391		lock.readLock().unlock();
392		lock.writeLock().unlock();
393	<	t1.join(MEDIUM_DELAY_MS);
394	<	t2.join(MEDIUM_DELAY_MS);
399	<	assertTrue(!t1.isAlive());
400	<	assertTrue(!t2.isAlive());
393	>	awaitTermination(t1, LONG_DELAY_MS);
394	>	awaitTermination(t2, LONG_DELAY_MS);
395		}
396
397		/**
#	Line 424 | Line 418 | public class ReentrantReadWriteLockTest
418		lock.readLock().lock();
419		lock.readLock().unlock();
420		lock.writeLock().unlock();
421	<	t1.join(MEDIUM_DELAY_MS);
422	<	t2.join(MEDIUM_DELAY_MS);
429	<	assertTrue(!t1.isAlive());
430	<	assertTrue(!t2.isAlive());
421	>	awaitTermination(t1, LONG_DELAY_MS);
422	>	awaitTermination(t2, LONG_DELAY_MS);
423		}
424
425
#	Line 455 | Line 447 | public class ReentrantReadWriteLockTest
447		lock.writeLock().lock();
448		lock.writeLock().unlock();
449		lock.writeLock().unlock();
450	<	t1.join(MEDIUM_DELAY_MS);
451	<	t2.join(MEDIUM_DELAY_MS);
460	<	assertTrue(!t1.isAlive());
461	<	assertTrue(!t2.isAlive());
450	>	awaitTermination(t1, LONG_DELAY_MS);
451	>	awaitTermination(t2, LONG_DELAY_MS);
452		}
453
454
#	Line 497 | Line 487 | public class ReentrantReadWriteLockTest
487		lock.readLock().lock();
488		lock.readLock().unlock();
489		lock.writeLock().unlock();
490	<	t1.join(MEDIUM_DELAY_MS);
491	<	t2.join(MEDIUM_DELAY_MS);
502	<	assertTrue(!t1.isAlive());
503	<	assertTrue(!t2.isAlive());
490	>	awaitTermination(t1, LONG_DELAY_MS);
491	>	awaitTermination(t2, LONG_DELAY_MS);
492		}
493
494
#	Line 528 | Line 516 | public class ReentrantReadWriteLockTest
516		lock.readLock().lock();
517		lock.readLock().unlock();
518		lock.writeLock().unlock();
519	<	t1.join(MEDIUM_DELAY_MS);
520	<	t2.join(MEDIUM_DELAY_MS);
533	<	assertTrue(!t1.isAlive());
534	<	assertTrue(!t2.isAlive());
519	>	awaitTermination(t1, LONG_DELAY_MS);
520	>	awaitTermination(t2, LONG_DELAY_MS);
521		}
522
523
#	Line 562 | Line 548 | public class ReentrantReadWriteLockTest
548		lock.writeLock().lock();
549		lock.writeLock().unlock();
550		lock.writeLock().unlock();
551	<	t1.join(MEDIUM_DELAY_MS);
552	<	t2.join(MEDIUM_DELAY_MS);
567	<	assertTrue(!t1.isAlive());
568	<	assertTrue(!t2.isAlive());
551	>	awaitTermination(t1, LONG_DELAY_MS);
552	>	awaitTermination(t2, LONG_DELAY_MS);
553		}
554
555
#	Line 581 | Line 565 | public class ReentrantReadWriteLockTest
565		lock.readLock().unlock();
566		}});
567
568	<	t.join();
568	>	awaitTermination(t, LONG_DELAY_MS);
569		lock.readLock().unlock();
570		}
571
#	Line 596 | Line 580 | public class ReentrantReadWriteLockTest
580		assertFalse(lock.writeLock().tryLock());
581		}});
582
583	<	t.join();
583	>	awaitTermination(t, LONG_DELAY_MS);
584		lock.readLock().unlock();
585		}
586
#	Line 613 | Line 597 | public class ReentrantReadWriteLockTest
597		lock.readLock().unlock();
598		}});
599
600	<	t.join();
600	>	awaitTermination(t, LONG_DELAY_MS);
601		lock.readLock().unlock();
602		}
603
#	Line 630 | Line 614 | public class ReentrantReadWriteLockTest
614		assertFalse(lock.writeLock().tryLock());
615		}});
616
617	<	t.join();
617	>	awaitTermination(t, LONG_DELAY_MS);
618		lock.readLock().unlock();
619		}
620
#	Line 647 | Line 631 | public class ReentrantReadWriteLockTest
631		assertFalse(lock.writeLock().tryLock(1, MILLISECONDS));
632		}});
633
634	<	t.join();
634	>	awaitTermination(t, LONG_DELAY_MS);
635		assertTrue(lock.writeLock().isHeldByCurrentThread());
636		lock.writeLock().unlock();
637		}
#	Line 663 | Line 647 | public class ReentrantReadWriteLockTest
647		assertFalse(lock.readLock().tryLock(1, MILLISECONDS));
648		}});
649
650	<	t.join();
650	>	awaitTermination(t, LONG_DELAY_MS);
651		assertTrue(lock.writeLock().isHeldByCurrentThread());
652		lock.writeLock().unlock();
653		}
#	Line 682 | Line 666 | public class ReentrantReadWriteLockTest
666
667		Thread.sleep(SHORT_DELAY_MS);
668		t.interrupt();
669	<	t.join();
669	>	awaitTermination(t, LONG_DELAY_MS);
670		releaseLock(lock.writeLock());
671		}
672
#	Line 699 | Line 683 | public class ReentrantReadWriteLockTest
683
684		Thread.sleep(SHORT_DELAY_MS);
685		t.interrupt();
686	<	t.join();
686	>	awaitTermination(t, LONG_DELAY_MS);
687		releaseLock(lock.writeLock());
688		}
689
#	Line 781 | Line 765 | public class ReentrantReadWriteLockTest
765		lock.writeLock().lock();
766		c.signal();
767		lock.writeLock().unlock();
768	<	t.join(SHORT_DELAY_MS);
785	<	assertFalse(t.isAlive());
768	>	awaitTermination(t, LONG_DELAY_MS);
769		}
770
771		/** A helper class for uninterruptible wait tests */
#	Line 835 | Line 818 | public class ReentrantReadWriteLockTest
818		lock.writeLock().unlock();
819		}
820
821	<	thread.join();
821	>	awaitTermination(thread, LONG_DELAY_MS);
822		assertTrue(thread.interrupted);
840	–	assertFalse(thread.isAlive());
823		}
824
825		/**
#	Line 937 | Line 919 | public class ReentrantReadWriteLockTest
919		lock.writeLock().lock();
920		c.signalAll();
921		lock.writeLock().unlock();
922	<	t1.join(SHORT_DELAY_MS);
923	<	t2.join(SHORT_DELAY_MS);
942	<	assertFalse(t1.isAlive());
943	<	assertFalse(t2.isAlive());
922	>	awaitTermination(t1, LONG_DELAY_MS);
923	>	awaitTermination(t2, LONG_DELAY_MS);
924		}
925
926		/**
#	Line 984 | Line 964 | public class ReentrantReadWriteLockTest
964		lock.writeLock().unlock();
965		Thread.sleep(SHORT_DELAY_MS);
966		assertFalse(lock.hasQueuedThreads());
967	<	t1.join();
968	<	t2.join();
967	>	awaitTermination(t1, LONG_DELAY_MS);
968	>	awaitTermination(t2, LONG_DELAY_MS);
969		}
970
971		/**
#	Line 1025 | Line 1005 | public class ReentrantReadWriteLockTest
1005		assertFalse(sync.hasQueuedThread(t1));
1006		Thread.sleep(SHORT_DELAY_MS);
1007		assertFalse(sync.hasQueuedThread(t2));
1008	<	t1.join();
1009	<	t2.join();
1008	>	awaitTermination(t1, LONG_DELAY_MS);
1009	>	awaitTermination(t2, LONG_DELAY_MS);
1010		}
1011
1012
#	Line 1051 | Line 1031 | public class ReentrantReadWriteLockTest
1031		lock.writeLock().unlock();
1032		Thread.sleep(SHORT_DELAY_MS);
1033		assertEquals(0, lock.getQueueLength());
1034	<	t1.join();
1035	<	t2.join();
1034	>	awaitTermination(t1, LONG_DELAY_MS);
1035	>	awaitTermination(t2, LONG_DELAY_MS);
1036		}
1037
1038		/**
#	Line 1079 | Line 1059 | public class ReentrantReadWriteLockTest
1059		lock.writeLock().unlock();
1060		Thread.sleep(SHORT_DELAY_MS);
1061		assertTrue(lock.getQueuedThreads().isEmpty());
1062	<	t1.join();
1063	<	t2.join();
1062	>	awaitTermination(t1, LONG_DELAY_MS);
1063	>	awaitTermination(t2, LONG_DELAY_MS);
1064		}
1065
1066		/**
#	Line 1221 | Line 1201 | public class ReentrantReadWriteLockTest
1201		assertFalse(lock.hasWaiters(c));
1202		assertEquals(0, lock.getWaitQueueLength(c));
1203		lock.writeLock().unlock();
1204	<	t.join(SHORT_DELAY_MS);
1225	<	assertFalse(t.isAlive());
1204	>	awaitTermination(t, LONG_DELAY_MS);
1205		}
1206
1207		/**
#	Line 1251 | Line 1230 | public class ReentrantReadWriteLockTest
1230		assertFalse(lock.hasWaiters(c));
1231		assertEquals(0, lock.getWaitQueueLength(c));
1232		lock.writeLock().unlock();
1233	<	t.join(SHORT_DELAY_MS);
1255	<	assertFalse(t.isAlive());
1233	>	awaitTermination(t, LONG_DELAY_MS);
1234		}
1235
1236
#	Line 1296 | Line 1274 | public class ReentrantReadWriteLockTest
1274		assertFalse(lock.hasWaiters(c));
1275		assertTrue(lock.getWaitingThreads(c).isEmpty());
1276		lock.writeLock().unlock();
1277	<	t1.join(SHORT_DELAY_MS);
1278	<	t2.join(SHORT_DELAY_MS);
1301	<	assertFalse(t1.isAlive());
1302	<	assertFalse(t2.isAlive());
1277	>	awaitTermination(t1, LONG_DELAY_MS);
1278	>	awaitTermination(t2, LONG_DELAY_MS);
1279		}
1280
1281		/**

Diff Legend

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