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.29 by jsr166, Mon Nov 16 04:57:10 2009 UTC vs.
Revision 1.30 by jsr166, Mon Nov 16 05:30:08 2009 UTC

#	Line 29 | Line 29 | public class ReentrantReadWriteLockTest
29		public void run() {
30		try {
31		lock.writeLock().lockInterruptibly();
32	<	} catch (InterruptedException success){}
32	>	} catch (InterruptedException success) {}
33		}
34		}
35
#	Line 45 | Line 45 | public class ReentrantReadWriteLockTest
45		try {
46		lock.writeLock().lockInterruptibly();
47		threadShouldThrow();
48	<	} catch (InterruptedException success){}
48	>	} catch (InterruptedException success) {}
49		}
50		}
51
#	Line 181 | Line 181 | public class ReentrantReadWriteLockTest
181		try {
182		rl.writeLock().unlock();
183		shouldThrow();
184	<	} catch (IllegalMonitorStateException success){}
184	>	} catch (IllegalMonitorStateException success) {}
185		}
186
187
#	Line 197 | Line 197 | public class ReentrantReadWriteLockTest
197		lock.writeLock().unlock();
198		lock.writeLock().lockInterruptibly();
199		lock.writeLock().unlock();
200	<	} catch (InterruptedException success){}
200	>	} catch (InterruptedException success) {}
201		}
202		});
203		try {
#	Line 208 | Line 208 | public class ReentrantReadWriteLockTest
208		Thread.sleep(SHORT_DELAY_MS);
209		lock.writeLock().unlock();
210		t.join();
211	<	} catch (Exception e){
211	>	} catch (Exception e) {
212		unexpectedException();
213		}
214		}
#	Line 223 | Line 223 | public class ReentrantReadWriteLockTest
223		public void run() {
224		try {
225		lock.writeLock().tryLock(1000,TimeUnit.MILLISECONDS);
226	<	} catch (InterruptedException success){}
226	>	} catch (InterruptedException success) {}
227		}
228		});
229		try {
#	Line 231 | Line 231 | public class ReentrantReadWriteLockTest
231		t.interrupt();
232		lock.writeLock().unlock();
233		t.join();
234	<	} catch (Exception e){
234	>	} catch (Exception e) {
235		unexpectedException();
236		}
237		}
#	Line 246 | Line 246 | public class ReentrantReadWriteLockTest
246		public void run() {
247		try {
248		lock.readLock().lockInterruptibly();
249	<	} catch (InterruptedException success){}
249	>	} catch (InterruptedException success) {}
250		}
251		});
252		try {
#	Line 256 | Line 256 | public class ReentrantReadWriteLockTest
256		Thread.sleep(SHORT_DELAY_MS);
257		lock.writeLock().unlock();
258		t.join();
259	<	} catch (Exception e){
259	>	} catch (Exception e) {
260		unexpectedException();
261		}
262		}
#	Line 272 | Line 272 | public class ReentrantReadWriteLockTest
272		try {
273		lock.readLock().tryLock(1000,TimeUnit.MILLISECONDS);
274		threadShouldThrow();
275	<	} catch (InterruptedException success){}
275	>	} catch (InterruptedException success) {}
276		}
277		});
278		try {
279		t.start();
280		t.interrupt();
281		t.join();
282	<	} catch (Exception e){
282	>	} catch (Exception e) {
283		unexpectedException();
284		}
285		}
#	Line 300 | Line 300 | public class ReentrantReadWriteLockTest
300		t.start();
301		t.join();
302		lock.writeLock().unlock();
303	<	} catch (Exception e){
303	>	} catch (Exception e) {
304		unexpectedException();
305		}
306		}
#	Line 320 | Line 320 | public class ReentrantReadWriteLockTest
320		t.start();
321		t.join();
322		lock.writeLock().unlock();
323	<	} catch (Exception e){
323	>	} catch (Exception e) {
324		unexpectedException();
325		}
326		}
#	Line 341 | Line 341 | public class ReentrantReadWriteLockTest
341		t.start();
342		t.join();
343		lock.readLock().unlock();
344	<	} catch (Exception e){
344	>	} catch (Exception e) {
345		unexpectedException();
346		}
347		}
#	Line 375 | Line 375 | public class ReentrantReadWriteLockTest
375		assertTrue(!t1.isAlive());
376		assertTrue(!t2.isAlive());
377
378	<	} catch (Exception e){
378	>	} catch (Exception e) {
379		unexpectedException();
380		}
381		}
#	Line 409 | Line 409 | public class ReentrantReadWriteLockTest
409		assertTrue(!t1.isAlive());
410		assertTrue(!t2.isAlive());
411
412	<	} catch (Exception e){
412	>	} catch (Exception e) {
413		unexpectedException();
414		}
415		}
#	Line 459 | Line 459 | public class ReentrantReadWriteLockTest
459		assertTrue(!t1.isAlive());
460		assertTrue(!t2.isAlive());
461
462	<	} catch (Exception e){
462	>	} catch (Exception e) {
463		unexpectedException();
464		}
465		}
#	Line 498 | Line 498 | public class ReentrantReadWriteLockTest
498		assertTrue(!t1.isAlive());
499		assertTrue(!t2.isAlive());
500
501	<	} catch (Exception e){
501	>	} catch (Exception e) {
502		unexpectedException();
503		}
504		}
#	Line 538 | Line 538 | public class ReentrantReadWriteLockTest
538		assertTrue(!t1.isAlive());
539		assertTrue(!t2.isAlive());
540
541	<	} catch (Exception e){
541	>	} catch (Exception e) {
542		unexpectedException();
543		}
544		}
#	Line 589 | Line 589 | public class ReentrantReadWriteLockTest
589		assertTrue(!t1.isAlive());
590		assertTrue(!t2.isAlive());
591
592	<	} catch (Exception e){
592	>	} catch (Exception e) {
593		unexpectedException();
594		}
595		}
#	Line 629 | Line 629 | public class ReentrantReadWriteLockTest
629		assertTrue(!t1.isAlive());
630		assertTrue(!t2.isAlive());
631
632	<	} catch (Exception e){
632	>	} catch (Exception e) {
633		unexpectedException();
634		}
635		}
#	Line 672 | Line 672 | public class ReentrantReadWriteLockTest
672		assertTrue(!t1.isAlive());
673		assertTrue(!t2.isAlive());
674
675	<	} catch (Exception e){
675	>	} catch (Exception e) {
676		unexpectedException();
677		}
678		}
#	Line 694 | Line 694 | public class ReentrantReadWriteLockTest
694		t.start();
695		t.join();
696		lock.readLock().unlock();
697	<	} catch (Exception e){
697	>	} catch (Exception e) {
698		unexpectedException();
699		}
700		}
#	Line 716 | Line 716 | public class ReentrantReadWriteLockTest
716		t.start();
717		t.join();
718		lock.readLock().unlock();
719	<	} catch (Exception e){
719	>	} catch (Exception e) {
720		unexpectedException();
721		}
722		}
#	Line 738 | Line 738 | public class ReentrantReadWriteLockTest
738		t.start();
739		t.join();
740		lock.readLock().unlock();
741	<	} catch (Exception e){
741	>	} catch (Exception e) {
742		unexpectedException();
743		}
744		}
#	Line 760 | Line 760 | public class ReentrantReadWriteLockTest
760		t.start();
761		t.join();
762		lock.readLock().unlock();
763	<	} catch (Exception e){
763	>	} catch (Exception e) {
764		unexpectedException();
765		}
766		}
#	Line 786 | Line 786 | public class ReentrantReadWriteLockTest
786		t.start();
787		t.join();
788		lock.writeLock().unlock();
789	<	} catch (Exception e){
789	>	} catch (Exception e) {
790		unexpectedException();
791		}
792		}
#	Line 810 | Line 810 | public class ReentrantReadWriteLockTest
810		t.start();
811		t.join();
812		lock.writeLock().unlock();
813	<	} catch (Exception e){
813	>	} catch (Exception e) {
814		unexpectedException();
815		}
816		}
#	Line 843 | Line 843 | public class ReentrantReadWriteLockTest
843		Thread.sleep(SHORT_DELAY_MS);
844		t.join();
845		lock.writeLock().unlock();
846	<	} catch (Exception e){
846	>	} catch (Exception e) {
847		unexpectedException();
848		}
849		}
#	Line 874 | Line 874 | public class ReentrantReadWriteLockTest
874		t.interrupt();
875		t.join();
876		lock.writeLock().unlock();
877	<	} catch (Exception e){
877	>	} catch (Exception e) {
878		unexpectedException();
879		}
880		}
#	Line 1216 | Line 1216 | public class ReentrantReadWriteLockTest
1216		ReentrantReadWriteLock r = (ReentrantReadWriteLock) in.readObject();
1217		r.readLock().lock();
1218		r.readLock().unlock();
1219	<	} catch (Exception e){
1219	>	} catch (Exception e) {
1220		e.printStackTrace();
1221		unexpectedException();
1222		}
#	Line 1246 | Line 1246 | public class ReentrantReadWriteLockTest
1246		assertFalse(lock.hasQueuedThreads());
1247		t1.join();
1248		t2.join();
1249	<	} catch (Exception e){
1249	>	} catch (Exception e) {
1250		unexpectedException();
1251		}
1252		}
#	Line 1292 | Line 1292 | public class ReentrantReadWriteLockTest
1292		assertFalse(sync.hasQueuedThread(t2));
1293		t1.join();
1294		t2.join();
1295	<	} catch (Exception e){
1295	>	} catch (Exception e) {
1296		unexpectedException();
1297		}
1298		}
#	Line 1322 | Line 1322 | public class ReentrantReadWriteLockTest
1322		assertEquals(0, lock.getQueueLength());
1323		t1.join();
1324		t2.join();
1325	<	} catch (Exception e){
1325	>	} catch (Exception e) {
1326		unexpectedException();
1327		}
1328		}
#	Line 1354 | Line 1354 | public class ReentrantReadWriteLockTest
1354		assertTrue(lock.getQueuedThreads().isEmpty());
1355		t1.join();
1356		t2.join();
1357	<	} catch (Exception e){
1357	>	} catch (Exception e) {
1358		unexpectedException();
1359		}
1360		}

Diff Legend

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