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

Comparing jsr166/src/test/tck/ReentrantReadWriteLockTest.java (file contents):
Revision 1.66 by jsr166, Fri Jun 3 05:07:14 2011 UTC vs.
Revision 1.72 by jsr166, Fri Feb 27 22:06:24 2015 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 < import junit.framework.*;
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.atomic.AtomicBoolean;
16   import java.util.concurrent.locks.Condition;
17   import java.util.concurrent.locks.Lock;
18   import java.util.concurrent.locks.ReentrantReadWriteLock;
19 < import java.util.concurrent.CountDownLatch;
20 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
21 < import java.util.*;
19 >
20 > import junit.framework.AssertionFailedError;
21 > import junit.framework.Test;
22 > import junit.framework.TestSuite;
23  
24   public class ReentrantReadWriteLockTest extends JSR166TestCase {
25      public static void main(String[] args) {
# Line 85 | Line 91 | public class ReentrantReadWriteLockTest
91              Thread.yield();
92          }
93          assertTrue(t.isAlive());
94 <        assertTrue(lock.getOwner() != t);
94 >        assertNotSame(t, lock.getOwner());
95      }
96  
97      /**
# Line 146 | Line 152 | public class ReentrantReadWriteLockTest
152          lock.writeLock().unlock();
153      }
154  
155 <    enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil };
155 >    enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil }
156  
157      /**
158       * Awaits condition using the specified AwaitMethod.
# Line 168 | Line 174 | public class ReentrantReadWriteLockTest
174              java.util.Date d = new java.util.Date();
175              assertTrue(c.awaitUntil(new java.util.Date(d.getTime() + 2 * LONG_DELAY_MS)));
176              break;
177 +        default:
178 +            throw new AssertionError();
179          }
180      }
181  
# Line 822 | Line 830 | public class ReentrantReadWriteLockTest
830              new PublicReentrantReadWriteLock(fair);
831          try {
832              lock.writeLock().lockInterruptibly();
833 <        } catch (InterruptedException ie) {
826 <            threadUnexpectedException(ie);
827 <        }
833 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
834          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
835              public void realRun() throws InterruptedException {
836                  lock.writeLock().lockInterruptibly();
# Line 849 | Line 855 | public class ReentrantReadWriteLockTest
855              lock.readLock().lockInterruptibly();
856              lock.readLock().unlock();
857              lock.writeLock().lockInterruptibly();
858 <        } catch (InterruptedException ie) {
853 <            threadUnexpectedException(ie);
854 <        }
858 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
859          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
860              public void realRun() throws InterruptedException {
861                  lock.readLock().lockInterruptibly();
# Line 877 | Line 881 | public class ReentrantReadWriteLockTest
881                  await(c, awaitMethod);
882                  shouldThrow();
883              } catch (IllegalMonitorStateException success) {
884 <            } catch (InterruptedException e) { threadUnexpectedException(e); }
884 >            } catch (InterruptedException fail) {
885 >                threadUnexpectedException(fail);
886 >            }
887              assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
888          }
889      }
# Line 928 | Line 934 | public class ReentrantReadWriteLockTest
934              assertTrue(nanosRemaining <= 0);
935              assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
936              lock.writeLock().unlock();
937 <        } catch (InterruptedException e) {
932 <            threadUnexpectedException(e);
933 <        }
937 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
938      }
939  
940      /**
# Line 949 | Line 953 | public class ReentrantReadWriteLockTest
953              assertFalse(c.await(timeoutMillis, MILLISECONDS));
954              assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
955              lock.writeLock().unlock();
956 <        } catch (InterruptedException e) {
953 <            threadUnexpectedException(e);
954 <        }
956 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
957      }
958  
959      /**
# Line 971 | Line 973 | public class ReentrantReadWriteLockTest
973              assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + timeoutMillis)));
974              assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
975              lock.writeLock().unlock();
976 <        } catch (InterruptedException e) {
975 <            threadUnexpectedException(e);
976 <        }
976 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
977      }
978  
979      /**

Diff Legend

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