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 {
            public int acquireExclusiveState(boolean isQueued, int acquires, Thread current) {
                assert acquires == 1; // Does not use multiple acquires
                return state().compareAndSet(0, 1)? 0 : -1;
            }
            
            public boolean releaseExclusiveState(int releases) {
                state().set(0);
                return true;
            }
            
            public int acquireSharedState(boolean isQueued, int acquires, Thread current) {
                throw new UnsupportedOperationException();
            }
            
            public boolean releaseSharedState(int releases) {
                throw new UnsupportedOperationException();
            }
            
            public void checkConditionAccess(Thread thread, boolean waiting) {
                if (state().get() == 0) throw new IllegalMonitorStateException();
            }
            
            Condition newCondition() { return new ConditionObject(); }
            
            private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
                s.defaultReadObject();
                state().set(0); // reset to unlocked state
            }
        }
        
        private final Sync sync = new Sync();
        public void lock() { sync.acquireExclusiveUninterruptibly(1);  }
        public boolean tryLock() { 
            return sync.acquireExclusiveState(false, 1, null) >= 0;
        }
        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.state().get() != 0; }
        public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
    }

    /**
     * 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();
        }
    } 

    /**
     * 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.1
Committed:	Sun Dec 28 21:56:18 2003 UTC (20 years, 4 months ago) by dl
Branch:	MAIN
Log Message:	Add tests for AQS extensions; adjust others for protected condition methods
#	Content
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	public int acquireExclusiveState(boolean isQueued, int acquires, Thread current) {
34	assert acquires == 1; // Does not use multiple acquires
35	return state().compareAndSet(0, 1)? 0 : -1;
36	}
37
38	public boolean releaseExclusiveState(int releases) {
39	state().set(0);
40	return true;
41	}
42
43	public int acquireSharedState(boolean isQueued, int acquires, Thread current) {
44	throw new UnsupportedOperationException();
45	}
46
47	public boolean releaseSharedState(int releases) {
48	throw new UnsupportedOperationException();
49	}
50
51	public void checkConditionAccess(Thread thread, boolean waiting) {
52	if (state().get() == 0) throw new IllegalMonitorStateException();
53	}
54
55	Condition newCondition() { return new ConditionObject(); }
56
57	private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
58	s.defaultReadObject();
59	state().set(0); // reset to unlocked state
60	}
61	}
62
63	private final Sync sync = new Sync();
64	public void lock() { sync.acquireExclusiveUninterruptibly(1); }
65	public boolean tryLock() {
66	return sync.acquireExclusiveState(false, 1, null) >= 0;
67	}
68	public void lockInterruptibly() throws InterruptedException {
69	sync.acquireExclusiveInterruptibly(1);
70	}
71	public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
72	return sync.acquireExclusiveTimed(1, unit.toNanos(timeout));
73	}
74	public void unlock() { sync.releaseExclusive(1); }
75	public Condition newCondition() { return sync.newCondition(); }
76	public boolean isLocked() { return sync.state().get() != 0; }
77	public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
78	}
79
80	/**
81	* A runnable calling lockInterruptibly
82	*/
83	class InterruptibleLockRunnable implements Runnable {
84	final Mutex lock;
85	InterruptibleLockRunnable(Mutex l) { lock = l; }
86	public void run() {
87	try {
88	lock.lockInterruptibly();
89	} catch(InterruptedException success){}
90	}
91	}
92
93
94	/**
95	* A runnable calling lockInterruptibly that expects to be
96	* interrupted
97	*/
98	class InterruptedLockRunnable implements Runnable {
99	final Mutex lock;
100	InterruptedLockRunnable(Mutex l) { lock = l; }
101	public void run() {
102	try {
103	lock.lockInterruptibly();
104	threadShouldThrow();
105	} catch(InterruptedException success){}
106	}
107	}
108
109	/**
110	* locking an unlocked lock succeeds
111	*/
112	public void testLock() {
113	Mutex rl = new Mutex();
114	rl.lock();
115	assertTrue(rl.isLocked());
116	rl.unlock();
117	}
118
119	/**
120	* trylock on an unlocked lock succeeds
121	*/
122	public void testTryLock() {
123	Mutex rl = new Mutex();
124	assertTrue(rl.tryLock());
125	assertTrue(rl.isLocked());
126	rl.unlock();
127	}
128
129	/**
130	* hasQueuedThreads reports whether there are waiting threads
131	*/
132	public void testhasQueuedThreads() {
133	final Mutex lock = new Mutex();
134	Thread t1 = new Thread(new InterruptedLockRunnable(lock));
135	Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
136	try {
137	assertFalse(lock.hasQueuedThreads());
138	lock.lock();
139	t1.start();
140	Thread.sleep(SHORT_DELAY_MS);
141	assertTrue(lock.hasQueuedThreads());
142	t2.start();
143	Thread.sleep(SHORT_DELAY_MS);
144	assertTrue(lock.hasQueuedThreads());
145	t1.interrupt();
146	Thread.sleep(SHORT_DELAY_MS);
147	assertTrue(lock.hasQueuedThreads());
148	lock.unlock();
149	Thread.sleep(SHORT_DELAY_MS);
150	assertFalse(lock.hasQueuedThreads());
151	t1.join();
152	t2.join();
153	} catch(Exception e){
154	unexpectedException();
155	}
156	}
157
158	/**
159	* timed trylock is interruptible.
160	*/
161	public void testInterruptedException2() {
162	final Mutex lock = new Mutex();
163	lock.lock();
164	Thread t = new Thread(new Runnable() {
165	public void run() {
166	try {
167	lock.tryLock(MEDIUM_DELAY_MS,TimeUnit.MILLISECONDS);
168	threadShouldThrow();
169	} catch(InterruptedException success){}
170	}
171	});
172	try {
173	t.start();
174	t.interrupt();
175	} catch(Exception e){
176	unexpectedException();
177	}
178	}
179
180
181	/**
182	* Trylock on a locked lock fails
183	*/
184	public void testTryLockWhenLocked() {
185	final Mutex lock = new Mutex();
186	lock.lock();
187	Thread t = new Thread(new Runnable() {
188	public void run() {
189	threadAssertFalse(lock.tryLock());
190	}
191	});
192	try {
193	t.start();
194	t.join();
195	lock.unlock();
196	} catch(Exception e){
197	unexpectedException();
198	}
199	}
200
201	/**
202	* Timed trylock on a locked lock times out
203	*/
204	public void testTryLock_Timeout() {
205	final Mutex lock = new Mutex();
206	lock.lock();
207	Thread t = new Thread(new Runnable() {
208	public void run() {
209	try {
210	threadAssertFalse(lock.tryLock(1, TimeUnit.MILLISECONDS));
211	} catch (Exception ex) {
212	threadUnexpectedException();
213	}
214	}
215	});
216	try {
217	t.start();
218	t.join();
219	lock.unlock();
220	} catch(Exception e){
221	unexpectedException();
222	}
223	}
224
225
226	/**
227	* isLocked is true when locked and false when not
228	*/
229	public void testIsLocked() {
230	final Mutex lock = new Mutex();
231	lock.lock();
232	assertTrue(lock.isLocked());
233	lock.unlock();
234	assertFalse(lock.isLocked());
235	Thread t = new Thread(new Runnable() {
236	public void run() {
237	lock.lock();
238	try {
239	Thread.sleep(SMALL_DELAY_MS);
240	}
241	catch(Exception e) {
242	threadUnexpectedException();
243	}
244	lock.unlock();
245	}
246	});
247	try {
248	t.start();
249	Thread.sleep(SHORT_DELAY_MS);
250	assertTrue(lock.isLocked());
251	t.join();
252	assertFalse(lock.isLocked());
253	} catch(Exception e){
254	unexpectedException();
255	}
256	}
257
258
259	/**
260	* lockInterruptibly is interruptible.
261	*/
262	public void testLockInterruptibly1() {
263	final Mutex lock = new Mutex();
264	lock.lock();
265	Thread t = new Thread(new InterruptedLockRunnable(lock));
266	try {
267	t.start();
268	t.interrupt();
269	lock.unlock();
270	t.join();
271	} catch(Exception e){
272	unexpectedException();
273	}
274	}
275
276	/**
277	* lockInterruptibly succeeds when unlocked, else is interruptible
278	*/
279	public void testLockInterruptibly2() {
280	final Mutex lock = new Mutex();
281	try {
282	lock.lockInterruptibly();
283	} catch(Exception e) {
284	unexpectedException();
285	}
286	Thread t = new Thread(new InterruptedLockRunnable(lock));
287	try {
288	t.start();
289	t.interrupt();
290	assertTrue(lock.isLocked());
291	t.join();
292	} catch(Exception e){
293	unexpectedException();
294	}
295	}
296
297	/**
298	* Calling await without holding lock throws IllegalMonitorStateException
299	*/
300	public void testAwait_IllegalMonitor() {
301	final Mutex lock = new Mutex();
302	final Condition c = lock.newCondition();
303	try {
304	c.await();
305	shouldThrow();
306	}
307	catch (IllegalMonitorStateException success) {
308	}
309	catch (Exception ex) {
310	unexpectedException();
311	}
312	}
313
314	/**
315	* Calling signal without holding lock throws IllegalMonitorStateException
316	*/
317	public void testSignal_IllegalMonitor() {
318	final Mutex lock = new Mutex();
319	final Condition c = lock.newCondition();
320	try {
321	c.signal();
322	shouldThrow();
323	}
324	catch (IllegalMonitorStateException success) {
325	}
326	catch (Exception ex) {
327	unexpectedException();
328	}
329	}
330
331	/**
332	* awaitNanos without a signal times out
333	*/
334	public void testAwaitNanos_Timeout() {
335	final Mutex lock = new Mutex();
336	final Condition c = lock.newCondition();
337	try {
338	lock.lock();
339	long t = c.awaitNanos(100);
340	assertTrue(t <= 0);
341	lock.unlock();
342	}
343	catch (Exception ex) {
344	unexpectedException();
345	}
346	}
347
348	/**
349	* timed await without a signal times out
350	*/
351	public void testAwait_Timeout() {
352	final Mutex lock = new Mutex();
353	final Condition c = lock.newCondition();
354	try {
355	lock.lock();
356	assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
357	lock.unlock();
358	}
359	catch (Exception ex) {
360	unexpectedException();
361	}
362	}
363
364	/**
365	* awaitUntil without a signal times out
366	*/
367	public void testAwaitUntil_Timeout() {
368	final Mutex lock = new Mutex();
369	final Condition c = lock.newCondition();
370	try {
371	lock.lock();
372	java.util.Date d = new java.util.Date();
373	assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
374	lock.unlock();
375	}
376	catch (Exception ex) {
377	unexpectedException();
378	}
379	}
380
381	/**
382	* await returns when signalled
383	*/
384	public void testAwait() {
385	final Mutex lock = new Mutex();
386	final Condition c = lock.newCondition();
387	Thread t = new Thread(new Runnable() {
388	public void run() {
389	try {
390	lock.lock();
391	c.await();
392	lock.unlock();
393	}
394	catch(InterruptedException e) {
395	threadUnexpectedException();
396	}
397	}
398	});
399
400	try {
401	t.start();
402	Thread.sleep(SHORT_DELAY_MS);
403	lock.lock();
404	c.signal();
405	lock.unlock();
406	t.join(SHORT_DELAY_MS);
407	assertFalse(t.isAlive());
408	}
409	catch (Exception ex) {
410	unexpectedException();
411	}
412	}
413
414	}