test/tck/AbstractQueuedSynchronizerTest.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/licenses/publicdomain
 * Other contributors include Andrew Wright, Jeffrey Hayes, 
 * Pat Fisher, Mike Judd. 
 */


import junit.framework.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;
import java.io.*;

public class AbstractQueuedSynchronizerTest extends JSR166TestCase {
    public static void main(String[] args) {
        junit.textui.TestRunner.run (suite());
    }
    public static Test suite() {
        return new TestSuite(AbstractQueuedSynchronizerTest.class);
    }

    /**
     * A simple mutex class, from the AbstractQueuedSynchronizer
     * javadoc.  All tests exercise this as a sample user extension.
     * Other methods/features of AbstractQueuedSynchronizerTest are
     * tested implicitly in ReentrantLock, ReentrantReadWriteLock, and
     * Semaphore test classes
     */
    static class Mutex implements Lock, java.io.Serializable {
        private static class Sync extends AbstractQueuedSynchronizer {
            boolean isLocked() { return getState() == 1; }

            public boolean tryAcquireExclusive(boolean isQueued, int acquires) {
                assert acquires == 1; // Does not use multiple acquires
                return compareAndSetState(0, 1);
            }
            
            public boolean tryReleaseExclusive(int releases) {
                setState(0);
                return true;
            }
            
            public void checkConditionAccess(Thread thread) {
                if (getState() == 0) throw new IllegalMonitorStateException();
            }
            
            Condition newCondition() { return new ConditionObject(); }
            
            private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
                s.defaultReadObject();
                setState(0); // reset to unlocked state
            }

        }
         
