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.*;

public class ReentrantLockTest extends TestCase {
    static int HOLD_COUNT_TEST_LIMIT = 20;

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

    private static long SHORT_DELAY_MS = 100; 
    private static long MEDIUM_DELAY_MS = 1000;
    private static long LONG_DELAY_MS = 10000; 

    /*
     * Unlocks an unlocked lock, throws Illegal Monitor State
     * 
     */
    
    public void testIllegalMonitorStateException(){ 
        ReentrantLock rl = new ReentrantLock();
        try{
            rl.unlock();
            fail("Should of thown Illegal Monitor State Exception");

        }catch(IllegalMonitorStateException sucess){}


    }
    
    /*
     * makes a lock, locks it, tries to aquire the lock in another thread
     * interrupts that thread and waits for an interrupted Exception to
     * be thrown.
     */

    public void testInterruptedException(){ 
        final ReentrantLock lock = new ReentrantLock();
        lock.lock();
        Thread t = new Thread(new Runnable() {
                public void run(){
                    try{
                        lock.lockInterruptibly();
                        fail("should throw");
                    }catch(InterruptedException sucess){}
                }
            });
        t.start();
        t.interrupt();
        lock.unlock();
    } 

    /*
     * tests for interrupted exception on a timed wait
     *
     */
    

