test/tck/CountDownLatchTest.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 static java.util.concurrent.TimeUnit.MILLISECONDS;

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

    /**
     * negative constructor argument throws IAE
     */
    public void testConstructor() {
        try {
            new CountDownLatch(-1);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
    }

    /**
     * getCount returns initial count and decreases after countDown
     */
    public void testGetCount() {
        final CountDownLatch l = new CountDownLatch(2);
        assertEquals(2, l.getCount());
        l.countDown();
        assertEquals(1, l.getCount());
    }

    /**
     * countDown decrements count when positive and has no effect when zero
     */
    public void testCountDown() {
        final CountDownLatch l = new CountDownLatch(1);
        assertEquals(1, l.getCount());
        l.countDown();
        assertEquals(0, l.getCount());
        l.countDown();
        assertEquals(0, l.getCount());
    }

    /**
     * await returns after countDown to zero, but not before
     */
    public void testAwait() throws InterruptedException {
        final CountDownLatch l = new CountDownLatch(2);

        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                threadAssertTrue(l.getCount() > 0);
                l.await();
                threadAssertTrue(l.getCount() == 0);
            }});

        t.start();
        assertEquals(l.getCount(), 2);
        Thread.sleep(SHORT_DELAY_MS);
        l.countDown();
        assertEquals(l.getCount(), 1);
        l.countDown();
        assertEquals(l.getCount(), 0);
        t.join();
    }


    /**
     * timed await returns after countDown to zero
     */
    public void testTimedAwait() throws InterruptedException {
        final CountDownLatch l = new CountDownLatch(2);

        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                threadAssertTrue(l.getCount() > 0);
                threadAssertTrue(l.await(SMALL_DELAY_MS, MILLISECONDS));
            }});

        t.start();
        assertEquals(l.getCount(), 2);
        Thread.sleep(SHORT_DELAY_MS);
        l.countDown();
        assertEquals(l.getCount(), 1);
        l.countDown();
        assertEquals(l.getCount(), 0);
        t.join();
    }

    /**
     * await throws IE if interrupted before counted down
     */
    public void testAwait_InterruptedException() throws InterruptedException {
        final CountDownLatch l = new CountDownLatch(1);
        Thread t = new Thread(new CheckedInterruptedRunnable() {
            public void realRun() throws InterruptedException {
                threadAssertTrue(l.getCount() > 0);
                l.await();
            }});

        t.start();
        assertEquals(l.getCount(), 1);
        t.interrupt();
        t.join();
    }

    /**
     * timed await throws IE if interrupted before counted down
     */
    public void testTimedAwait_InterruptedException() throws InterruptedException {
        final CountDownLatch l = new CountDownLatch(1);
        Thread t = new Thread(new CheckedInterruptedRunnable() {
            public void realRun() throws InterruptedException {
                threadAssertTrue(l.getCount() > 0);
                l.await(MEDIUM_DELAY_MS, MILLISECONDS);
            }});

        t.start();
        Thread.sleep(SHORT_DELAY_MS);
        assertEquals(l.getCount(), 1);
        t.interrupt();
        t.join();
    }

    /**
     * timed await times out if not counted down before timeout
     */
    public void testAwaitTimeout() throws InterruptedException {
        final CountDownLatch l = new CountDownLatch(1);
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                threadAssertTrue(l.getCount() > 0);
                threadAssertFalse(l.await(SHORT_DELAY_MS, MILLISECONDS));
                threadAssertTrue(l.getCount() > 0);
            }});

        t.start();
        assertEquals(l.getCount(), 1);
        t.join();
    }

    /**
     * toString indicates current count
     */
    public void testToString() {
        CountDownLatch s = new CountDownLatch(2);
        String us = s.toString();
        assertTrue(us.indexOf("Count = 2") >= 0);
        s.countDown();
        String s1 = s.toString();
        assertTrue(s1.indexOf("Count = 1") >= 0);
        s.countDown();
        String s2 = s.toString();
        assertTrue(s2.indexOf("Count = 0") >= 0);
    }

}
Revision:	1.14
Committed:	Wed Aug 25 00:07:03 2010 UTC (13 years, 8 months ago) by jsr166
Branch:	MAIN
Changes since 1.13:	+1 -1 lines
Log Message:	whitespace
#	Content
1	/*
2	* Written by Doug Lea with assistance from members of JCP JSR-166
3	* Expert Group and released to the public domain, as explained at
4	* http://creativecommons.org/licenses/publicdomain
5	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	* Pat Fisher, Mike Judd.
7	*/
8
9	import junit.framework.*;
10	import java.util.*;
11	import java.util.concurrent.*;
12	import static java.util.concurrent.TimeUnit.MILLISECONDS;
13
14	public class CountDownLatchTest 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(CountDownLatchTest.class);
20	}
21
22	/**
23	* negative constructor argument throws IAE
24	*/
25	public void testConstructor() {
26	try {
27	new CountDownLatch(-1);
28	shouldThrow();
29	} catch (IllegalArgumentException success) {}
30	}
31
32	/**
33	* getCount returns initial count and decreases after countDown
34	*/
35	public void testGetCount() {
36	final CountDownLatch l = new CountDownLatch(2);
37	assertEquals(2, l.getCount());
38	l.countDown();
39	assertEquals(1, l.getCount());
40	}
41
42	/**
43	* countDown decrements count when positive and has no effect when zero
44	*/
45	public void testCountDown() {
46	final CountDownLatch l = new CountDownLatch(1);
47	assertEquals(1, l.getCount());
48	l.countDown();
49	assertEquals(0, l.getCount());
50	l.countDown();
51	assertEquals(0, l.getCount());
52	}
53
54	/**
55	* await returns after countDown to zero, but not before
56	*/
57	public void testAwait() throws InterruptedException {
58	final CountDownLatch l = new CountDownLatch(2);
59
60	Thread t = new Thread(new CheckedRunnable() {
61	public void realRun() throws InterruptedException {
62	threadAssertTrue(l.getCount() > 0);
63	l.await();
64	threadAssertTrue(l.getCount() == 0);
65	}});
66
67	t.start();
68	assertEquals(l.getCount(), 2);
69	Thread.sleep(SHORT_DELAY_MS);
70	l.countDown();
71	assertEquals(l.getCount(), 1);
72	l.countDown();
73	assertEquals(l.getCount(), 0);
74	t.join();
75	}
76
77
78	/**
79	* timed await returns after countDown to zero
80	*/
81	public void testTimedAwait() throws InterruptedException {
82	final CountDownLatch l = new CountDownLatch(2);
83
84	Thread t = new Thread(new CheckedRunnable() {
85	public void realRun() throws InterruptedException {
86	threadAssertTrue(l.getCount() > 0);
87	threadAssertTrue(l.await(SMALL_DELAY_MS, MILLISECONDS));
88	}});
89
90	t.start();
91	assertEquals(l.getCount(), 2);
92	Thread.sleep(SHORT_DELAY_MS);
93	l.countDown();
94	assertEquals(l.getCount(), 1);
95	l.countDown();
96	assertEquals(l.getCount(), 0);
97	t.join();
98	}
99
100	/**
101	* await throws IE if interrupted before counted down
102	*/
103	public void testAwait_InterruptedException() throws InterruptedException {
104	final CountDownLatch l = new CountDownLatch(1);
105	Thread t = new Thread(new CheckedInterruptedRunnable() {
106	public void realRun() throws InterruptedException {
107	threadAssertTrue(l.getCount() > 0);
108	l.await();
109	}});
110
111	t.start();
112	assertEquals(l.getCount(), 1);
113	t.interrupt();
114	t.join();
115	}
116
117	/**
118	* timed await throws IE if interrupted before counted down
119	*/
120	public void testTimedAwait_InterruptedException() throws InterruptedException {
121	final CountDownLatch l = new CountDownLatch(1);
122	Thread t = new Thread(new CheckedInterruptedRunnable() {
123	public void realRun() throws InterruptedException {
124	threadAssertTrue(l.getCount() > 0);
125	l.await(MEDIUM_DELAY_MS, MILLISECONDS);
126	}});
127
128	t.start();
129	Thread.sleep(SHORT_DELAY_MS);
130	assertEquals(l.getCount(), 1);
131	t.interrupt();
132	t.join();
133	}
134
135	/**
136	* timed await times out if not counted down before timeout
137	*/
138	public void testAwaitTimeout() throws InterruptedException {
139	final CountDownLatch l = new CountDownLatch(1);
140	Thread t = new Thread(new CheckedRunnable() {
141	public void realRun() throws InterruptedException {
142	threadAssertTrue(l.getCount() > 0);
143	threadAssertFalse(l.await(SHORT_DELAY_MS, MILLISECONDS));
144	threadAssertTrue(l.getCount() > 0);
145	}});
146
147	t.start();
148	assertEquals(l.getCount(), 1);
149	t.join();
150	}
151
152	/**
153	* toString indicates current count
154	*/
155	public void testToString() {
156	CountDownLatch s = new CountDownLatch(2);
157	String us = s.toString();
158	assertTrue(us.indexOf("Count = 2") >= 0);
159	s.countDown();
160	String s1 = s.toString();
161	assertTrue(s1.indexOf("Count = 1") >= 0);
162	s.countDown();
163	String s2 = s.toString();
164	assertTrue(s2.indexOf("Count = 0") >= 0);
165	}
166
167	}