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

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 success){}


    }
    
    /*
     * 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 success){}
                }
            });
        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 success){}
                }
            });
        t.start();
        t.interrupt();
    }


    public void testTryLockWhenLocked() { 
        final ReentrantLock lock = new ReentrantLock();
        lock.lock();
        Thread t = new Thread(new Runnable() {
                public void run(){
                    assertFalse(lock.tryLock());
                }
            });
        try {
            t.start();
            t.join();
            lock.unlock();
        } catch(Exception e){
            fail("unexpected exception");
        }
    } 

    public void testTryLock_Timeout(){ 
        final ReentrantLock lock = new ReentrantLock();
        lock.lock();
        Thread t = new Thread(new Runnable() {
                public void run(){
                    try {
                        assertFalse(lock.tryLock(1, TimeUnit.MILLISECONDS));
                    } catch (Exception ex) {
                        fail("unexpected exception");
                    }
                }
            });
        try {
            t.start();
            t.join();
            lock.unlock();
        } catch(Exception e){
            fail("unexpected exception");
        }
    } 
    
    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");
        }
    }


    public void testLockInterruptibly() {
        final ReentrantLock lock = new ReentrantLock(); 
        try {
            lock.lockInterruptibly();
        } catch(Exception e) {
            fail("unexpected exception");
        }
        Thread t = new Thread(new Runnable() { 
                public void run() {
                    try {
                        lock.lockInterruptibly();
                        fail("should throw");
                    }
                    catch(InterruptedException e) {}
                }
            });
        try {
            t.start();
            t.interrupt();
            assertTrue(lock.isLocked());
            assertTrue(lock.isHeldByCurrentThread());
            t.join();
        } catch(Exception e){
            fail("unexpected exception");
        }
    }

    public void testAwait_IllegalMonitor() {
        final ReentrantLock lock = new ReentrantLock(); 
        final Condition c = lock.newCondition();
        try {
            c.await();
            fail("should throw");
        }
        catch (IllegalMonitorStateException success) {
        }
        catch (Exception ex) {
            fail("should throw IMSE");
        }
    }

    public void testSignal_IllegalMonitor() {
        final ReentrantLock lock = new ReentrantLock(); 
        final Condition c = lock.newCondition();
        try {
            c.signal();
            fail("should throw");
        }
        catch (IllegalMonitorStateException success) {
        }
        catch (Exception ex) {
            fail("should throw IMSE");
        }
    }

    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) {
            fail("unexpected exception");
        }
    }

    public void testAwait_Timeout() {
        final ReentrantLock lock = new ReentrantLock(); 
        final Condition c = lock.newCondition();
        try {
            lock.lock();
            assertFalse(c.await(10, TimeUnit.MILLISECONDS));
            lock.unlock();
        }
        catch (Exception ex) {
            fail("unexpected exception");
        }
    }

    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) {
            fail("unexpected exception");
        }
    }

    public void testAwait() {
        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();
                    }
                    catch(InterruptedException e) {
                        fail("unexpected exception");
                    }
                }
            });

        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) {
            fail("unexpected exception");
        }
    }

    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();
            t.join(SHORT_DELAY_MS);
            assertFalse(t.isAlive());
        }
        catch (Exception ex) {
            fail("unexpected exception");
        }
    }

    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();
                        fail("should throw");
                    }
                    catch(InterruptedException success) {
                    }
                }
            });

        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join(SHORT_DELAY_MS);
            assertFalse(t.isAlive());
        }
        catch (Exception ex) {
            fail("unexpected exception");
        }
    }

    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();
                        fail("should throw");
                    }
                    catch(InterruptedException success) {
                    }
                }
            });

        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join(SHORT_DELAY_MS);
            assertFalse(t.isAlive());
        }
        catch (Exception ex) {
            fail("unexpected exception");
        }
    }

    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();
                        fail("should throw");
                    }
                    catch(InterruptedException success) {
                    }
                }
            });

        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join(SHORT_DELAY_MS);
            assertFalse(t.isAlive());
        }
        catch (Exception ex) {
            fail("unexpected exception");
        }
    }

    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) {
                        fail("unexpected exception");
                    }
                }
            });

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

        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) {
            fail("unexpected exception");
        }
    }

    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();
            fail("unexpected exception");
        }
    }

}
Revision:	1.3
Committed:	Sun Sep 7 20:39:11 2003 UTC (20 years, 8 months ago) by dl
Branch:	MAIN
Changes since 1.2:	+80 -18 lines
Log Message:	Added serialization and lock tests
#	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.io.*;
12
13	public class ReentrantLockTest extends TestCase {
14	static int HOLD_COUNT_TEST_LIMIT = 20;
15
16	public static void main(String[] args) {
17	junit.textui.TestRunner.run (suite());
18	}
19
20	public static Test suite() {
21	return new TestSuite(ReentrantLockTest.class);
22	}
23
24	private static long SHORT_DELAY_MS = 100;
25	private static long MEDIUM_DELAY_MS = 1000;
26	private static long LONG_DELAY_MS = 10000;
27
28	/*
29	* Unlocks an unlocked lock, throws Illegal Monitor State
30	*
31	*/
32
33	public void testIllegalMonitorStateException(){
34	ReentrantLock rl = new ReentrantLock();
35	try{
36	rl.unlock();
37	fail("Should of thown Illegal Monitor State Exception");
38
39	} catch(IllegalMonitorStateException success){}
40
41
42	}
43
44	/*
45	* makes a lock, locks it, tries to aquire the lock in another thread
46	* interrupts that thread and waits for an interrupted Exception to
47	* be thrown.
48	*/
49
50	public void testInterruptedException(){
51	final ReentrantLock lock = new ReentrantLock();
52	lock.lock();
53	Thread t = new Thread(new Runnable() {
54	public void run(){
55	try{
56	lock.lockInterruptibly();
57	fail("should throw");
58	} catch(InterruptedException success){}
59	}
60	});
61	t.start();
62	t.interrupt();
63	lock.unlock();
64	}
65
66	/*
67	* tests for interrupted exception on a timed wait
68	*
69	*/
70
71
72	public void testInterruptedException2(){
73	final ReentrantLock lock = new ReentrantLock();
74	lock.lock();
75	Thread t = new Thread(new Runnable() {
76	public void run(){
77	try{
78	lock.tryLock(1000,TimeUnit.MILLISECONDS);
79	fail("should throw");
80	} catch(InterruptedException success){}
81	}
82	});
83	t.start();
84	t.interrupt();
85	}
86
87
88	public void testTryLockWhenLocked() {
89	final ReentrantLock lock = new ReentrantLock();
90	lock.lock();
91	Thread t = new Thread(new Runnable() {
92	public void run(){
93	assertFalse(lock.tryLock());
94	}
95	});
96	try {
97	t.start();
98	t.join();
99	lock.unlock();
100	} catch(Exception e){
101	fail("unexpected exception");
102	}
103	}
104
105	public void testTryLock_Timeout(){
106	final ReentrantLock lock = new ReentrantLock();
107	lock.lock();
108	Thread t = new Thread(new Runnable() {
109	public void run(){
110	try {
111	assertFalse(lock.tryLock(1, TimeUnit.MILLISECONDS));
112	} catch (Exception ex) {
113	fail("unexpected exception");
114	}
115	}
116	});
117	try {
118	t.start();
119	t.join();
120	lock.unlock();
121	} catch(Exception e){
122	fail("unexpected exception");
123	}
124	}
125
126	public void testGetHoldCount() {
127	ReentrantLock lock = new ReentrantLock();
128	for(int i = 1; i <= ReentrantLockTest.HOLD_COUNT_TEST_LIMIT;i++) {
129	lock.lock();
130	assertEquals(i,lock.getHoldCount());
131	}
132	for(int i = ReentrantLockTest.HOLD_COUNT_TEST_LIMIT; i > 0; i--) {
133	lock.unlock();
134	assertEquals(i-1,lock.getHoldCount());
135	}
136	}
137
138
139
140
141	public void testIsLocked() {
142	final ReentrantLock lock = new ReentrantLock();
143	lock.lock();
144	assertTrue(lock.isLocked());
145	lock.unlock();
146	assertFalse(lock.isLocked());
147	Thread t = new Thread(new Runnable() {
148	public void run() {
149	lock.lock();
150	try {
151	Thread.sleep(SHORT_DELAY_MS * 2);
152	}
153	catch(Exception e) {}
154	lock.unlock();
155	}
156	});
157	try{
158	t.start();
159	Thread.sleep(SHORT_DELAY_MS);
160	assertTrue(lock.isLocked());
161	t.join();
162	assertFalse(lock.isLocked());
163	} catch(Exception e){
164	fail("unexpected exception");
165	}
166	}
167
168
169	public void testLockInterruptibly() {
170	final ReentrantLock lock = new ReentrantLock();
171	try {
172	lock.lockInterruptibly();
173	} catch(Exception e) {
174	fail("unexpected exception");
175	}
176	Thread t = new Thread(new Runnable() {
177	public void run() {
178	try {
179	lock.lockInterruptibly();
180	fail("should throw");
181	}
182	catch(InterruptedException e) {}
183	}
184	});
185	try {
186	t.start();
187	t.interrupt();
188	assertTrue(lock.isLocked());
189	assertTrue(lock.isHeldByCurrentThread());
190	t.join();
191	} catch(Exception e){
192	fail("unexpected exception");
193	}
194	}
195
196	public void testAwait_IllegalMonitor() {
197	final ReentrantLock lock = new ReentrantLock();
198	final Condition c = lock.newCondition();
199	try {
200	c.await();
201	fail("should throw");
202	}
203	catch (IllegalMonitorStateException success) {
204	}
205	catch (Exception ex) {
206	fail("should throw IMSE");
207	}
208	}
209
210	public void testSignal_IllegalMonitor() {
211	final ReentrantLock lock = new ReentrantLock();
212	final Condition c = lock.newCondition();
213	try {
214	c.signal();
215	fail("should throw");
216	}
217	catch (IllegalMonitorStateException success) {
218	}
219	catch (Exception ex) {
220	fail("should throw IMSE");
221	}
222	}
223
224	public void testAwaitNanos_Timeout() {
225	final ReentrantLock lock = new ReentrantLock();
226	final Condition c = lock.newCondition();
227	try {
228	lock.lock();
229	long t = c.awaitNanos(100);
230	assertTrue(t <= 0);
231	lock.unlock();
232	}
233	catch (Exception ex) {
234	fail("unexpected exception");
235	}
236	}
237
238	public void testAwait_Timeout() {
239	final ReentrantLock lock = new ReentrantLock();
240	final Condition c = lock.newCondition();
241	try {
242	lock.lock();
243	assertFalse(c.await(10, TimeUnit.MILLISECONDS));
244	lock.unlock();
245	}
246	catch (Exception ex) {
247	fail("unexpected exception");
248	}
249	}
250
251	public void testAwaitUntil_Timeout() {
252	final ReentrantLock lock = new ReentrantLock();
253	final Condition c = lock.newCondition();
254	try {
255	lock.lock();
256	java.util.Date d = new java.util.Date();
257	assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
258	lock.unlock();
259	}
260	catch (Exception ex) {
261	fail("unexpected exception");
262	}
263	}
264
265	public void testAwait() {
266	final ReentrantLock lock = new ReentrantLock();
267	final Condition c = lock.newCondition();
268	Thread t = new Thread(new Runnable() {
269	public void run() {
270	try {
271	lock.lock();
272	c.await();
273	lock.unlock();
274	}
275	catch(InterruptedException e) {
276	fail("unexpected exception");
277	}
278	}
279	});
280
281	try {
282	t.start();
283	Thread.sleep(SHORT_DELAY_MS);
284	lock.lock();
285	c.signal();
286	lock.unlock();
287	t.join(SHORT_DELAY_MS);
288	assertFalse(t.isAlive());
289	}
290	catch (Exception ex) {
291	fail("unexpected exception");
292	}
293	}
294
295	public void testAwaitUninterruptibly() {
296	final ReentrantLock lock = new ReentrantLock();
297	final Condition c = lock.newCondition();
298	Thread t = new Thread(new Runnable() {
299	public void run() {
300	lock.lock();
301	c.awaitUninterruptibly();
302	lock.unlock();
303	}
304	});
305
306	try {
307	t.start();
308	Thread.sleep(SHORT_DELAY_MS);
309	t.interrupt();
310	lock.lock();
311	c.signal();
312	lock.unlock();
313	t.join(SHORT_DELAY_MS);
314	assertFalse(t.isAlive());
315	}
316	catch (Exception ex) {
317	fail("unexpected exception");
318	}
319	}
320
321	public void testAwait_Interrupt() {
322	final ReentrantLock lock = new ReentrantLock();
323	final Condition c = lock.newCondition();
324	Thread t = new Thread(new Runnable() {
325	public void run() {
326	try {
327	lock.lock();
328	c.await();
329	lock.unlock();
330	fail("should throw");
331	}
332	catch(InterruptedException success) {
333	}
334	}
335	});
336
337	try {
338	t.start();
339	Thread.sleep(SHORT_DELAY_MS);
340	t.interrupt();
341	t.join(SHORT_DELAY_MS);
342	assertFalse(t.isAlive());
343	}
344	catch (Exception ex) {
345	fail("unexpected exception");
346	}
347	}
348
349	public void testAwaitNanos_Interrupt() {
350	final ReentrantLock lock = new ReentrantLock();
351	final Condition c = lock.newCondition();
352	Thread t = new Thread(new Runnable() {
353	public void run() {
354	try {
355	lock.lock();
356	c.awaitNanos(SHORT_DELAY_MS * 2 * 1000000);
357	lock.unlock();
358	fail("should throw");
359	}
360	catch(InterruptedException success) {
361	}
362	}
363	});
364
365	try {
366	t.start();
367	Thread.sleep(SHORT_DELAY_MS);
368	t.interrupt();
369	t.join(SHORT_DELAY_MS);
370	assertFalse(t.isAlive());
371	}
372	catch (Exception ex) {
373	fail("unexpected exception");
374	}
375	}
376
377	public void testAwaitUntil_Interrupt() {
378	final ReentrantLock lock = new ReentrantLock();
379	final Condition c = lock.newCondition();
380	Thread t = new Thread(new Runnable() {
381	public void run() {
382	try {
383	lock.lock();
384	java.util.Date d = new java.util.Date();
385	c.awaitUntil(new java.util.Date(d.getTime() + 10000));
386	lock.unlock();
387	fail("should throw");
388	}
389	catch(InterruptedException success) {
390	}
391	}
392	});
393
394	try {
395	t.start();
396	Thread.sleep(SHORT_DELAY_MS);
397	t.interrupt();
398	t.join(SHORT_DELAY_MS);
399	assertFalse(t.isAlive());
400	}
401	catch (Exception ex) {
402	fail("unexpected exception");
403	}
404	}
405
406	public void testSignalAll() {
407	final ReentrantLock lock = new ReentrantLock();
408	final Condition c = lock.newCondition();
409	Thread t1 = new Thread(new Runnable() {
410	public void run() {
411	try {
412	lock.lock();
413	c.await();
414	lock.unlock();
415	}
416	catch(InterruptedException e) {
417	fail("unexpected exception");
418	}
419	}
420	});
421
422	Thread t2 = 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	fail("unexpected exception");
431	}
432	}
433	});
434
435	try {
436	t1.start();
437	t2.start();
438	Thread.sleep(SHORT_DELAY_MS);
439	lock.lock();
440	c.signalAll();
441	lock.unlock();
442	t1.join(SHORT_DELAY_MS);
443	t2.join(SHORT_DELAY_MS);
444	assertFalse(t1.isAlive());
445	assertFalse(t2.isAlive());
446	}
447	catch (Exception ex) {
448	fail("unexpected exception");
449	}
450	}
451
452	public void testSerialization() {
453	ReentrantLock l = new ReentrantLock();
454	l.lock();
455	l.unlock();
456
457	try {
458	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
459	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
460	out.writeObject(l);
461	out.close();
462
463	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
464	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
465	ReentrantLock r = (ReentrantLock) in.readObject();
466	r.lock();
467	r.unlock();
468	} catch(Exception e){
469	e.printStackTrace();
470	fail("unexpected exception");
471	}
472	}
473
474	}