ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ReentrantLockTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ReentrantLockTest.java (file contents):
Revision 1.26 by jsr166, Mon Nov 2 20:28:31 2009 UTC vs.
Revision 1.27 by jsr166, Mon Nov 16 04:57:10 2009 UTC

# Line 29 | Line 29 | public class ReentrantLockTest extends J
29          public void run() {
30              try {
31                  lock.lockInterruptibly();
32 <            } catch(InterruptedException success){}
32 >            } catch (InterruptedException success){}
33          }
34      }
35  
# Line 45 | Line 45 | public class ReentrantLockTest extends J
45              try {
46                  lock.lockInterruptibly();
47                  threadShouldThrow();
48 <            } catch(InterruptedException success){}
48 >            } catch (InterruptedException success){}
49          }
50      }
51  
# Line 103 | Line 103 | public class ReentrantLockTest extends J
103              rl.unlock();
104              shouldThrow();
105  
106 <        } catch(IllegalMonitorStateException success){}
106 >        } catch (IllegalMonitorStateException success){}
107      }
108  
109      /**
# Line 141 | Line 141 | public class ReentrantLockTest extends J
141              assertFalse(lock.hasQueuedThreads());
142              t1.join();
143              t2.join();
144 <        } catch(Exception e){
144 >        } catch (Exception e){
145              unexpectedException();
146          }
147      }
# Line 170 | Line 170 | public class ReentrantLockTest extends J
170              assertEquals(0, lock.getQueueLength());
171              t1.join();
172              t2.join();
173 <        } catch(Exception e){
173 >        } catch (Exception e){
174              unexpectedException();
175          }
176      }
# Line 199 | Line 199 | public class ReentrantLockTest extends J
199              assertEquals(0, lock.getQueueLength());
200              t1.join();
201              t2.join();
202 <        } catch(Exception e){
202 >        } catch (Exception e){
203              unexpectedException();
204          }
205      }
# Line 245 | Line 245 | public class ReentrantLockTest extends J
245              assertFalse(sync.hasQueuedThread(t2));
246              t1.join();
247              t2.join();
248 <        } catch(Exception e){
248 >        } catch (Exception e){
249              unexpectedException();
250          }
251      }
# Line 278 | Line 278 | public class ReentrantLockTest extends J
278              assertTrue(lock.getQueuedThreads().isEmpty());
279              t1.join();
280              t2.join();
281 <        } catch(Exception e){
281 >        } catch (Exception e){
282              unexpectedException();
283          }
284      }
# Line 295 | Line 295 | public class ReentrantLockTest extends J
295                      try {
296                          lock.tryLock(MEDIUM_DELAY_MS,TimeUnit.MILLISECONDS);
297                          threadShouldThrow();
298 <                    } catch(InterruptedException success){}
298 >                    } catch (InterruptedException success){}
299                  }
300              });
301          try {
302              t.start();
303              t.interrupt();
304 <        } catch(Exception e){
304 >        } catch (Exception e){
305              unexpectedException();
306          }
307      }
# Line 322 | Line 322 | public class ReentrantLockTest extends J
322              t.start();
323              t.join();
324              lock.unlock();
325 <        } catch(Exception e){
325 >        } catch (Exception e){
326              unexpectedException();
327          }
328      }
# Line 346 | Line 346 | public class ReentrantLockTest extends J
346              t.start();
347              t.join();
348              lock.unlock();
349 <        } catch(Exception e){
349 >        } catch (Exception e){
350              unexpectedException();
351          }
352      }
# Line 356 | Line 356 | public class ReentrantLockTest extends J
356       */
357      public void testGetHoldCount() {
358          ReentrantLock lock = new ReentrantLock();
359 <        for(int i = 1; i <= SIZE; i++) {
359 >        for (int i = 1; i <= SIZE; i++) {
360              lock.lock();
361              assertEquals(i,lock.getHoldCount());
362          }
363 <        for(int i = SIZE; i > 0; i--) {
363 >        for (int i = SIZE; i > 0; i--) {
364              lock.unlock();
365              assertEquals(i-1,lock.getHoldCount());
366          }
# Line 382 | Line 382 | public class ReentrantLockTest extends J
382                      try {
383                          Thread.sleep(SMALL_DELAY_MS);
384                      }
385 <                    catch(Exception e) {
385 >                    catch (Exception e) {
386                          threadUnexpectedException();
387                      }
388                      lock.unlock();
# Line 394 | Line 394 | public class ReentrantLockTest extends J
394              assertTrue(lock.isLocked());
395              t.join();
396              assertFalse(lock.isLocked());
397 <        } catch(Exception e){
397 >        } catch (Exception e){
398              unexpectedException();
399          }
400      }
# Line 414 | Line 414 | public class ReentrantLockTest extends J
414              Thread.sleep(SHORT_DELAY_MS);
415              lock.unlock();
416              t.join();
417 <        } catch(Exception e){
417 >        } catch (Exception e){
418              unexpectedException();
419          }
420      }
# Line 426 | Line 426 | public class ReentrantLockTest extends J
426          final ReentrantLock lock = new ReentrantLock();
427          try {
428              lock.lockInterruptibly();
429 <        } catch(Exception e) {
429 >        } catch (Exception e) {
430              unexpectedException();
431          }
432          Thread t = new Thread(new InterruptedLockRunnable(lock));
# Line 436 | Line 436 | public class ReentrantLockTest extends J
436              assertTrue(lock.isLocked());
437              assertTrue(lock.isHeldByCurrentThread());
438              t.join();
439 <        } catch(Exception e){
439 >        } catch (Exception e){
440              unexpectedException();
441          }
442      }
# Line 538 | Line 538 | public class ReentrantLockTest extends J
538                          c.await();
539                          lock.unlock();
540                      }
541 <                    catch(InterruptedException e) {
541 >                    catch (InterruptedException e) {
542                          threadUnexpectedException();
543                      }
544                  }
# Line 714 | Line 714 | public class ReentrantLockTest extends J
714                          c.await();
715                          lock.unlock();
716                      }
717 <                    catch(InterruptedException e) {
717 >                    catch (InterruptedException e) {
718                          threadUnexpectedException();
719                      }
720                  }
# Line 756 | Line 756 | public class ReentrantLockTest extends J
756                          c.await();
757                          lock.unlock();
758                      }
759 <                    catch(InterruptedException e) {
759 >                    catch (InterruptedException e) {
760                          threadUnexpectedException();
761                      }
762                  }
# Line 771 | Line 771 | public class ReentrantLockTest extends J
771                          c.await();
772                          lock.unlock();
773                      }
774 <                    catch(InterruptedException e) {
774 >                    catch (InterruptedException e) {
775                          threadUnexpectedException();
776                      }
777                  }
# Line 816 | Line 816 | public class ReentrantLockTest extends J
816                          c.await();
817                          lock.unlock();
818                      }
819 <                    catch(InterruptedException e) {
819 >                    catch (InterruptedException e) {
820                          threadUnexpectedException();
821                      }
822                  }
# Line 830 | Line 830 | public class ReentrantLockTest extends J
830                          c.await();
831                          lock.unlock();
832                      }
833 <                    catch(InterruptedException e) {
833 >                    catch (InterruptedException e) {
834                          threadUnexpectedException();
835                      }
836                  }
# Line 938 | Line 938 | public class ReentrantLockTest extends J
938                          lock.unlock();
939                          threadShouldThrow();
940                      }
941 <                    catch(InterruptedException success) {
941 >                    catch (InterruptedException success) {
942                      }
943                  }
944              });
# Line 969 | Line 969 | public class ReentrantLockTest extends J
969                          lock.unlock();
970                          threadShouldThrow();
971                      }
972 <                    catch(InterruptedException success) {
972 >                    catch (InterruptedException success) {
973                      }
974                  }
975              });
# Line 1001 | Line 1001 | public class ReentrantLockTest extends J
1001                          lock.unlock();
1002                          threadShouldThrow();
1003                      }
1004 <                    catch(InterruptedException success) {
1004 >                    catch (InterruptedException success) {
1005                      }
1006                  }
1007              });
# Line 1031 | Line 1031 | public class ReentrantLockTest extends J
1031                          c.await();
1032                          lock.unlock();
1033                      }
1034 <                    catch(InterruptedException e) {
1034 >                    catch (InterruptedException e) {
1035                          threadUnexpectedException();
1036                      }
1037                  }
# Line 1044 | Line 1044 | public class ReentrantLockTest extends J
1044                          c.await();
1045                          lock.unlock();
1046                      }
1047 <                    catch(InterruptedException e) {
1047 >                    catch (InterruptedException e) {
1048                          threadUnexpectedException();
1049                      }
1050                  }
# Line 1082 | Line 1082 | public class ReentrantLockTest extends J
1082                          threadAssertEquals(1, lock.getHoldCount());
1083                          lock.unlock();
1084                      }
1085 <                    catch(InterruptedException e) {
1085 >                    catch (InterruptedException e) {
1086                          threadUnexpectedException();
1087                      }
1088                  }
# Line 1099 | Line 1099 | public class ReentrantLockTest extends J
1099                          lock.unlock();
1100                          lock.unlock();
1101                      }
1102 <                    catch(InterruptedException e) {
1102 >                    catch (InterruptedException e) {
1103                          threadUnexpectedException();
1104                      }
1105                  }
# Line 1141 | Line 1141 | public class ReentrantLockTest extends J
1141              ReentrantLock r = (ReentrantLock) in.readObject();
1142              r.lock();
1143              r.unlock();
1144 <        } catch(Exception e){
1144 >        } catch (Exception e){
1145              e.printStackTrace();
1146              unexpectedException();
1147          }

Diff Legend

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