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, adapted from the
     * AbstractQueuedSynchronizer javadoc.  Exclusive acquire tests
     * exercise this as a sample user extension.  Other
     * methods/features of AbstractQueuedSynchronizerTest are tested
     * via other test classes, including those for ReentrantLock,
     * ReentrantReadWriteLock, and Semaphore
     */
    static class Mutex extends AbstractQueuedSynchronizer {
        public boolean isLocked() { return getState() == 1; }
        
        public boolean tryAcquireExclusive(int acquires) {
            assertTrue(acquires == 1); 
            return compareAndSetState(0, 1);
        }
        
        public boolean tryReleaseExclusive(int releases) {
            setState(0);
            return true;
        }
        
        public void checkConditionAccess(Thread thread) {
            if (getState() == 0) throw new IllegalMonitorStateException();
        }
        
        public ConditionObject newCondition() { return new ConditionObject(); }
        
        public void lock() { 
            acquireExclusiveUninterruptibly(1);
        }

    }

    
    /**
     * A simple latch class, to test shared mode.
     */
    static class BooleanLatch extends AbstractQueuedSynchronizer { 
        public boolean isSignalled() { return getState() != 0; }

        public int tryAcquireShared(int ignore) {
            return isSignalled()? 1 : -1;
        }
        
        public boolean tryReleaseShared(int ignore) {
            setState(1);
            return true;
        }
    }

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


    /**
     * A runnable calling acquireExclusiveInterruptibly that expects to be
     * interrupted
     */
    class InterruptedLockRunnable implements Runnable {
        final Mutex lock;
        InterruptedLockRunnable(Mutex l) { lock = l; }
        public void run() {
            try {
                lock.acquireExclusiveInterruptibly(1);
                threadShouldThrow();
            } catch(InterruptedException success){}
        }
    }
    
    /**
     * acquireExclusiveUninterruptiblying an releaseExclusiveed lock succeeds
     */
    public void testAcquireExclusiveUninterruptibly() { 
        Mutex rl = new Mutex();
        rl.acquireExclusiveUninterruptibly(1);
        assertTrue(rl.isLocked());
        rl.releaseExclusive(1);
    }

    /**
     * tryAcquireExclusive on an releaseExclusiveed lock succeeds
     */
    public void testTryAcquireExclusive() { 
        Mutex rl = new Mutex();
        assertTrue(rl.tryAcquireExclusive(1));
        assertTrue(rl.isLocked());
        rl.releaseExclusive(1);
    }

    /**
     * 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.acquireExclusiveUninterruptibly(1);
            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.releaseExclusive(1);
            Thread.sleep(SHORT_DELAY_MS);
            assertFalse(lock.hasQueuedThreads());
            t1.join();
            t2.join();
        } catch(Exception e){
            unexpectedException();
        }
    } 

    /**
     * isQueued(null) throws NPE
     */
    public void testIsQueuedNPE() { 
        final Mutex lock = new Mutex();
        try {
            lock.isQueued(null);
            shouldThrow();
        } catch (NullPointerException success) {
        }
    }

    /**
     * isQueued reports whether a thread is queued.
     */
    public void testIsQueued() { 
        final Mutex lock = new Mutex();
        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
        try {
            assertFalse(lock.isQueued(t1));
            assertFalse(lock.isQueued(t2));
            lock.acquireExclusiveUninterruptibly(1);
            t1.start();
            Thread.sleep(SHORT_DELAY_MS);
            assertTrue(lock.isQueued(t1));
            t2.start();
            Thread.sleep(SHORT_DELAY_MS);
            assertTrue(lock.isQueued(t1));
            assertTrue(lock.isQueued(t2));
            t1.interrupt();
            Thread.sleep(SHORT_DELAY_MS);
            assertFalse(lock.isQueued(t1));
            assertTrue(lock.isQueued(t2));
            lock.releaseExclusive(1);
            Thread.sleep(SHORT_DELAY_MS);
            assertFalse(lock.isQueued(t1));
            assertFalse(lock.isQueued(t2));
            t1.join();
            t2.join();
        } catch(Exception e){
            unexpectedException();
        }
    } 

    /**
     * getFirstQueuedThread returns first waiting thread or null is none
     */
    public void testGetFirstQueuedThread() { 
        final Mutex lock = new Mutex();
        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
        try {
            assertNull(lock.getFirstQueuedThread());
            lock.acquireExclusiveUninterruptibly(1);
            t1.start();
            Thread.sleep(SHORT_DELAY_MS);
            assertEquals(t1, lock.getFirstQueuedThread());
            t2.start();
            Thread.sleep(SHORT_DELAY_MS);
            assertEquals(t1, lock.getFirstQueuedThread());
            t1.interrupt();
            Thread.sleep(SHORT_DELAY_MS);
            assertEquals(t2, lock.getFirstQueuedThread());
            lock.releaseExclusive(1);
            Thread.sleep(SHORT_DELAY_MS);
            assertNull(lock.getFirstQueuedThread());
            t1.join();
            t2.join();
        } catch(Exception e){
            unexpectedException();
        }
    } 


    /**
     * hasContended reports false if no thread has ever blocked, else true
     */
    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.acquireExclusiveUninterruptibly(1);
            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.releaseExclusive(1);
            Thread.sleep(SHORT_DELAY_MS);
            assertTrue(lock.hasContended());
            t1.join();
            t2.join();
        } catch(Exception e){
            unexpectedException();
        }
    } 

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


    /**
     * TryAcquireExclusive on a locked lock fails
     */
    public void testTryAcquireExclusiveWhenLocked() { 
        final Mutex lock = new Mutex();
        lock.acquireExclusiveUninterruptibly(1);
        Thread t = new Thread(new Runnable() {
                public void run() {
                    threadAssertFalse(lock.tryAcquireExclusive(1));
                }
            });
        try {
            t.start();
            t.join();
            lock.releaseExclusive(1);
        } catch(Exception e){
            unexpectedException();
        }
    } 

    /**
     * acquireExclusiveNanos on a locked lock times out
     */
    public void testAcquireExclusiveNanos_Timeout() { 
        final Mutex lock = new Mutex();
        lock.acquireExclusiveUninterruptibly(1);
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        threadAssertFalse(lock.acquireExclusiveNanos(1, 1000 * 1000));
                    } catch (Exception ex) {
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t.start();
            t.join();
            lock.releaseExclusive(1);
        } catch(Exception e){
            unexpectedException();
        }
    } 
    
   
    /**
     * getState is true when acquired and false when not
     */
    public void testGetState() {
        final Mutex lock = new Mutex();
        lock.acquireExclusiveUninterruptibly(1);
        assertTrue(lock.isLocked());
        lock.releaseExclusive(1);
        assertFalse(lock.isLocked());
        Thread t = new Thread(new Runnable() { 
                public void run() {
                    lock.acquireExclusiveUninterruptibly(1);
                    try {
                        Thread.sleep(SMALL_DELAY_MS);
                    }
                    catch(Exception e) {
                        threadUnexpectedException();
                    }
                    lock.releaseExclusive(1);
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            assertTrue(lock.isLocked());
            t.join();
            assertFalse(lock.isLocked());
        } catch(Exception e){
            unexpectedException();
        }
    }


    /**
     * acquireExclusiveInterruptibly is interruptible.
     */
    public void testAcquireInterruptibly1() { 
        final Mutex lock = new Mutex();
        lock.acquireExclusiveUninterruptibly(1);
        Thread t = new Thread(new InterruptedLockRunnable(lock));
        try {
            t.start();
            t.interrupt();
            lock.releaseExclusive(1);
            t.join();
        } catch(Exception e){
            unexpectedException();
        }
    } 

    /**
     * acquireExclusiveInterruptibly succeeds when released, else is interruptible
     */
    public void testAcquireInterruptibly2() {
        final Mutex lock = new Mutex(); 
        try {
            lock.acquireExclusiveInterruptibly(1);
        } 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();
        }
    }

    /**
     * owns is true for a condition created by lock else false
     */
    public void testOwns() {
        final Mutex lock = new Mutex(); 
        final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
        final Mutex lock2 = new Mutex();
        assertTrue(lock.owns(c));
        assertFalse(lock2.owns(c));
    }

    /**
     * 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.acquireExclusiveUninterruptibly(1);
            long t = c.awaitNanos(100);
            assertTrue(t <= 0);
            lock.releaseExclusive(1);
        }
        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.acquireExclusiveUninterruptibly(1);
            assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            lock.releaseExclusive(1);
        }
        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.acquireExclusiveUninterruptibly(1);
            java.util.Date d = new java.util.Date();
            assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
            lock.releaseExclusive(1);
        }
        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.acquireExclusiveUninterruptibly(1);
                        c.await();
                        lock.releaseExclusive(1);
                    }
                    catch(InterruptedException e) {
                        threadUnexpectedException();
                    }
                }
            });

        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            lock.acquireExclusiveUninterruptibly(1);
            c.signal();
            lock.releaseExclusive(1);
            t.join(SHORT_DELAY_MS);
            assertFalse(t.isAlive());
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * toString indicates current state
     */
    public void testToString() {
        Mutex lock = new Mutex();
        String us = lock.toString();
        assertTrue(us.indexOf("State = 0") >= 0);
        lock.acquireExclusiveUninterruptibly(1);
        String ls = lock.toString();
        assertTrue(ls.indexOf("State = 1") >= 0);
    }

    /**
     * A serialized AQS deserializes with current state
     */
    public void testSerialization() {
        Mutex l = new Mutex();
        l.acquireExclusiveUninterruptibly(1);
        assertTrue(l.isLocked());

        try {
            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
            out.writeObject(l);
            out.close();

            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
            Mutex r = (Mutex) in.readObject();
            assertTrue(r.isLocked());
        } catch(Exception e){
            e.printStackTrace();
            unexpectedException();
        }
    }


    /**
     * Latch isSignalled initially returns false, then true after release
     */
    public void testLatchIsSignalled() {
        final BooleanLatch l = new BooleanLatch();
        assertFalse(l.isSignalled());
        l.releaseShared(0);
        assertTrue(l.isSignalled());
    }

    /**
     * release and has no effect when already signalled
     */
    public void testReleaseShared() {
        final BooleanLatch l = new BooleanLatch();
        assertFalse(l.isSignalled());
        l.releaseShared(0);
        assertTrue(l.isSignalled());
        l.releaseShared(0);
        assertTrue(l.isSignalled());
    }

    /**
     * acquireSharedInterruptibly returns after release, but not before
     */
    public void testAcquireSharedInterruptibly() {
        final BooleanLatch l = new BooleanLatch();

        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        threadAssertFalse(l.isSignalled());
                        l.acquireSharedInterruptibly(0);
                        threadAssertTrue(l.isSignalled());
                    } catch(InterruptedException e){
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t.start();
            assertFalse(l.isSignalled());
            Thread.sleep(SHORT_DELAY_MS);
            l.releaseShared(0);
            assertTrue(l.isSignalled());
            t.join();
        } catch (InterruptedException e){
            unexpectedException();
        }
    }
    

    /**
     * acquireSharedTimed returns after release
     */
    public void testAsquireSharedTimed() {
        final BooleanLatch l = new BooleanLatch();

        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        threadAssertFalse(l.isSignalled());
                        threadAssertTrue(l.acquireSharedNanos(0, MEDIUM_DELAY_MS* 1000 * 1000));
                        threadAssertTrue(l.isSignalled());

                    } catch(InterruptedException e){
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t.start();
            assertFalse(l.isSignalled());
            Thread.sleep(SHORT_DELAY_MS);
            l.releaseShared(0);
            assertTrue(l.isSignalled());
            t.join();
        } catch (InterruptedException e){
            unexpectedException();
        }
    }
    
    /**
     * acquireSharedInterruptibly throws IE if interrupted before released
     */
    public void testAcquireSharedInterruptibly_InterruptedException() {
        final BooleanLatch l = new BooleanLatch();
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        threadAssertFalse(l.isSignalled());
                        l.acquireSharedInterruptibly(0);
                        threadShouldThrow();
                    } catch(InterruptedException success){}
                }
            });
        t.start();
        try {
            assertFalse(l.isSignalled());
            t.interrupt();
            t.join();
        } catch (InterruptedException e){
            unexpectedException();
        }
    }

    /**
     * acquireSharedTimed throws IE if interrupted before released
     */
    public void testAcquireSharedNanos_InterruptedException() {
        final BooleanLatch l = new BooleanLatch();
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        threadAssertFalse(l.isSignalled());
                        l.acquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000);
                        threadShouldThrow();                        
                    } catch(InterruptedException success){}
                }
            });
        t.start();
        try {
            Thread.sleep(SHORT_DELAY_MS);
            assertFalse(l.isSignalled());
            t.interrupt();
            t.join();
        } catch (InterruptedException e){
            unexpectedException();
        }
    }

    /**
     * acquireSharedTimed times out if not released before timeout
     */
    public void testAcquireSharedNanos_Timeout() {
        final BooleanLatch l = new BooleanLatch();
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        threadAssertFalse(l.isSignalled());
                        threadAssertFalse(l.acquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000));
                    } catch(InterruptedException ie){
                        threadUnexpectedException();
                    }
                }
            });
        t.start();
        try {
            Thread.sleep(SHORT_DELAY_MS);
            assertFalse(l.isSignalled());
            t.join();
        } catch (InterruptedException e){
            unexpectedException();
        }
    }

    
}
Revision:	1.14
Committed:	Sat Jan 10 01:41:59 2004 UTC (20 years, 3 months ago) by dl
Branch:	MAIN
Changes since 1.13:	+37 -0 lines
Log Message:	Test toString
#	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	dl	1.12	* A simple mutex class, adapted from the
26			* AbstractQueuedSynchronizer javadoc. Exclusive acquire tests
27			* exercise this as a sample user extension. Other
28			* methods/features of AbstractQueuedSynchronizerTest are tested
29			* via other test classes, including those for ReentrantLock,
30			* ReentrantReadWriteLock, and Semaphore
31			*/
32			static class Mutex extends AbstractQueuedSynchronizer {
33			public boolean isLocked() { return getState() == 1; }
34
35			public boolean tryAcquireExclusive(int acquires) {
36			assertTrue(acquires == 1);
37			return compareAndSetState(0, 1);
38			}
39
40			public boolean tryReleaseExclusive(int releases) {
41			setState(0);
42			return true;
43			}
44
45			public void checkConditionAccess(Thread thread) {
46			if (getState() == 0) throw new IllegalMonitorStateException();
47			}
48
49			public ConditionObject newCondition() { return new ConditionObject(); }
50
51	dl	1.2	public void lock() {
52	dl	1.12	acquireExclusiveUninterruptibly(1);
53	dl	1.1	}
54	dl	1.12
55			}
56
57
58			/**
59			* A simple latch class, to test shared mode.
60			*/
61			static class BooleanLatch extends AbstractQueuedSynchronizer {
62			public boolean isSignalled() { return getState() != 0; }
63
64			public int tryAcquireShared(int ignore) {
65			return isSignalled()? 1 : -1;
66	dl	1.1	}
67	dl	1.12
68			public boolean tryReleaseShared(int ignore) {
69			setState(1);
70			return true;
71	dl	1.1	}
72			}
73
74			/**
75	dl	1.12	* A runnable calling acquireExclusiveInterruptibly
76	dl	1.1	*/
77			class InterruptibleLockRunnable implements Runnable {
78			final Mutex lock;
79			InterruptibleLockRunnable(Mutex l) { lock = l; }
80			public void run() {
81			try {
82	dl	1.12	lock.acquireExclusiveInterruptibly(1);
83	dl	1.1	} catch(InterruptedException success){}
84			}
85			}
86
87
88			/**
89	dl	1.12	* A runnable calling acquireExclusiveInterruptibly that expects to be
90	dl	1.1	* interrupted
91			*/
92			class InterruptedLockRunnable implements Runnable {
93			final Mutex lock;
94			InterruptedLockRunnable(Mutex l) { lock = l; }
95			public void run() {
96			try {
97	dl	1.12	lock.acquireExclusiveInterruptibly(1);
98	dl	1.1	threadShouldThrow();
99			} catch(InterruptedException success){}
100			}
101			}
102
103			/**
104	dl	1.12	* acquireExclusiveUninterruptiblying an releaseExclusiveed lock succeeds
105	dl	1.1	*/
106	dl	1.12	public void testAcquireExclusiveUninterruptibly() {
107	dl	1.1	Mutex rl = new Mutex();
108	dl	1.12	rl.acquireExclusiveUninterruptibly(1);
109	dl	1.1	assertTrue(rl.isLocked());
110	dl	1.12	rl.releaseExclusive(1);
111	dl	1.1	}
112
113			/**
114	dl	1.12	* tryAcquireExclusive on an releaseExclusiveed lock succeeds
115	dl	1.1	*/
116	dl	1.12	public void testTryAcquireExclusive() {
117	dl	1.1	Mutex rl = new Mutex();
118	dl	1.12	assertTrue(rl.tryAcquireExclusive(1));
119	dl	1.1	assertTrue(rl.isLocked());
120	dl	1.12	rl.releaseExclusive(1);
121	dl	1.1	}
122
123			/**
124			* hasQueuedThreads reports whether there are waiting threads
125			*/
126			public void testhasQueuedThreads() {
127			final Mutex lock = new Mutex();
128			Thread t1 = new Thread(new InterruptedLockRunnable(lock));
129			Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
130			try {
131			assertFalse(lock.hasQueuedThreads());
132	dl	1.12	lock.acquireExclusiveUninterruptibly(1);
133	dl	1.1	t1.start();
134			Thread.sleep(SHORT_DELAY_MS);
135			assertTrue(lock.hasQueuedThreads());
136			t2.start();
137			Thread.sleep(SHORT_DELAY_MS);
138			assertTrue(lock.hasQueuedThreads());
139			t1.interrupt();
140			Thread.sleep(SHORT_DELAY_MS);
141			assertTrue(lock.hasQueuedThreads());
142	dl	1.12	lock.releaseExclusive(1);
143	dl	1.1	Thread.sleep(SHORT_DELAY_MS);
144			assertFalse(lock.hasQueuedThreads());
145	dl	1.10	t1.join();
146			t2.join();
147			} catch(Exception e){
148			unexpectedException();
149			}
150			}
151
152			/**
153	dl	1.11	* isQueued(null) throws NPE
154			*/
155			public void testIsQueuedNPE() {
156			final Mutex lock = new Mutex();
157			try {
158			lock.isQueued(null);
159			shouldThrow();
160			} catch (NullPointerException success) {
161			}
162			}
163
164			/**
165	dl	1.10	* isQueued reports whether a thread is queued.
166			*/
167			public void testIsQueued() {
168			final Mutex lock = new Mutex();
169			Thread t1 = new Thread(new InterruptedLockRunnable(lock));
170			Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
171			try {
172			assertFalse(lock.isQueued(t1));
173			assertFalse(lock.isQueued(t2));
174	dl	1.12	lock.acquireExclusiveUninterruptibly(1);
175	dl	1.10	t1.start();
176			Thread.sleep(SHORT_DELAY_MS);
177			assertTrue(lock.isQueued(t1));
178			t2.start();
179			Thread.sleep(SHORT_DELAY_MS);
180			assertTrue(lock.isQueued(t1));
181			assertTrue(lock.isQueued(t2));
182			t1.interrupt();
183			Thread.sleep(SHORT_DELAY_MS);
184			assertFalse(lock.isQueued(t1));
185			assertTrue(lock.isQueued(t2));
186	dl	1.12	lock.releaseExclusive(1);
187	dl	1.10	Thread.sleep(SHORT_DELAY_MS);
188			assertFalse(lock.isQueued(t1));
189			assertFalse(lock.isQueued(t2));
190	dl	1.8	t1.join();
191			t2.join();
192			} catch(Exception e){
193			unexpectedException();
194			}
195			}
196
197	dl	1.12	/**
198			* getFirstQueuedThread returns first waiting thread or null is none
199			*/
200			public void testGetFirstQueuedThread() {
201			final Mutex lock = new Mutex();
202			Thread t1 = new Thread(new InterruptedLockRunnable(lock));
203			Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
204			try {
205			assertNull(lock.getFirstQueuedThread());
206			lock.acquireExclusiveUninterruptibly(1);
207			t1.start();
208			Thread.sleep(SHORT_DELAY_MS);
209			assertEquals(t1, lock.getFirstQueuedThread());
210			t2.start();
211			Thread.sleep(SHORT_DELAY_MS);
212			assertEquals(t1, lock.getFirstQueuedThread());
213			t1.interrupt();
214			Thread.sleep(SHORT_DELAY_MS);
215			assertEquals(t2, lock.getFirstQueuedThread());
216			lock.releaseExclusive(1);
217			Thread.sleep(SHORT_DELAY_MS);
218			assertNull(lock.getFirstQueuedThread());
219			t1.join();
220			t2.join();
221			} catch(Exception e){
222			unexpectedException();
223			}
224			}
225
226	dl	1.8
227			/**
228	dl	1.12	* hasContended reports false if no thread has ever blocked, else true
229	dl	1.8	*/
230	dl	1.12	public void testHasContended() {
231	dl	1.8	final Mutex lock = new Mutex();
232			Thread t1 = new Thread(new InterruptedLockRunnable(lock));
233			Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
234			try {
235			assertFalse(lock.hasContended());
236	dl	1.12	lock.acquireExclusiveUninterruptibly(1);
237	dl	1.8	t1.start();
238			Thread.sleep(SHORT_DELAY_MS);
239			assertTrue(lock.hasContended());
240			t2.start();
241			Thread.sleep(SHORT_DELAY_MS);
242			assertTrue(lock.hasContended());
243			t1.interrupt();
244			Thread.sleep(SHORT_DELAY_MS);
245			assertTrue(lock.hasContended());
246	dl	1.12	lock.releaseExclusive(1);
247	dl	1.8	Thread.sleep(SHORT_DELAY_MS);
248			assertTrue(lock.hasContended());
249	dl	1.1	t1.join();
250			t2.join();
251			} catch(Exception e){
252			unexpectedException();
253			}
254			}
255
256			/**
257	dl	1.13	* acquireExclusiveNanos is interruptible.
258	dl	1.1	*/
259			public void testInterruptedException2() {
260			final Mutex lock = new Mutex();
261	dl	1.12	lock.acquireExclusiveUninterruptibly(1);
262	dl	1.1	Thread t = new Thread(new Runnable() {
263			public void run() {
264			try {
265	dl	1.12	lock.acquireExclusiveNanos(1, MEDIUM_DELAY_MS * 1000 * 1000);
266	dl	1.1	threadShouldThrow();
267			} catch(InterruptedException success){}
268			}
269			});
270			try {
271			t.start();
272			t.interrupt();
273			} catch(Exception e){
274			unexpectedException();
275			}
276			}
277
278
279			/**
280	dl	1.12	* TryAcquireExclusive on a locked lock fails
281	dl	1.1	*/
282	dl	1.12	public void testTryAcquireExclusiveWhenLocked() {
283	dl	1.1	final Mutex lock = new Mutex();
284	dl	1.12	lock.acquireExclusiveUninterruptibly(1);
285	dl	1.1	Thread t = new Thread(new Runnable() {
286			public void run() {
287	dl	1.12	threadAssertFalse(lock.tryAcquireExclusive(1));
288	dl	1.1	}
289			});
290			try {
291			t.start();
292			t.join();
293	dl	1.12	lock.releaseExclusive(1);
294	dl	1.1	} catch(Exception e){
295			unexpectedException();
296			}
297			}
298
299			/**
300	dl	1.13	* acquireExclusiveNanos on a locked lock times out
301	dl	1.1	*/
302	dl	1.13	public void testAcquireExclusiveNanos_Timeout() {
303	dl	1.1	final Mutex lock = new Mutex();
304	dl	1.12	lock.acquireExclusiveUninterruptibly(1);
305	dl	1.1	Thread t = new Thread(new Runnable() {
306			public void run() {
307			try {
308	dl	1.12	threadAssertFalse(lock.acquireExclusiveNanos(1, 1000 * 1000));
309	dl	1.1	} catch (Exception ex) {
310			threadUnexpectedException();
311			}
312			}
313			});
314			try {
315			t.start();
316			t.join();
317	dl	1.12	lock.releaseExclusive(1);
318	dl	1.1	} catch(Exception e){
319			unexpectedException();
320			}
321			}
322
323
324			/**
325	dl	1.13	* getState is true when acquired and false when not
326	dl	1.1	*/
327	dl	1.13	public void testGetState() {
328	dl	1.1	final Mutex lock = new Mutex();
329	dl	1.12	lock.acquireExclusiveUninterruptibly(1);
330	dl	1.1	assertTrue(lock.isLocked());
331	dl	1.12	lock.releaseExclusive(1);
332	dl	1.1	assertFalse(lock.isLocked());
333			Thread t = new Thread(new Runnable() {
334			public void run() {
335	dl	1.12	lock.acquireExclusiveUninterruptibly(1);
336	dl	1.1	try {
337			Thread.sleep(SMALL_DELAY_MS);
338			}
339			catch(Exception e) {
340			threadUnexpectedException();
341			}
342	dl	1.12	lock.releaseExclusive(1);
343	dl	1.1	}
344			});
345			try {
346			t.start();
347			Thread.sleep(SHORT_DELAY_MS);
348			assertTrue(lock.isLocked());
349			t.join();
350			assertFalse(lock.isLocked());
351			} catch(Exception e){
352			unexpectedException();
353			}
354			}
355
356
357			/**
358	dl	1.12	* acquireExclusiveInterruptibly is interruptible.
359	dl	1.1	*/
360	dl	1.12	public void testAcquireInterruptibly1() {
361	dl	1.1	final Mutex lock = new Mutex();
362	dl	1.12	lock.acquireExclusiveUninterruptibly(1);
363	dl	1.1	Thread t = new Thread(new InterruptedLockRunnable(lock));
364			try {
365			t.start();
366			t.interrupt();
367	dl	1.12	lock.releaseExclusive(1);
368	dl	1.1	t.join();
369			} catch(Exception e){
370			unexpectedException();
371			}
372			}
373
374			/**
375	dl	1.12	* acquireExclusiveInterruptibly succeeds when released, else is interruptible
376	dl	1.1	*/
377	dl	1.12	public void testAcquireInterruptibly2() {
378	dl	1.1	final Mutex lock = new Mutex();
379			try {
380	dl	1.12	lock.acquireExclusiveInterruptibly(1);
381	dl	1.1	} catch(Exception e) {
382			unexpectedException();
383			}
384			Thread t = new Thread(new InterruptedLockRunnable(lock));
385			try {
386			t.start();
387			t.interrupt();
388			assertTrue(lock.isLocked());
389			t.join();
390			} catch(Exception e){
391			unexpectedException();
392			}
393			}
394
395			/**
396	dl	1.12	* owns is true for a condition created by lock else false
397			*/
398			public void testOwns() {
399			final Mutex lock = new Mutex();
400			final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
401			final Mutex lock2 = new Mutex();
402			assertTrue(lock.owns(c));
403			assertFalse(lock2.owns(c));
404			}
405
406			/**
407	dl	1.1	* Calling await without holding lock throws IllegalMonitorStateException
408			*/
409			public void testAwait_IllegalMonitor() {
410			final Mutex lock = new Mutex();
411			final Condition c = lock.newCondition();
412			try {
413			c.await();
414			shouldThrow();
415			}
416			catch (IllegalMonitorStateException success) {
417			}
418			catch (Exception ex) {
419			unexpectedException();
420			}
421			}
422
423			/**
424			* Calling signal without holding lock throws IllegalMonitorStateException
425			*/
426			public void testSignal_IllegalMonitor() {
427			final Mutex lock = new Mutex();
428			final Condition c = lock.newCondition();
429			try {
430			c.signal();
431			shouldThrow();
432			}
433			catch (IllegalMonitorStateException success) {
434			}
435			catch (Exception ex) {
436			unexpectedException();
437			}
438			}
439
440			/**
441			* awaitNanos without a signal times out
442			*/
443			public void testAwaitNanos_Timeout() {
444			final Mutex lock = new Mutex();
445			final Condition c = lock.newCondition();
446			try {
447	dl	1.12	lock.acquireExclusiveUninterruptibly(1);
448	dl	1.1	long t = c.awaitNanos(100);
449			assertTrue(t <= 0);
450	dl	1.12	lock.releaseExclusive(1);
451	dl	1.1	}
452			catch (Exception ex) {
453			unexpectedException();
454			}
455			}
456
457			/**
458			* timed await without a signal times out
459			*/
460			public void testAwait_Timeout() {
461			final Mutex lock = new Mutex();
462			final Condition c = lock.newCondition();
463			try {
464	dl	1.12	lock.acquireExclusiveUninterruptibly(1);
465	dl	1.1	assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
466	dl	1.12	lock.releaseExclusive(1);
467	dl	1.1	}
468			catch (Exception ex) {
469			unexpectedException();
470			}
471			}
472
473			/**
474			* awaitUntil without a signal times out
475			*/
476			public void testAwaitUntil_Timeout() {
477			final Mutex lock = new Mutex();
478			final Condition c = lock.newCondition();
479			try {
480	dl	1.12	lock.acquireExclusiveUninterruptibly(1);
481	dl	1.1	java.util.Date d = new java.util.Date();
482			assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
483	dl	1.12	lock.releaseExclusive(1);
484	dl	1.1	}
485			catch (Exception ex) {
486			unexpectedException();
487			}
488			}
489
490			/**
491			* await returns when signalled
492			*/
493			public void testAwait() {
494			final Mutex lock = new Mutex();
495			final Condition c = lock.newCondition();
496			Thread t = new Thread(new Runnable() {
497			public void run() {
498			try {
499	dl	1.12	lock.acquireExclusiveUninterruptibly(1);
500	dl	1.1	c.await();
501	dl	1.12	lock.releaseExclusive(1);
502	dl	1.1	}
503			catch(InterruptedException e) {
504			threadUnexpectedException();
505			}
506			}
507			});
508
509			try {
510			t.start();
511			Thread.sleep(SHORT_DELAY_MS);
512	dl	1.12	lock.acquireExclusiveUninterruptibly(1);
513	dl	1.1	c.signal();
514	dl	1.12	lock.releaseExclusive(1);
515	dl	1.1	t.join(SHORT_DELAY_MS);
516			assertFalse(t.isAlive());
517			}
518			catch (Exception ex) {
519	dl	1.12	unexpectedException();
520			}
521			}
522
523	dl	1.14	/**
524			* toString indicates current state
525			*/
526			public void testToString() {
527			Mutex lock = new Mutex();
528			String us = lock.toString();
529			assertTrue(us.indexOf("State = 0") >= 0);
530			lock.acquireExclusiveUninterruptibly(1);
531			String ls = lock.toString();
532			assertTrue(ls.indexOf("State = 1") >= 0);
533			}
534
535			/**
536			* A serialized AQS deserializes with current state
537			*/
538			public void testSerialization() {
539			Mutex l = new Mutex();
540			l.acquireExclusiveUninterruptibly(1);
541			assertTrue(l.isLocked());
542
543			try {
544			ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
545			ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
546			out.writeObject(l);
547			out.close();
548
549			ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
550			ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
551			Mutex r = (Mutex) in.readObject();
552			assertTrue(r.isLocked());
553			} catch(Exception e){
554			e.printStackTrace();
555			unexpectedException();
556			}
557			}
558
559	dl	1.12
560			/**
561			* Latch isSignalled initially returns false, then true after release
562			*/
563			public void testLatchIsSignalled() {
564			final BooleanLatch l = new BooleanLatch();
565			assertFalse(l.isSignalled());
566			l.releaseShared(0);
567			assertTrue(l.isSignalled());
568			}
569
570			/**
571			* release and has no effect when already signalled
572			*/
573	dl	1.13	public void testReleaseShared() {
574	dl	1.12	final BooleanLatch l = new BooleanLatch();
575			assertFalse(l.isSignalled());
576			l.releaseShared(0);
577			assertTrue(l.isSignalled());
578			l.releaseShared(0);
579			assertTrue(l.isSignalled());
580			}
581
582			/**
583			* acquireSharedInterruptibly returns after release, but not before
584			*/
585	dl	1.13	public void testAcquireSharedInterruptibly() {
586	dl	1.12	final BooleanLatch l = new BooleanLatch();
587
588			Thread t = new Thread(new Runnable() {
589			public void run() {
590			try {
591			threadAssertFalse(l.isSignalled());
592			l.acquireSharedInterruptibly(0);
593			threadAssertTrue(l.isSignalled());
594			} catch(InterruptedException e){
595			threadUnexpectedException();
596			}
597			}
598			});
599			try {
600			t.start();
601			assertFalse(l.isSignalled());
602			Thread.sleep(SHORT_DELAY_MS);
603			l.releaseShared(0);
604			assertTrue(l.isSignalled());
605			t.join();
606			} catch (InterruptedException e){
607			unexpectedException();
608			}
609			}
610
611
612			/**
613			* acquireSharedTimed returns after release
614			*/
615	dl	1.13	public void testAsquireSharedTimed() {
616	dl	1.12	final BooleanLatch l = new BooleanLatch();
617
618			Thread t = new Thread(new Runnable() {
619			public void run() {
620			try {
621			threadAssertFalse(l.isSignalled());
622			threadAssertTrue(l.acquireSharedNanos(0, MEDIUM_DELAY_MS* 1000 * 1000));
623			threadAssertTrue(l.isSignalled());
624
625			} catch(InterruptedException e){
626			threadUnexpectedException();
627			}
628			}
629			});
630			try {
631			t.start();
632			assertFalse(l.isSignalled());
633			Thread.sleep(SHORT_DELAY_MS);
634			l.releaseShared(0);
635			assertTrue(l.isSignalled());
636			t.join();
637			} catch (InterruptedException e){
638			unexpectedException();
639			}
640			}
641
642			/**
643			* acquireSharedInterruptibly throws IE if interrupted before released
644			*/
645	dl	1.13	public void testAcquireSharedInterruptibly_InterruptedException() {
646	dl	1.12	final BooleanLatch l = new BooleanLatch();
647			Thread t = new Thread(new Runnable() {
648			public void run() {
649			try {
650			threadAssertFalse(l.isSignalled());
651			l.acquireSharedInterruptibly(0);
652			threadShouldThrow();
653			} catch(InterruptedException success){}
654			}
655			});
656			t.start();
657			try {
658			assertFalse(l.isSignalled());
659			t.interrupt();
660			t.join();
661			} catch (InterruptedException e){
662			unexpectedException();
663			}
664			}
665
666			/**
667			* acquireSharedTimed throws IE if interrupted before released
668			*/
669	dl	1.13	public void testAcquireSharedNanos_InterruptedException() {
670	dl	1.12	final BooleanLatch l = new BooleanLatch();
671			Thread t = new Thread(new Runnable() {
672			public void run() {
673			try {
674			threadAssertFalse(l.isSignalled());
675			l.acquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000);
676			threadShouldThrow();
677			} catch(InterruptedException success){}
678			}
679			});
680			t.start();
681			try {
682			Thread.sleep(SHORT_DELAY_MS);
683			assertFalse(l.isSignalled());
684			t.interrupt();
685			t.join();
686			} catch (InterruptedException e){
687			unexpectedException();
688			}
689			}
690
691			/**
692			* acquireSharedTimed times out if not released before timeout
693			*/
694	dl	1.13	public void testAcquireSharedNanos_Timeout() {
695	dl	1.12	final BooleanLatch l = new BooleanLatch();
696			Thread t = new Thread(new Runnable() {
697			public void run() {
698			try {
699			threadAssertFalse(l.isSignalled());
700			threadAssertFalse(l.acquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000));
701			} catch(InterruptedException ie){
702			threadUnexpectedException();
703			}
704			}
705			});
706			t.start();
707			try {
708			Thread.sleep(SHORT_DELAY_MS);
709			assertFalse(l.isSignalled());
710			t.join();
711			} catch (InterruptedException e){
712	dl	1.1	unexpectedException();
713			}
714			}
715	dl	1.14
716	dl	1.1
717			}