    public void testInterruptedException2(){ 
        final ReentrantLock lock = new ReentrantLock();
        lock.lock();
        Thread t = new Thread(new Runnable() {
                public void run(){
                    try{
                        lock.tryLock(1000,TimeUnit.MILLISECONDS);
                        fail("should throw");
                    }catch(InterruptedException sucess){}
                }
            });
        t.start();
        t.interrupt();
    }

    
    public void testGetHoldCount() {
        ReentrantLock lock = new ReentrantLock();
        for(int i = 1; i <= ReentrantLockTest.HOLD_COUNT_TEST_LIMIT;i++) {
            lock.lock();
            assertEquals(i,lock.getHoldCount());
        }
        for(int i = ReentrantLockTest.HOLD_COUNT_TEST_LIMIT; i > 0; i--) {
            lock.unlock();
            assertEquals(i-1,lock.getHoldCount());
        }
    }
    
   
    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(SHORT_DELAY_MS * 2);
                    }
                    catch(Exception e) {}
                    lock.unlock();
                }
            });
        try{
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            assertTrue(lock.isLocked());
            t.join();
            assertFalse(lock.isLocked());
        } catch(Exception e){
            fail("unexpected exception");
        }

    }

    /*
     * current thread locks interruptibly the thread
     * another thread tries to aquire the lock and blocks 
     * on the call. interrupt the attempted aquireLock
     * assert that the first lock() call actually locked the lock
     * assert that the current thread is the one holding the lock
     */

    public void testLockedInterruptibly() {
        final ReentrantLock lock = new ReentrantLock(); 
        try {lock.lockInterruptibly();} catch(Exception e) {}
        Thread t = new Thread(new Runnable() { 
                public void run() {
                    try {
                        lock.lockInterruptibly();
                        fail("Failed to generate an Interrupted Exception");
                    }
                    catch(InterruptedException e) {}
                }
            });
        t.start();
        t.interrupt();
        assertTrue(lock.isLocked());
        assertTrue(lock.isHeldByCurrentThread());
    }
    

}
Revision:	1.1
Committed:	Sun Aug 31 19:24:55 2003 UTC (20 years, 8 months ago) by dl
Branch:	MAIN
Log Message:	First check-in of tests to be in tck
#	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
12	public class ReentrantLockTest extends TestCase {
13	static int HOLD_COUNT_TEST_LIMIT = 20;
14
15	public static void main(String[] args) {
16	junit.textui.TestRunner.run (suite());
17	}
18
19	public static Test suite() {
20	return new TestSuite(ReentrantLockTest.class);
21	}
22
23	private static long SHORT_DELAY_MS = 100;
24	private static long MEDIUM_DELAY_MS = 1000;
25	private static long LONG_DELAY_MS = 10000;
26
27	/*
28	* Unlocks an unlocked lock, throws Illegal Monitor State
29	*
30	*/
31
32	public void testIllegalMonitorStateException(){
33	ReentrantLock rl = new ReentrantLock();
34	try{
35	rl.unlock();
36	fail("Should of thown Illegal Monitor State Exception");
37
38	}catch(IllegalMonitorStateException sucess){}
39
40
41	}
42
43	/*
44	* makes a lock, locks it, tries to aquire the lock in another thread
45	* interrupts that thread and waits for an interrupted Exception to
46	* be thrown.
47	*/
48
49	public void testInterruptedException(){
50	final ReentrantLock lock = new ReentrantLock();
51	lock.lock();
52	Thread t = new Thread(new Runnable() {
53	public void run(){
54	try{
55	lock.lockInterruptibly();
56	fail("should throw");
57	}catch(InterruptedException sucess){}
58	}
59	});
60	t.start();
61	t.interrupt();
62	lock.unlock();
63	}
64
65	/*
66	* tests for interrupted exception on a timed wait
67	*
68	*/
69
70
71	public void testInterruptedException2(){
72	final ReentrantLock lock = new ReentrantLock();
73	lock.lock();
74	Thread t = new Thread(new Runnable() {
75	public void run(){
76	try{
77	lock.tryLock(1000,TimeUnit.MILLISECONDS);
78	fail("should throw");
79	}catch(InterruptedException sucess){}
80	}
81	});
82	t.start();
83	t.interrupt();
84	}
85
86
87	public void testGetHoldCount() {
88	ReentrantLock lock = new ReentrantLock();
89	for(int i = 1; i <= ReentrantLockTest.HOLD_COUNT_TEST_LIMIT;i++) {
90	lock.lock();
91	assertEquals(i,lock.getHoldCount());
92	}
93	for(int i = ReentrantLockTest.HOLD_COUNT_TEST_LIMIT; i > 0; i--) {
94	lock.unlock();
95	assertEquals(i-1,lock.getHoldCount());
96	}
97	}
98
99
100
101
102	public void testIsLocked() {
103	final ReentrantLock lock = new ReentrantLock();
104	lock.lock();
105	assertTrue(lock.isLocked());
106	lock.unlock();
107	assertFalse(lock.isLocked());
108	Thread t = new Thread(new Runnable() {
109	public void run() {
110	lock.lock();
111	try {
112	Thread.sleep(SHORT_DELAY_MS * 2);
113	}
114	catch(Exception e) {}
115	lock.unlock();
116	}
117	});
118	try{
119	t.start();
120	Thread.sleep(SHORT_DELAY_MS);
121	assertTrue(lock.isLocked());
122	t.join();
123	assertFalse(lock.isLocked());
124	} catch(Exception e){
125	fail("unexpected exception");
126	}
127
128	}
129
130	/*
131	* current thread locks interruptibly the thread
132	* another thread tries to aquire the lock and blocks
133	* on the call. interrupt the attempted aquireLock
134	* assert that the first lock() call actually locked the lock
135	* assert that the current thread is the one holding the lock
136	*/
137
138	public void testLockedInterruptibly() {
139	final ReentrantLock lock = new ReentrantLock();
140	try {lock.lockInterruptibly();} catch(Exception e) {}
141	Thread t = new Thread(new Runnable() {
142	public void run() {
143	try {
144	lock.lockInterruptibly();
145	fail("Failed to generate an Interrupted Exception");
146	}
147	catch(InterruptedException e) {}
148	}
149	});
150	t.start();
151	t.interrupt();
152	assertTrue(lock.isLocked());
153	assertTrue(lock.isHeldByCurrentThread());
154	}
155
156
157	}