test/tck/ReentrantLockTest.java

/*
 * Written by members of JCP JSR-166 Expert Group and released to the
 * public domain. Use, modify, and redistribute this code in any way
 * without acknowledgement. Other contributors include Andrew Wright,
 * Jeffrey Hayes, Pat Fischer, Mike Judd.
 */

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

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

    /**
     * A runnable calling lockInterruptibly
     */
    class InterruptibleLockRunnable implements Runnable {
        final ReentrantLock lock;
        InterruptibleLockRunnable(ReentrantLock 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 ReentrantLock lock;
        InterruptedLockRunnable(ReentrantLock l) { lock = l; }
        public void run() {
            try {
                lock.lockInterruptibly();
                threadShouldThrow();
            } catch(InterruptedException success){}
        }
    }

    /**
     * Subclass to expose protected methods
     */
    static class PublicReentrantLock extends ReentrantLock {
        PublicReentrantLock() { super(); }
        public Collection<Thread> getQueuedThreads() { 
            return super.getQueuedThreads(); 
        }
        public ConditionObject newCondition() { 
            return new PublicCondition(this);
        }

        static class PublicCondition extends ReentrantLock.ConditionObject {
            PublicCondition(PublicReentrantLock l) { super(l); }
            public Collection<Thread> getWaitingThreads() { 
                return super.getWaitingThreads(); 
            }
        }

    }

    /**
     * locking an unlocked lock succeeds
     */
    public void testLock() { 
        ReentrantLock rl = new ReentrantLock();
        rl.lock();
        assertTrue(rl.isLocked());
        rl.unlock();
    }

    /**
     * locking an unlocked fair lock succeeds
     */
    public void testFairLock() { 
        ReentrantLock rl = new ReentrantLock(true);
        rl.lock();
        assertTrue(rl.isLocked());
        rl.unlock();
    }

    /**
     * Unlocking an unlocked lock throws IllegalMonitorStateException
     */
    public void testUnlock_IllegalMonitorStateException() { 
        ReentrantLock rl = new ReentrantLock();
        try {
            rl.unlock();
            shouldThrow();

        } catch(IllegalMonitorStateException success){}
    }

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


    /**
     * getQueueLength reports number of waiting threads
     */
    public void testGetQueueLength() { 
        final ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
        try {
            assertEquals(0, lock.getQueueLength());
            lock.lock();
            t1.start();
            Thread.sleep(SHORT_DELAY_MS);
            assertEquals(1, lock.getQueueLength());
            t2.start();
            Thread.sleep(SHORT_DELAY_MS);
            assertEquals(2, lock.getQueueLength());
            t1.interrupt();
            Thread.sleep(SHORT_DELAY_MS);
            assertEquals(1, lock.getQueueLength());
            lock.unlock();
            Thread.sleep(SHORT_DELAY_MS);
            assertEquals(0, lock.getQueueLength());
            t1.join();
            t2.join();
        } catch(Exception e){
            unexpectedException();
        }
    } 

    /**
     * getQueuedThreads includes waiting threads
     */
    public void testGetQueuedThreads() { 
        final PublicReentrantLock lock = new PublicReentrantLock();
        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
        try {
            assertTrue(lock.getQueuedThreads().isEmpty());
            lock.lock();
            assertTrue(lock.getQueuedThreads().isEmpty());
            t1.start();
            Thread.sleep(SHORT_DELAY_MS);
            assertTrue(lock.getQueuedThreads().contains(t1));
            t2.start();
            Thread.sleep(SHORT_DELAY_MS);
            assertTrue(lock.getQueuedThreads().contains(t1));
            assertTrue(lock.getQueuedThreads().contains(t2));
            t1.interrupt();
            Thread.sleep(SHORT_DELAY_MS);
            assertFalse(lock.getQueuedThreads().contains(t1));
            assertTrue(lock.getQueuedThreads().contains(t2));
            lock.unlock();
            Thread.sleep(SHORT_DELAY_MS);
            assertTrue(lock.getQueuedThreads().isEmpty());
            t1.join();
            t2.join();
        } catch(Exception e){
            unexpectedException();
        }
    } 


    /**
     * timed trylock is interruptible.
     */
    public void testInterruptedException2() { 
        final ReentrantLock lock = new ReentrantLock();
        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 ReentrantLock lock = new ReentrantLock();
        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 ReentrantLock lock = new ReentrantLock();
        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();
        }
    } 
    
    /**
     * getHoldCount returns number of recursive holds
     */
    public void testGetHoldCount() {
        ReentrantLock lock = new ReentrantLock();
        for(int i = 1; i <= SIZE; i++) {
            lock.lock();
            assertEquals(i,lock.getHoldCount());
        }
        for(int i = SIZE; i > 0; i--) {
            lock.unlock();
            assertEquals(i-1,lock.getHoldCount());
        }
    }
    
   
    /**
     * isLocked is true when locked and false when not
     */
    public void testIsLocked() {
        final ReentrantLock lock = new ReentrantLock();
        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 ReentrantLock lock = new ReentrantLock();
        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 ReentrantLock lock = new ReentrantLock(); 
        try {
            lock.lockInterruptibly();
        } catch(Exception e) {
            unexpectedException();
        }
        Thread t = new Thread(new InterruptedLockRunnable(lock));
        try {
            t.start();
            t.interrupt();
            assertTrue(lock.isLocked());
            assertTrue(lock.isHeldByCurrentThread());
            t.join();
        } catch(Exception e){
            unexpectedException();
        }
    }

    /**
     * Calling await without holding lock throws IllegalMonitorStateException
     */
    public void testAwait_IllegalMonitor() {
        final ReentrantLock lock = new ReentrantLock(); 
        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 ReentrantLock lock = new ReentrantLock(); 
        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 ReentrantLock lock = new ReentrantLock(); 
        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 ReentrantLock lock = new ReentrantLock(); 
        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 ReentrantLock lock = new ReentrantLock(); 
        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 ReentrantLock lock = new ReentrantLock(); 
        final ReentrantLock.ConditionObject 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();
        }
    }

    /**
     * hasWaiters returns true when a thread is waiting, else false
     */
    public void testHasWaiters() {
        final ReentrantLock lock = new ReentrantLock(); 
        final ReentrantLock.ConditionObject c = lock.newCondition();
        Thread t = new Thread(new Runnable() { 
                public void run() {
                    try {
                        lock.lock();
                        threadAssertFalse(c.hasWaiters());
                        threadAssertEquals(0, c.getWaitQueueLength());
                        c.await();
                        lock.unlock();
                    }
                    catch(InterruptedException e) {
                        threadUnexpectedException();
                    }
                }
            });

        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            lock.lock();
            assertTrue(c.hasWaiters());
            assertEquals(1, c.getWaitQueueLength());
            c.signal();
            lock.unlock();
            Thread.sleep(SHORT_DELAY_MS);
            lock.lock();
            assertFalse(c.hasWaiters());
            assertEquals(0, c.getWaitQueueLength());
            lock.unlock();
            t.join(SHORT_DELAY_MS);
            assertFalse(t.isAlive());
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * getWaitQueueLength returns number of waiting threads
     */
    public void testGetWaitQueueLength() {
        final ReentrantLock lock = new ReentrantLock(); 
        final ReentrantLock.ConditionObject c = lock.newCondition();
        Thread t1 = new Thread(new Runnable() { 
                public void run() {
                    try {
                        lock.lock();
                        threadAssertFalse(c.hasWaiters());
                        threadAssertEquals(0, c.getWaitQueueLength());
                        c.await();
                        lock.unlock();
                    }
                    catch(InterruptedException e) {
                        threadUnexpectedException();
                    }
                }
            });

        Thread t2 = new Thread(new Runnable() { 
                public void run() {
                    try {
                        lock.lock();
                        threadAssertTrue(c.hasWaiters());
                        threadAssertEquals(1, c.getWaitQueueLength());
                        c.await();
                        lock.unlock();
                    }
                    catch(InterruptedException e) {
                        threadUnexpectedException();
                    }
                }
            });

        try {
            t1.start();
            Thread.sleep(SHORT_DELAY_MS);
            t2.start();
            Thread.sleep(SHORT_DELAY_MS);
            lock.lock();
            assertTrue(c.hasWaiters());
            assertEquals(2, c.getWaitQueueLength());
            c.signalAll();
            lock.unlock();
            Thread.sleep(SHORT_DELAY_MS);
            lock.lock();
            assertFalse(c.hasWaiters());
            assertEquals(0, c.getWaitQueueLength());
            lock.unlock();
            t1.join(SHORT_DELAY_MS);
            t2.join(SHORT_DELAY_MS);
            assertFalse(t1.isAlive());
            assertFalse(t2.isAlive());
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * getWaitingThreads returns only and all waiting threads
     */
    public void testGetWaitingThreads() {
        final PublicReentrantLock lock = new PublicReentrantLock();     
        final PublicReentrantLock.PublicCondition c = (PublicReentrantLock.PublicCondition)lock.newCondition();
        Thread t1 = new Thread(new Runnable() { 
                public void run() {
                    try {
                        lock.lock();
                        threadAssertTrue(c.getWaitingThreads().isEmpty());
                        c.await();
                        lock.unlock();
                    }
                    catch(InterruptedException e) {
                        threadUnexpectedException();
                    }
                }
            });

        Thread t2 = new Thread(new Runnable() { 
                public void run() {
                    try {
                        lock.lock();
                        threadAssertFalse(c.getWaitingThreads().isEmpty());
                        c.await();
                        lock.unlock();
                    }
                    catch(InterruptedException e) {
                        threadUnexpectedException();
                    }
                }
            });

        try {
            lock.lock();
            assertTrue(c.getWaitingThreads().isEmpty());
            lock.unlock();
            t1.start();
            Thread.sleep(SHORT_DELAY_MS);
            t2.start();
            Thread.sleep(SHORT_DELAY_MS);
            lock.lock();
            assertTrue(c.hasWaiters());
            assertTrue(c.getWaitingThreads().contains(t1));
            assertTrue(c.getWaitingThreads().contains(t2));
            c.signalAll();
            lock.unlock();
            Thread.sleep(SHORT_DELAY_MS);
            lock.lock();
            assertFalse(c.hasWaiters());
            assertTrue(c.getWaitingThreads().isEmpty());
            lock.unlock();
            t1.join(SHORT_DELAY_MS);
            t2.join(SHORT_DELAY_MS);
            assertFalse(t1.isAlive());
            assertFalse(t2.isAlive());
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * awaitUninterruptibly doesn't abort on interrupt
     */
    public void testAwaitUninterruptibly() {
        final ReentrantLock lock = new ReentrantLock(); 
        final Condition c = lock.newCondition();
        Thread t = new Thread(new Runnable() { 
                public void run() {
                    lock.lock();
                    c.awaitUninterruptibly();
                    lock.unlock();
                }
            });

        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            lock.lock();
            c.signal();
            lock.unlock();
            assert(t.isInterrupted());
            t.join(SHORT_DELAY_MS);
            assertFalse(t.isAlive());
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * await is interruptible
     */
    public void testAwait_Interrupt() {
        final ReentrantLock lock = new ReentrantLock(); 
        final Condition c = lock.newCondition();
        Thread t = new Thread(new Runnable() { 
                public void run() {
                    try {
                        lock.lock();
                        c.await();
                        lock.unlock();
                        threadShouldThrow();
                    }
                    catch(InterruptedException success) {
                    }
                }
            });

        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join(SHORT_DELAY_MS);
            assertFalse(t.isAlive());
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * awaitNanos is interruptible
     */
    public void testAwaitNanos_Interrupt() {
        final ReentrantLock lock = new ReentrantLock(); 
        final Condition c = lock.newCondition();
        Thread t = new Thread(new Runnable() { 
                public void run() {
                    try {
                        lock.lock();
                        c.awaitNanos(SHORT_DELAY_MS * 2 * 1000000);
                        lock.unlock();
                        threadShouldThrow();
                    }
                    catch(InterruptedException success) {
                    }
                }
            });

        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join(SHORT_DELAY_MS);
            assertFalse(t.isAlive());
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * awaitUntil is interruptible
     */
    public void testAwaitUntil_Interrupt() {
        final ReentrantLock lock = new ReentrantLock(); 
        final Condition c = lock.newCondition();
        Thread t = new Thread(new Runnable() { 
                public void run() {
                    try {
                        lock.lock();
                        java.util.Date d = new java.util.Date();
                        c.awaitUntil(new java.util.Date(d.getTime() + 10000));
                        lock.unlock();
                        threadShouldThrow();
                    }
                    catch(InterruptedException success) {
                    }
                }
            });

        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join(SHORT_DELAY_MS);
            assertFalse(t.isAlive());
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * signalAll wakes up all threads
     */
    public void testSignalAll() {
        final ReentrantLock lock = new ReentrantLock(); 
        final Condition c = lock.newCondition();
        Thread t1 = new Thread(new Runnable() { 
                public void run() {
                    try {
                        lock.lock();
                        c.await();
                        lock.unlock();
                    }
                    catch(InterruptedException e) {
                        threadUnexpectedException();
                    }
                }
            });

        Thread t2 = new Thread(new Runnable() { 
                public void run() {
                    try {
                        lock.lock();
                        c.await();
                        lock.unlock();
                    }
                    catch(InterruptedException e) {
                        threadUnexpectedException();
                    }
                }
            });

        try {
            t1.start();
            t2.start();
            Thread.sleep(SHORT_DELAY_MS);
            lock.lock();
            c.signalAll();
            lock.unlock();
            t1.join(SHORT_DELAY_MS);
            t2.join(SHORT_DELAY_MS);
            assertFalse(t1.isAlive());
            assertFalse(t2.isAlive());
        }
        catch (Exception ex) {
            unexpectedException();
        }
    }

    /**
     * A serialized lock deserializes as unlocked
     */
    public void testSerialization() {
        ReentrantLock l = new ReentrantLock();
        l.lock();
        l.unlock();

        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));
            ReentrantLock r = (ReentrantLock) in.readObject();
            r.lock();
            r.unlock();
        } catch(Exception e){
            e.printStackTrace();
            unexpectedException();
        }
    }

}
Revision:	1.8
Committed:	Fri Sep 26 15:33:13 2003 UTC (20 years, 7 months ago) by dl
Branch:	MAIN
Changes since 1.7:	+8 -8 lines
Log Message:	Javadoc fixes
#	Content
1	/*
2	* Written by members of JCP JSR-166 Expert Group and released to the
3	* public domain. Use, modify, and redistribute this code in any way
4	* without acknowledgement. Other contributors include Andrew Wright,
5	* Jeffrey Hayes, Pat Fischer, Mike Judd.
6	*/
7
8	import junit.framework.*;
9	import java.util.concurrent.locks.*;
10	import java.util.concurrent.*;
11	import java.util.*;
12	import java.io.*;
13
14	public class ReentrantLockTest extends JSR166TestCase {
15	public static void main(String[] args) {
16	junit.textui.TestRunner.run (suite());
17	}
18	public static Test suite() {
19	return new TestSuite(ReentrantLockTest.class);
20	}
21
22	/**
23	* A runnable calling lockInterruptibly
24	*/
25	class InterruptibleLockRunnable implements Runnable {
26	final ReentrantLock lock;
27	InterruptibleLockRunnable(ReentrantLock l) { lock = l; }
28	public void run() {
29	try {
30	lock.lockInterruptibly();
31	} catch(InterruptedException success){}
32	}
33	}
34
35
36	/**
37	* A runnable calling lockInterruptibly that expects to be
38	* interrupted
39	*/
40	class InterruptedLockRunnable implements Runnable {
41	final ReentrantLock lock;
42	InterruptedLockRunnable(ReentrantLock l) { lock = l; }
43	public void run() {
44	try {
45	lock.lockInterruptibly();
46	threadShouldThrow();
47	} catch(InterruptedException success){}
48	}
49	}
50
51	/**
52	* Subclass to expose protected methods
53	*/
54	static class PublicReentrantLock extends ReentrantLock {
55	PublicReentrantLock() { super(); }
56	public Collection<Thread> getQueuedThreads() {
57	return super.getQueuedThreads();
58	}
59	public ConditionObject newCondition() {
60	return new PublicCondition(this);
61	}
62
63	static class PublicCondition extends ReentrantLock.ConditionObject {
64	PublicCondition(PublicReentrantLock l) { super(l); }
65	public Collection<Thread> getWaitingThreads() {
66	return super.getWaitingThreads();
67	}
68	}
69
70	}
71
72	/**
73	* locking an unlocked lock succeeds
74	*/
75	public void testLock() {
76	ReentrantLock rl = new ReentrantLock();
77	rl.lock();
78	assertTrue(rl.isLocked());
79	rl.unlock();
80	}
81
82	/**
83	* locking an unlocked fair lock succeeds
84	*/
85	public void testFairLock() {
86	ReentrantLock rl = new ReentrantLock(true);
87	rl.lock();
88	assertTrue(rl.isLocked());
89	rl.unlock();
90	}
91
92	/**
93	* Unlocking an unlocked lock throws IllegalMonitorStateException
94	*/
95	public void testUnlock_IllegalMonitorStateException() {
96	ReentrantLock rl = new ReentrantLock();
97	try {
98	rl.unlock();
99	shouldThrow();
100
101	} catch(IllegalMonitorStateException success){}
102	}
103
104	/**
105	* trylock on an unlocked lock succeeds
106	*/
107	public void testTryLock() {
108	ReentrantLock rl = new ReentrantLock();
109	assertTrue(rl.tryLock());
110	assertTrue(rl.isLocked());
111	rl.unlock();
112	}
113
114
115	/**
116	* getQueueLength reports number of waiting threads
117	*/
118	public void testGetQueueLength() {
119	final ReentrantLock lock = new ReentrantLock();
120	Thread t1 = new Thread(new InterruptedLockRunnable(lock));
121	Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
122	try {
123	assertEquals(0, lock.getQueueLength());
124	lock.lock();
125	t1.start();
126	Thread.sleep(SHORT_DELAY_MS);
127	assertEquals(1, lock.getQueueLength());
128	t2.start();
129	Thread.sleep(SHORT_DELAY_MS);
130	assertEquals(2, lock.getQueueLength());
131	t1.interrupt();
132	Thread.sleep(SHORT_DELAY_MS);
133	assertEquals(1, lock.getQueueLength());
134	lock.unlock();
135	Thread.sleep(SHORT_DELAY_MS);
136	assertEquals(0, lock.getQueueLength());
137	t1.join();
138	t2.join();
139	} catch(Exception e){
140	unexpectedException();
141	}
142	}
143
144	/**
145	* getQueuedThreads includes waiting threads
146	*/
147	public void testGetQueuedThreads() {
148	final PublicReentrantLock lock = new PublicReentrantLock();
149	Thread t1 = new Thread(new InterruptedLockRunnable(lock));
150	Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
151	try {
152	assertTrue(lock.getQueuedThreads().isEmpty());
153	lock.lock();
154	assertTrue(lock.getQueuedThreads().isEmpty());
155	t1.start();
156	Thread.sleep(SHORT_DELAY_MS);
157	assertTrue(lock.getQueuedThreads().contains(t1));
158	t2.start();
159	Thread.sleep(SHORT_DELAY_MS);
160	assertTrue(lock.getQueuedThreads().contains(t1));
161	assertTrue(lock.getQueuedThreads().contains(t2));
162	t1.interrupt();
163	Thread.sleep(SHORT_DELAY_MS);
164	assertFalse(lock.getQueuedThreads().contains(t1));
165	assertTrue(lock.getQueuedThreads().contains(t2));
166	lock.unlock();
167	Thread.sleep(SHORT_DELAY_MS);
168	assertTrue(lock.getQueuedThreads().isEmpty());
169	t1.join();
170	t2.join();
171	} catch(Exception e){
172	unexpectedException();
173	}
174	}
175
176
177	/**
178	* timed trylock is interruptible.
179	*/
180	public void testInterruptedException2() {
181	final ReentrantLock lock = new ReentrantLock();
182	lock.lock();
183	Thread t = new Thread(new Runnable() {
184	public void run() {
185	try {
186	lock.tryLock(MEDIUM_DELAY_MS,TimeUnit.MILLISECONDS);
187	threadShouldThrow();
188	} catch(InterruptedException success){}
189	}
190	});
191	try {
192	t.start();
193	t.interrupt();
194	} catch(Exception e){
195	unexpectedException();
196	}
197	}
198
199
200	/**
201	* Trylock on a locked lock fails
202	*/
203	public void testTryLockWhenLocked() {
204	final ReentrantLock lock = new ReentrantLock();
205	lock.lock();
206	Thread t = new Thread(new Runnable() {
207	public void run() {
208	threadAssertFalse(lock.tryLock());
209	}
210	});
211	try {
212	t.start();
213	t.join();
214	lock.unlock();
215	} catch(Exception e){
216	unexpectedException();
217	}
218	}
219
220	/**
221	* Timed trylock on a locked lock times out
222	*/
223	public void testTryLock_Timeout() {
224	final ReentrantLock lock = new ReentrantLock();
225	lock.lock();
226	Thread t = new Thread(new Runnable() {
227	public void run() {
228	try {
229	threadAssertFalse(lock.tryLock(1, TimeUnit.MILLISECONDS));
230	} catch (Exception ex) {
231	threadUnexpectedException();
232	}
233	}
234	});
235	try {
236	t.start();
237	t.join();
238	lock.unlock();
239	} catch(Exception e){
240	unexpectedException();
241	}
242	}
243
244	/**
245	* getHoldCount returns number of recursive holds
246	*/
247	public void testGetHoldCount() {
248	ReentrantLock lock = new ReentrantLock();
249	for(int i = 1; i <= SIZE; i++) {
250	lock.lock();
251	assertEquals(i,lock.getHoldCount());
252	}
253	for(int i = SIZE; i > 0; i--) {
254	lock.unlock();
255	assertEquals(i-1,lock.getHoldCount());
256	}
257	}
258
259
260	/**
261	* isLocked is true when locked and false when not
262	*/
263	public void testIsLocked() {
264	final ReentrantLock lock = new ReentrantLock();
265	lock.lock();
266	assertTrue(lock.isLocked());
267	lock.unlock();
268	assertFalse(lock.isLocked());
269	Thread t = new Thread(new Runnable() {
270	public void run() {
271	lock.lock();
272	try {
273	Thread.sleep(SMALL_DELAY_MS);
274	}
275	catch(Exception e) {
276	threadUnexpectedException();
277	}
278	lock.unlock();
279	}
280	});
281	try {
282	t.start();
283	Thread.sleep(SHORT_DELAY_MS);
284	assertTrue(lock.isLocked());
285	t.join();
286	assertFalse(lock.isLocked());
287	} catch(Exception e){
288	unexpectedException();
289	}
290	}
291
292
293	/**
294	* lockInterruptibly is interruptible.
295	*/
296	public void testLockInterruptibly1() {
297	final ReentrantLock lock = new ReentrantLock();
298	lock.lock();
299	Thread t = new Thread(new InterruptedLockRunnable(lock));
300	try {
301	t.start();
302	t.interrupt();
303	lock.unlock();
304	t.join();
305	} catch(Exception e){
306	unexpectedException();
307	}
308	}
309
310	/**
311	* lockInterruptibly succeeds when unlocked, else is interruptible
312	*/
313	public void testLockInterruptibly2() {
314	final ReentrantLock lock = new ReentrantLock();
315	try {
316	lock.lockInterruptibly();
317	} catch(Exception e) {
318	unexpectedException();
319	}
320	Thread t = new Thread(new InterruptedLockRunnable(lock));
321	try {
322	t.start();
323	t.interrupt();
324	assertTrue(lock.isLocked());
325	assertTrue(lock.isHeldByCurrentThread());
326	t.join();
327	} catch(Exception e){
328	unexpectedException();
329	}
330	}
331
332	/**
333	* Calling await without holding lock throws IllegalMonitorStateException
334	*/
335	public void testAwait_IllegalMonitor() {
336	final ReentrantLock lock = new ReentrantLock();
337	final Condition c = lock.newCondition();
338	try {
339	c.await();
340	shouldThrow();
341	}
342	catch (IllegalMonitorStateException success) {
343	}
344	catch (Exception ex) {
345	unexpectedException();
346	}
347	}
348
349	/**
350	* Calling signal without holding lock throws IllegalMonitorStateException
351	*/
352	public void testSignal_IllegalMonitor() {
353	final ReentrantLock lock = new ReentrantLock();
354	final Condition c = lock.newCondition();
355	try {
356	c.signal();
357	shouldThrow();
358	}
359	catch (IllegalMonitorStateException success) {
360	}
361	catch (Exception ex) {
362	unexpectedException();
363	}
364	}
365
366	/**
367	* awaitNanos without a signal times out
368	*/
369	public void testAwaitNanos_Timeout() {
370	final ReentrantLock lock = new ReentrantLock();
371	final Condition c = lock.newCondition();
372	try {
373	lock.lock();
374	long t = c.awaitNanos(100);
375	assertTrue(t <= 0);
376	lock.unlock();
377	}
378	catch (Exception ex) {
379	unexpectedException();
380	}
381	}
382
383	/**
384	* timed await without a signal times out
385	*/
386	public void testAwait_Timeout() {
387	final ReentrantLock lock = new ReentrantLock();
388	final Condition c = lock.newCondition();
389	try {
390	lock.lock();
391	assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
392	lock.unlock();
393	}
394	catch (Exception ex) {
395	unexpectedException();
396	}
397	}
398
399	/**
400	* awaitUntil without a signal times out
401	*/
402	public void testAwaitUntil_Timeout() {
403	final ReentrantLock lock = new ReentrantLock();
404	final Condition c = lock.newCondition();
405	try {
406	lock.lock();
407	java.util.Date d = new java.util.Date();
408	assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
409	lock.unlock();
410	}
411	catch (Exception ex) {
412	unexpectedException();
413	}
414	}
415
416	/**
417	* await returns when signalled
418	*/
419	public void testAwait() {
420	final ReentrantLock lock = new ReentrantLock();
421	final ReentrantLock.ConditionObject c = lock.newCondition();
422	Thread t = new Thread(new Runnable() {
423	public void run() {
424	try {
425	lock.lock();
426	c.await();
427	lock.unlock();
428	}
429	catch(InterruptedException e) {
430	threadUnexpectedException();
431	}
432	}
433	});
434
435	try {
436	t.start();
437	Thread.sleep(SHORT_DELAY_MS);
438	lock.lock();
439	c.signal();
440	lock.unlock();
441	t.join(SHORT_DELAY_MS);
442	assertFalse(t.isAlive());
443	}
444	catch (Exception ex) {
445	unexpectedException();
446	}
447	}
448
449	/**
450	* hasWaiters returns true when a thread is waiting, else false
451	*/
452	public void testHasWaiters() {
453	final ReentrantLock lock = new ReentrantLock();
454	final ReentrantLock.ConditionObject c = lock.newCondition();
455	Thread t = new Thread(new Runnable() {
456	public void run() {
457	try {
458	lock.lock();
459	threadAssertFalse(c.hasWaiters());
460	threadAssertEquals(0, c.getWaitQueueLength());
461	c.await();
462	lock.unlock();
463	}
464	catch(InterruptedException e) {
465	threadUnexpectedException();
466	}
467	}
468	});
469
470	try {
471	t.start();
472	Thread.sleep(SHORT_DELAY_MS);
473	lock.lock();
474	assertTrue(c.hasWaiters());
475	assertEquals(1, c.getWaitQueueLength());
476	c.signal();
477	lock.unlock();
478	Thread.sleep(SHORT_DELAY_MS);
479	lock.lock();
480	assertFalse(c.hasWaiters());
481	assertEquals(0, c.getWaitQueueLength());
482	lock.unlock();
483	t.join(SHORT_DELAY_MS);
484	assertFalse(t.isAlive());
485	}
486	catch (Exception ex) {
487	unexpectedException();
488	}
489	}
490
491	/**
492	* getWaitQueueLength returns number of waiting threads
493	*/
494	public void testGetWaitQueueLength() {
495	final ReentrantLock lock = new ReentrantLock();
496	final ReentrantLock.ConditionObject c = lock.newCondition();
497	Thread t1 = new Thread(new Runnable() {
498	public void run() {
499	try {
500	lock.lock();
501	threadAssertFalse(c.hasWaiters());
502	threadAssertEquals(0, c.getWaitQueueLength());
503	c.await();
504	lock.unlock();
505	}
506	catch(InterruptedException e) {
507	threadUnexpectedException();
508	}
509	}
510	});
511
512	Thread t2 = new Thread(new Runnable() {
513	public void run() {
514	try {
515	lock.lock();
516	threadAssertTrue(c.hasWaiters());
517	threadAssertEquals(1, c.getWaitQueueLength());
518	c.await();
519	lock.unlock();
520	}
521	catch(InterruptedException e) {
522	threadUnexpectedException();
523	}
524	}
525	});
526
527	try {
528	t1.start();
529	Thread.sleep(SHORT_DELAY_MS);
530	t2.start();
531	Thread.sleep(SHORT_DELAY_MS);
532	lock.lock();
533	assertTrue(c.hasWaiters());
534	assertEquals(2, c.getWaitQueueLength());
535	c.signalAll();
536	lock.unlock();
537	Thread.sleep(SHORT_DELAY_MS);
538	lock.lock();
539	assertFalse(c.hasWaiters());
540	assertEquals(0, c.getWaitQueueLength());
541	lock.unlock();
542	t1.join(SHORT_DELAY_MS);
543	t2.join(SHORT_DELAY_MS);
544	assertFalse(t1.isAlive());
545	assertFalse(t2.isAlive());
546	}
547	catch (Exception ex) {
548	unexpectedException();
549	}
550	}
551
552	/**
553	* getWaitingThreads returns only and all waiting threads
554	*/
555	public void testGetWaitingThreads() {
556	final PublicReentrantLock lock = new PublicReentrantLock();
557	final PublicReentrantLock.PublicCondition c = (PublicReentrantLock.PublicCondition)lock.newCondition();
558	Thread t1 = new Thread(new Runnable() {
559	public void run() {
560	try {
561	lock.lock();
562	threadAssertTrue(c.getWaitingThreads().isEmpty());
563	c.await();
564	lock.unlock();
565	}
566	catch(InterruptedException e) {
567	threadUnexpectedException();
568	}
569	}
570	});
571
572	Thread t2 = new Thread(new Runnable() {
573	public void run() {
574	try {
575	lock.lock();
576	threadAssertFalse(c.getWaitingThreads().isEmpty());
577	c.await();
578	lock.unlock();
579	}
580	catch(InterruptedException e) {
581	threadUnexpectedException();
582	}
583	}
584	});
585
586	try {
587	lock.lock();
588	assertTrue(c.getWaitingThreads().isEmpty());
589	lock.unlock();
590	t1.start();
591	Thread.sleep(SHORT_DELAY_MS);
592	t2.start();
593	Thread.sleep(SHORT_DELAY_MS);
594	lock.lock();
595	assertTrue(c.hasWaiters());
596	assertTrue(c.getWaitingThreads().contains(t1));
597	assertTrue(c.getWaitingThreads().contains(t2));
598	c.signalAll();
599	lock.unlock();
600	Thread.sleep(SHORT_DELAY_MS);
601	lock.lock();
602	assertFalse(c.hasWaiters());
603	assertTrue(c.getWaitingThreads().isEmpty());
604	lock.unlock();
605	t1.join(SHORT_DELAY_MS);
606	t2.join(SHORT_DELAY_MS);
607	assertFalse(t1.isAlive());
608	assertFalse(t2.isAlive());
609	}
610	catch (Exception ex) {
611	unexpectedException();
612	}
613	}
614
615	/**
616	* awaitUninterruptibly doesn't abort on interrupt
617	*/
618	public void testAwaitUninterruptibly() {
619	final ReentrantLock lock = new ReentrantLock();
620	final Condition c = lock.newCondition();
621	Thread t = new Thread(new Runnable() {
622	public void run() {
623	lock.lock();
624	c.awaitUninterruptibly();
625	lock.unlock();
626	}
627	});
628
629	try {
630	t.start();
631	Thread.sleep(SHORT_DELAY_MS);
632	t.interrupt();
633	lock.lock();
634	c.signal();
635	lock.unlock();
636	assert(t.isInterrupted());
637	t.join(SHORT_DELAY_MS);
638	assertFalse(t.isAlive());
639	}
640	catch (Exception ex) {
641	unexpectedException();
642	}
643	}
644
645	/**
646	* await is interruptible
647	*/
648	public void testAwait_Interrupt() {
649	final ReentrantLock lock = new ReentrantLock();
650	final Condition c = lock.newCondition();
651	Thread t = new Thread(new Runnable() {
652	public void run() {
653	try {
654	lock.lock();
655	c.await();
656	lock.unlock();
657	threadShouldThrow();
658	}
659	catch(InterruptedException success) {
660	}
661	}
662	});
663
664	try {
665	t.start();
666	Thread.sleep(SHORT_DELAY_MS);
667	t.interrupt();
668	t.join(SHORT_DELAY_MS);
669	assertFalse(t.isAlive());
670	}
671	catch (Exception ex) {
672	unexpectedException();
673	}
674	}
675
676	/**
677	* awaitNanos is interruptible
678	*/
679	public void testAwaitNanos_Interrupt() {
680	final ReentrantLock lock = new ReentrantLock();
681	final Condition c = lock.newCondition();
682	Thread t = new Thread(new Runnable() {
683	public void run() {
684	try {
685	lock.lock();
686	c.awaitNanos(SHORT_DELAY_MS * 2 * 1000000);
687	lock.unlock();
688	threadShouldThrow();
689	}
690	catch(InterruptedException success) {
691	}
692	}
693	});
694
695	try {
696	t.start();
697	Thread.sleep(SHORT_DELAY_MS);
698	t.interrupt();
699	t.join(SHORT_DELAY_MS);
700	assertFalse(t.isAlive());
701	}
702	catch (Exception ex) {
703	unexpectedException();
704	}
705	}
706
707	/**
708	* awaitUntil is interruptible
709	*/
710	public void testAwaitUntil_Interrupt() {
711	final ReentrantLock lock = new ReentrantLock();
712	final Condition c = lock.newCondition();
713	Thread t = new Thread(new Runnable() {
714	public void run() {
715	try {
716	lock.lock();
717	java.util.Date d = new java.util.Date();
718	c.awaitUntil(new java.util.Date(d.getTime() + 10000));
719	lock.unlock();
720	threadShouldThrow();
721	}
722	catch(InterruptedException success) {
723	}
724	}
725	});
726
727	try {
728	t.start();
729	Thread.sleep(SHORT_DELAY_MS);
730	t.interrupt();
731	t.join(SHORT_DELAY_MS);
732	assertFalse(t.isAlive());
733	}
734	catch (Exception ex) {
735	unexpectedException();
736	}
737	}
738
739	/**
740	* signalAll wakes up all threads
741	*/
742	public void testSignalAll() {
743	final ReentrantLock lock = new ReentrantLock();
744	final Condition c = lock.newCondition();
745	Thread t1 = new Thread(new Runnable() {
746	public void run() {
747	try {
748	lock.lock();
749	c.await();
750	lock.unlock();
751	}
752	catch(InterruptedException e) {
753	threadUnexpectedException();
754	}
755	}
756	});
757
758	Thread t2 = new Thread(new Runnable() {
759	public void run() {
760	try {
761	lock.lock();
762	c.await();
763	lock.unlock();
764	}
765	catch(InterruptedException e) {
766	threadUnexpectedException();
767	}
768	}
769	});
770
771	try {
772	t1.start();
773	t2.start();
774	Thread.sleep(SHORT_DELAY_MS);
775	lock.lock();
776	c.signalAll();
777	lock.unlock();
778	t1.join(SHORT_DELAY_MS);
779	t2.join(SHORT_DELAY_MS);
780	assertFalse(t1.isAlive());
781	assertFalse(t2.isAlive());
782	}
783	catch (Exception ex) {
784	unexpectedException();
785	}
786	}
787
788	/**
789	* A serialized lock deserializes as unlocked
790	*/
791	public void testSerialization() {
792	ReentrantLock l = new ReentrantLock();
793	l.lock();
794	l.unlock();
795
796	try {
797	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
798	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
799	out.writeObject(l);
800	out.close();
801
802	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
803	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
804	ReentrantLock r = (ReentrantLock) in.readObject();
805	r.lock();
806	r.unlock();
807	} catch(Exception e){
808	e.printStackTrace();
809	unexpectedException();
810	}
811	}
812
813	}