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

Comparing jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java (file contents):
Revision 1.6 by dl, Wed Dec 31 21:30:08 2003 UTC vs.
Revision 1.11 by dl, Thu Jan 8 01:29:46 2004 UTC

# Line 32 | Line 32 | public class AbstractQueuedSynchronizerT
32          private static class Sync extends AbstractQueuedSynchronizer {
33              boolean isLocked() { return getState() == 1; }
34  
35 <            public boolean tryAcquireExclusiveState(boolean isQueued, int acquires) {
35 >            public boolean tryAcquireExclusive(int acquires) {
36                  assert acquires == 1; // Does not use multiple acquires
37                  return compareAndSetState(0, 1);
38              }
39              
40 <            public boolean releaseExclusiveState(int releases) {
40 >            public boolean tryReleaseExclusive(int releases) {
41                  setState(0);
42                  return true;
43              }
44              
45 <            public void checkConditionAccess(Thread thread, boolean waiting) {
45 >            public void checkConditionAccess(Thread thread) {
46                  if (getState() == 0) throw new IllegalMonitorStateException();
47              }
48              
# Line 52 | Line 52 | public class AbstractQueuedSynchronizerT
52                  s.defaultReadObject();
53                  setState(0); // reset to unlocked state
54              }
55 +
56          }
57 <        
57 >        
58          private final Sync sync = new Sync();
59          public boolean tryLock() {
60 <            return sync.tryAcquireExclusiveState(false, 1);
60 >            return sync.tryAcquireExclusive(1);
61          }
62          public void lock() {
63              sync.acquireExclusiveUninterruptibly(1);
# Line 71 | Line 72 | public class AbstractQueuedSynchronizerT
72          public Condition newCondition() { return sync.newCondition(); }
73          public boolean isLocked() { return sync.isLocked(); }
74          public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
75 +        public boolean hasContended() { return sync.hasContended(); }
76 +        public boolean isQueued(Thread t) { return sync.isQueued(t); }
77      }
78  
79      /**
# Line 147 | Line 150 | public class AbstractQueuedSynchronizerT
150              t1.join();
151              t2.join();
152          } catch(Exception e){
153 +            unexpectedException();
154 +        }
155 +    }
156 +
157 +    /**
158 +     * isQueued(null) throws NPE
159 +     */
160 +    public void testIsQueuedNPE() {
161 +        final Mutex lock = new Mutex();
162 +        try {
163 +            lock.isQueued(null);
164 +            shouldThrow();
165 +        } catch (NullPointerException success) {
166 +        }
167 +    }
168 +
169 +    /**
170 +     * isQueued reports whether a thread is queued.
171 +     */
172 +    public void testIsQueued() {
173 +        final Mutex lock = new Mutex();
174 +        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
175 +        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
176 +        try {
177 +            assertFalse(lock.isQueued(t1));
178 +            assertFalse(lock.isQueued(t2));
179 +            lock.lock();
180 +            t1.start();
181 +            Thread.sleep(SHORT_DELAY_MS);
182 +            assertTrue(lock.isQueued(t1));
183 +            t2.start();
184 +            Thread.sleep(SHORT_DELAY_MS);
185 +            assertTrue(lock.isQueued(t1));
186 +            assertTrue(lock.isQueued(t2));
187 +            t1.interrupt();
188 +            Thread.sleep(SHORT_DELAY_MS);
189 +            assertFalse(lock.isQueued(t1));
190 +            assertTrue(lock.isQueued(t2));
191 +            lock.unlock();
192 +            Thread.sleep(SHORT_DELAY_MS);
193 +            assertFalse(lock.isQueued(t1));
194 +            assertFalse(lock.isQueued(t2));
195 +            t1.join();
196 +            t2.join();
197 +        } catch(Exception e){
198 +            unexpectedException();
199 +        }
200 +    }
201 +
202 +
203 +    /**
204 +     * hasContended reports whether there has been contention
205 +     */
206 +    public void testhasContended() {
207 +        final Mutex lock = new Mutex();
208 +        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
209 +        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
210 +        try {
211 +            assertFalse(lock.hasContended());
212 +            lock.lock();
213 +            t1.start();
214 +            Thread.sleep(SHORT_DELAY_MS);
215 +            assertTrue(lock.hasContended());
216 +            t2.start();
217 +            Thread.sleep(SHORT_DELAY_MS);
218 +            assertTrue(lock.hasContended());
219 +            t1.interrupt();
220 +            Thread.sleep(SHORT_DELAY_MS);
221 +            assertTrue(lock.hasContended());
222 +            lock.unlock();
223 +            Thread.sleep(SHORT_DELAY_MS);
224 +            assertTrue(lock.hasContended());
225 +            t1.join();
226 +            t2.join();
227 +        } catch(Exception e){
228              unexpectedException();
229          }
230      }

Diff Legend

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