        private final Sync sync = new Sync();
        public boolean tryLock() { 
            return sync.tryAcquireExclusive(false, 1);
        }
        public void lock() { 
            sync.acquireExclusiveUninterruptibly(1);
        }
        public void lockInterruptibly() throws InterruptedException { 
            sync.acquireExclusiveInterruptibly(1);
        }
        public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
            return sync.acquireExclusiveTimed(1, unit.toNanos(timeout));
        }
        public void unlock() { sync.releaseExclusive(1); }
        public Condition newCondition() { return sync.newCondition(); }
        public boolean isLocked() { return sync.isLocked(); }
        public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
        public boolean hasContended() { return sync.hasContended(); }
    }

    /**
     * A runnable calling lockInterruptibly
     */
    class InterruptibleLockRunnable implements Runnable {
        final Mutex lock;
        InterruptibleLockRunnable(Mutex l) { lock = l; }
        public void run() {
            try {
                lock.lockInterruptibly();
            } catch(InterruptedException success){}
        }
    }


    /**
     * A runnable calling lockInterruptibly that expects to be
     * interrupted
     */
    class InterruptedLockRunnable implements Runnable {
        final Mutex lock;
        InterruptedLockRunnable(Mutex l) { lock = l; }
        public void run() {
            try {
                lock.lockInterruptibly();
                threadShouldThrow();
            } catch(InterruptedException success){}
        }
    }
    
    /**
     * locking an unlocked lock succeeds
     */
    public void testLock() { 
        Mutex rl = new Mutex();
        rl.lock();
        assertTrue(rl.isLocked());
        rl.unlock();
    }

    /**
     * tryLock on an unlocked lock succeeds
     */
    public void testTryLock() { 
        Mutex rl = new Mutex();
        assertTrue(rl.tryLock());
        assertTrue(rl.isLocked());
        rl.unlock();
    }

    /**
     * hasQueuedThreads reports whether there are waiting threads
     */
    public void testhasQueuedThreads() { 
        final Mutex lock = new Mutex();
        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
        try {
            assertFalse(lock.hasQueuedThreads());
            lock.lock();
            t1.start();
            Thread.sleep(SHORT_DELAY_MS);
            assertTrue(lock.hasQueuedThreads());
            t2.start();
            Thread.sleep(SHORT_DELAY_MS);
            assertTrue(lock.hasQueuedThreads());
            t1.interrupt();
            Thread.sleep(SHORT_DELAY_MS);
            assertTrue(lock.hasQueuedThreads());
            lock.unlock();
            Thread.sleep(SHORT_DELAY_MS);
            assertFalse(lock.hasQueuedThreads());
            t1.join();
            t2.join();
        } catch(Exception e){
            unexpectedException();
        }
    } 


    /**
     * hasContended reports whether there has been contention
     */
    public void testhasContended() { 
        final Mutex lock = new Mutex();
        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
        try {
            assertFalse(lock.hasContended());
            lock.lock();
            t1.start();
            Thread.sleep(SHORT_DELAY_MS);
            assertTrue(lock.hasContended());
            t2.start();
            Thread.sleep(SHORT_DELAY_MS);
            assertTrue(lock.hasContended());
            t1.interrupt();
            Thread.sleep(SHORT_DELAY_MS);
            assertTrue(lock.hasContended());
            lock.unlock();
            Thread.sleep(SHORT_DELAY_MS);
            assertTrue(lock.hasContended());
            t1.join();
            t2.join();
        } catch(Exception e){
            unexpectedException();
        }
    } 

    /**
     * timed tryLock is interruptible.
     */
    public void testInterruptedException2() { 
        final Mutex lock = new Mutex();
        lock.lock();
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        lock.tryLock(MEDIUM_DELAY_MS,TimeUnit.MILLISECONDS);
                        threadShouldThrow();
                    } catch(InterruptedException success){}
                }
            });
        try {
            t.start();
            t.interrupt();
        } catch(Exception e){
            unexpectedException();
        }
    }


    /**
     * TryLock on a locked lock fails
     */
    public void testTryLockWhenLocked() { 
        final Mutex lock = new Mutex();
        lock.lock();
        Thread t = new Thread(new Runnable() {
                public void run() {
                    threadAssertFalse(lock.tryLock());
                }
            });
        try {
            t.start();
            t.join();
            lock.unlock();
        } catch(Exception e){
            unexpectedException();
        }
    } 

    /**
     * Timed tryLock on a locked lock times out
     */
    public void testTryLock_Timeout() { 
        final Mutex lock = new Mutex();
        lock.lock();
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        threadAssertFalse(lock.tryLock(1, TimeUnit.MILLISECONDS));
                    } catch (Exception ex) {
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t.start();
            t.join();
            lock.unlock();
        } catch(Exception e){
            unexpectedException();
        }
    } 
    
   
    /**
     * isLocked is true when locked and false when not
     */
    public void testIsLocked() {
        final Mutex lock = new Mutex();
        lock.lock();
        assertTrue(lock.isLocked());
        lock.unlock();
        assertFalse(lock.isLocked());
        Thread t = new Thread(new Runnable() { 
                public void run() {
                    lock.lock();
                    try {
                        Thread.sleep(SMALL_DELAY_MS);
                    }
                    catch(Exception e) {
                        threadUnexpectedException();
                    }
                    lock.unlock();
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            assertTrue(lock.isLocked());
            t.join();
            assertFalse(lock.isLocked());
        } catch(Exception e){
            unexpectedException();
        }
    }


    /**
     * lockInterruptibly is interruptible.
     */
    public void testLockInterruptibly1() { 
        final Mutex lock = new Mutex();
        lock.lock();
        Thread t = new Thread(new InterruptedLockRunnable(lock));
        try {
            t.start();
            t.interrupt();
            lock.unlock();
            t.join();
        } catch(Exception e){
            unexpectedException();
        }
    } 

    /**
     * lockInterruptibly succeeds when unlocked, else is interruptible
     */
    public void testLockInterruptibly2() {
        final Mutex lock = new Mutex(); 
        try {
            lock.lockInterruptibly();
        } catch(Exception e) {
            unexpectedException();
        }
        Thread t = new Thread(new InterruptedLockRunnable(lock));
        try {
            t.start();
            t.interrupt();
            assertTrue(lock.isLocked());
            t.join();
        } catch(Exception e){
            unexpectedException();
        }
    }

    /**
     * Calling await without holding lock throws IllegalMonitorStateException
     */
    public void testAwait_IllegalMonitor() {
        final Mutex lock = new Mutex(); 
        final Condition c = lock.newCondition();
        try {
            c.await();
            shouldThrow();
        }
        catch (IllegalMonitorStateException success) {
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * Calling signal without holding lock throws IllegalMonitorStateException
     */
    public void testSignal_IllegalMonitor() {
        final Mutex lock = new Mutex(); 
        final Condition c = lock.newCondition();
        try {
            c.signal();
            shouldThrow();
        }
        catch (IllegalMonitorStateException success) {
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * awaitNanos without a signal times out
     */
    public void testAwaitNanos_Timeout() {
        final Mutex lock = new Mutex(); 
        final Condition c = lock.newCondition();
        try {
            lock.lock();
            long t = c.awaitNanos(100);
            assertTrue(t <= 0);
            lock.unlock();
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     *  timed await without a signal times out
     */
    public void testAwait_Timeout() {
        final Mutex lock = new Mutex(); 
        final Condition c = lock.newCondition();
        try {
            lock.lock();
            assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            lock.unlock();
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * awaitUntil without a signal times out
     */
    public void testAwaitUntil_Timeout() {
        final Mutex lock = new Mutex(); 
        final Condition c = lock.newCondition();
        try {
            lock.lock();
            java.util.Date d = new java.util.Date();
            assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
            lock.unlock();
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * await returns when signalled
     */
    public void testAwait() {
        final Mutex lock = new Mutex(); 
        final Condition c = lock.newCondition();
        Thread t = new Thread(new Runnable() { 
                public void run() {
                    try {
                        lock.lock();
                        c.await();
                        lock.unlock();
                    }
                    catch(InterruptedException e) {
                        threadUnexpectedException();
                    }
                }
            });

        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            lock.lock();
            c.signal();
            lock.unlock();
            t.join(SHORT_DELAY_MS);
            assertFalse(t.isAlive());
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }
    
}
Revision:	1.8
Committed:	Sun Jan 4 00:57:21 2004 UTC (20 years, 4 months ago) by dl
Branch:	MAIN
Changes since 1.7:	+33 -1 lines
Log Message:	added a few tests
#	User	Rev	Content
1	dl	1.1	/*
2			* Written by Doug Lea with assistance from members of JCP JSR-166
3			* Expert Group and released to the public domain, as explained at
4			* http://creativecommons.org/licenses/publicdomain
5			* Other contributors include Andrew Wright, Jeffrey Hayes,
6			* Pat Fisher, Mike Judd.
7			*/
8
9
10			import junit.framework.*;
11			import java.util.*;
12			import java.util.concurrent.*;
13			import java.util.concurrent.locks.*;
14			import java.io.*;
15
16			public class AbstractQueuedSynchronizerTest extends JSR166TestCase {
17			public static void main(String[] args) {
18			junit.textui.TestRunner.run (suite());
19			}
20			public static Test suite() {
21			return new TestSuite(AbstractQueuedSynchronizerTest.class);
22			}
23
24			/**
25			* A simple mutex class, from the AbstractQueuedSynchronizer
26			* javadoc. All tests exercise this as a sample user extension.
27			* Other methods/features of AbstractQueuedSynchronizerTest are
28			* tested implicitly in ReentrantLock, ReentrantReadWriteLock, and
29			* Semaphore test classes
30			*/
31			static class Mutex implements Lock, java.io.Serializable {
32			private static class Sync extends AbstractQueuedSynchronizer {
33	dl	1.6	boolean isLocked() { return getState() == 1; }
34
35	dl	1.7	public boolean tryAcquireExclusive(boolean isQueued, int acquires) {
36	dl	1.1	assert acquires == 1; // Does not use multiple acquires
37	dl	1.6	return compareAndSetState(0, 1);
38	dl	1.1	}
39
40	dl	1.7	public boolean tryReleaseExclusive(int releases) {
41	dl	1.6	setState(0);
42	dl	1.1	return true;
43			}
44
45	dl	1.8	public void checkConditionAccess(Thread thread) {
46	dl	1.6	if (getState() == 0) throw new IllegalMonitorStateException();
47	dl	1.1	}
48
49			Condition newCondition() { return new ConditionObject(); }
50
51			private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
52			s.defaultReadObject();
53	dl	1.6	setState(0); // reset to unlocked state
54	dl	1.1	}
55	dl	1.8
56	dl	1.1	}
57	dl	1.7
58	dl	1.1	private final Sync sync = new Sync();
59			public boolean tryLock() {
60	dl	1.7	return sync.tryAcquireExclusive(false, 1);
61	dl	1.2	}
62			public void lock() {
63	dl	1.3	sync.acquireExclusiveUninterruptibly(1);
64	dl	1.1	}
65			public void lockInterruptibly() throws InterruptedException {
66			sync.acquireExclusiveInterruptibly(1);
67			}
68			public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
69			return sync.acquireExclusiveTimed(1, unit.toNanos(timeout));
70			}
71			public void unlock() { sync.releaseExclusive(1); }
72			public Condition newCondition() { return sync.newCondition(); }
73	dl	1.6	public boolean isLocked() { return sync.isLocked(); }
74	dl	1.1	public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
75	dl	1.8	public boolean hasContended() { return sync.hasContended(); }
76	dl	1.1	}
77
78			/**
79			* A runnable calling lockInterruptibly
80			*/
81			class InterruptibleLockRunnable implements Runnable {
82			final Mutex lock;
83			InterruptibleLockRunnable(Mutex l) { lock = l; }
84			public void run() {
85			try {
86			lock.lockInterruptibly();
87			} catch(InterruptedException success){}
88			}
89			}
90
91
92			/**
93			* A runnable calling lockInterruptibly that expects to be
94			* interrupted
95			*/
96			class InterruptedLockRunnable implements Runnable {
97			final Mutex lock;
98			InterruptedLockRunnable(Mutex l) { lock = l; }
99			public void run() {
100			try {
101			lock.lockInterruptibly();
102			threadShouldThrow();
103			} catch(InterruptedException success){}
104			}
105			}
106
107			/**
108			* locking an unlocked lock succeeds
109			*/
110			public void testLock() {
111			Mutex rl = new Mutex();
112			rl.lock();
113			assertTrue(rl.isLocked());
114			rl.unlock();
115			}
116
117			/**
118	dl	1.4	* tryLock on an unlocked lock succeeds
119	dl	1.1	*/
120			public void testTryLock() {
121			Mutex rl = new Mutex();
122			assertTrue(rl.tryLock());
123			assertTrue(rl.isLocked());
124			rl.unlock();
125			}
126
127			/**
128			* hasQueuedThreads reports whether there are waiting threads
129			*/
130			public void testhasQueuedThreads() {
131			final Mutex lock = new Mutex();
132			Thread t1 = new Thread(new InterruptedLockRunnable(lock));
133			Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
134			try {
135			assertFalse(lock.hasQueuedThreads());
136			lock.lock();
137			t1.start();
138			Thread.sleep(SHORT_DELAY_MS);
139			assertTrue(lock.hasQueuedThreads());
140			t2.start();
141			Thread.sleep(SHORT_DELAY_MS);
142			assertTrue(lock.hasQueuedThreads());
143			t1.interrupt();
144			Thread.sleep(SHORT_DELAY_MS);
145			assertTrue(lock.hasQueuedThreads());
146			lock.unlock();
147			Thread.sleep(SHORT_DELAY_MS);
148			assertFalse(lock.hasQueuedThreads());
149	dl	1.8	t1.join();
150			t2.join();
151			} catch(Exception e){
152			unexpectedException();
153			}
154			}
155
156
157			/**
158			* hasContended reports whether there has been contention
159			*/
160			public void testhasContended() {
161			final Mutex lock = new Mutex();
162			Thread t1 = new Thread(new InterruptedLockRunnable(lock));
163			Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
164			try {
165			assertFalse(lock.hasContended());
166			lock.lock();
167			t1.start();
168			Thread.sleep(SHORT_DELAY_MS);
169			assertTrue(lock.hasContended());
170			t2.start();
171			Thread.sleep(SHORT_DELAY_MS);
172			assertTrue(lock.hasContended());
173			t1.interrupt();
174			Thread.sleep(SHORT_DELAY_MS);
175			assertTrue(lock.hasContended());
176			lock.unlock();
177			Thread.sleep(SHORT_DELAY_MS);
178			assertTrue(lock.hasContended());
179	dl	1.1	t1.join();
180			t2.join();
181			} catch(Exception e){
182			unexpectedException();
183			}
184			}
185
186			/**
187	dl	1.4	* timed tryLock is interruptible.
188	dl	1.1	*/
189			public void testInterruptedException2() {
190			final Mutex lock = new Mutex();
191			lock.lock();
192			Thread t = new Thread(new Runnable() {
193			public void run() {
194			try {
195			lock.tryLock(MEDIUM_DELAY_MS,TimeUnit.MILLISECONDS);
196			threadShouldThrow();
197			} catch(InterruptedException success){}
198			}
199			});
200			try {
201			t.start();
202			t.interrupt();
203			} catch(Exception e){
204			unexpectedException();
205			}
206			}
207
208
209			/**
210	dl	1.4	* TryLock on a locked lock fails
211	dl	1.1	*/
212			public void testTryLockWhenLocked() {
213			final Mutex lock = new Mutex();
214			lock.lock();
215			Thread t = new Thread(new Runnable() {
216			public void run() {
217			threadAssertFalse(lock.tryLock());
218			}
219			});
220			try {
221			t.start();
222			t.join();
223			lock.unlock();
224			} catch(Exception e){
225			unexpectedException();
226			}
227			}
228
229			/**
230	dl	1.4	* Timed tryLock on a locked lock times out
231	dl	1.1	*/
232			public void testTryLock_Timeout() {
233			final Mutex lock = new Mutex();
234			lock.lock();
235			Thread t = new Thread(new Runnable() {
236			public void run() {
237			try {
238			threadAssertFalse(lock.tryLock(1, TimeUnit.MILLISECONDS));
239			} catch (Exception ex) {
240			threadUnexpectedException();
241			}
242			}
243			});
244			try {
245			t.start();
246			t.join();
247			lock.unlock();
248			} catch(Exception e){
249			unexpectedException();
250			}
251			}
252
253
254			/**
255			* isLocked is true when locked and false when not
256			*/
257			public void testIsLocked() {
258			final Mutex lock = new Mutex();
259			lock.lock();
260			assertTrue(lock.isLocked());
261			lock.unlock();
262			assertFalse(lock.isLocked());
263			Thread t = new Thread(new Runnable() {
264			public void run() {
265			lock.lock();
266			try {
267			Thread.sleep(SMALL_DELAY_MS);
268			}
269			catch(Exception e) {
270			threadUnexpectedException();
271			}
272			lock.unlock();
273			}
274			});
275			try {
276			t.start();
277			Thread.sleep(SHORT_DELAY_MS);
278			assertTrue(lock.isLocked());
279			t.join();
280			assertFalse(lock.isLocked());
281			} catch(Exception e){
282			unexpectedException();
283			}
284			}
285
286
287			/**
288			* lockInterruptibly is interruptible.
289			*/
290			public void testLockInterruptibly1() {
291			final Mutex lock = new Mutex();
292			lock.lock();
293			Thread t = new Thread(new InterruptedLockRunnable(lock));
294			try {
295			t.start();
296			t.interrupt();
297			lock.unlock();
298			t.join();
299			} catch(Exception e){
300			unexpectedException();
301			}
302			}
303
304			/**
305			* lockInterruptibly succeeds when unlocked, else is interruptible
306			*/
307			public void testLockInterruptibly2() {
308			final Mutex lock = new Mutex();
309			try {
310			lock.lockInterruptibly();
311			} catch(Exception e) {
312			unexpectedException();
313			}
314			Thread t = new Thread(new InterruptedLockRunnable(lock));
315			try {
316			t.start();
317			t.interrupt();
318			assertTrue(lock.isLocked());
319			t.join();
320			} catch(Exception e){
321			unexpectedException();
322			}
323			}
324
325			/**
326			* Calling await without holding lock throws IllegalMonitorStateException
327			*/
328			public void testAwait_IllegalMonitor() {
329			final Mutex lock = new Mutex();
330			final Condition c = lock.newCondition();
331			try {
332			c.await();
333			shouldThrow();
334			}
335			catch (IllegalMonitorStateException success) {
336			}
337			catch (Exception ex) {
338			unexpectedException();
339			}
340			}
341
342			/**
343			* Calling signal without holding lock throws IllegalMonitorStateException
344			*/
345			public void testSignal_IllegalMonitor() {
346			final Mutex lock = new Mutex();
347			final Condition c = lock.newCondition();
348			try {
349			c.signal();
350			shouldThrow();
351			}
352			catch (IllegalMonitorStateException success) {
353			}
354			catch (Exception ex) {
355			unexpectedException();
356			}
357			}
358
359			/**
360			* awaitNanos without a signal times out
361			*/
362			public void testAwaitNanos_Timeout() {
363			final Mutex lock = new Mutex();
364			final Condition c = lock.newCondition();
365			try {
366			lock.lock();
367			long t = c.awaitNanos(100);
368			assertTrue(t <= 0);
369			lock.unlock();
370			}
371			catch (Exception ex) {
372			unexpectedException();
373			}
374			}
375
376			/**
377			* timed await without a signal times out
378			*/
379			public void testAwait_Timeout() {
380			final Mutex lock = new Mutex();
381			final Condition c = lock.newCondition();
382			try {
383			lock.lock();
384			assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
385			lock.unlock();
386			}
387			catch (Exception ex) {
388			unexpectedException();
389			}
390			}
391
392			/**
393			* awaitUntil without a signal times out
394			*/
395			public void testAwaitUntil_Timeout() {
396			final Mutex lock = new Mutex();
397			final Condition c = lock.newCondition();
398			try {
399			lock.lock();
400			java.util.Date d = new java.util.Date();
401			assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
402			lock.unlock();
403			}
404			catch (Exception ex) {
405			unexpectedException();
406			}
407			}
408
409			/**
410			* await returns when signalled
411			*/
412			public void testAwait() {
413			final Mutex lock = new Mutex();
414			final Condition c = lock.newCondition();
415			Thread t = new Thread(new Runnable() {
416			public void run() {
417			try {
418			lock.lock();
419			c.await();
420			lock.unlock();
421			}
422			catch(InterruptedException e) {
423			threadUnexpectedException();
424			}
425			}
426			});
427
428			try {
429			t.start();
430			Thread.sleep(SHORT_DELAY_MS);
431			lock.lock();
432			c.signal();
433			lock.unlock();
434			t.join(SHORT_DELAY_MS);
435			assertFalse(t.isAlive());
436			}
437			catch (Exception ex) {
438			unexpectedException();
439			}
440			}
441
442			}