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/publicdomain/zero/1.0/
 * Other contributors include Andrew Wright, Jeffrey Hayes,
 * Pat Fisher, Mike Judd.
 */

import static java.util.concurrent.TimeUnit.MILLISECONDS;

import java.util.concurrent.CountDownLatch;

import junit.framework.Test;
import junit.framework.TestSuite;

public class CountDownLatchTest extends JSR166TestCase {
    public static void main(String[] args) {
        main(suite(), args);
    }
    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() {
        final CountDownLatch l = new CountDownLatch(2);
        final CountDownLatch pleaseCountDown = new CountDownLatch(1);

        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                assertEquals(2, l.getCount());
                pleaseCountDown.countDown();
                l.await();
                assertEquals(0, l.getCount());
            }});

        await(pleaseCountDown);
        assertEquals(2, l.getCount());
        l.countDown();
        assertEquals(1, l.getCount());
        assertThreadBlocks(t, Thread.State.WAITING);
        l.countDown();
        assertEquals(0, l.getCount());
        awaitTermination(t);
    }

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

        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                assertEquals(2, l.getCount());
                pleaseCountDown.countDown();
                assertTrue(l.await(LONG_DELAY_MS, MILLISECONDS));
                assertEquals(0, l.getCount());
            }});

        await(pleaseCountDown);
        assertEquals(2, l.getCount());
        l.countDown();
        assertEquals(1, l.getCount());
        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
        l.countDown();
        assertEquals(0, l.getCount());
        awaitTermination(t);
    }

    /**
     * await throws InterruptedException if interrupted before counted down
     */
    public void testAwait_Interruptible() {
        final CountDownLatch l = new CountDownLatch(1);
        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                Thread.currentThread().interrupt();
                try {
                    l.await();
                    shouldThrow();
                } catch (InterruptedException success) {}
                assertFalse(Thread.interrupted());

                pleaseInterrupt.countDown();
                try {
                    l.await();
                    shouldThrow();
                } catch (InterruptedException success) {}
                assertFalse(Thread.interrupted());

                assertEquals(1, l.getCount());
            }});

        await(pleaseInterrupt);
        assertThreadBlocks(t, Thread.State.WAITING);
        t.interrupt();
        awaitTermination(t);
    }

    /**
     * timed await throws InterruptedException if interrupted before counted down
     */
    public void testTimedAwait_Interruptible() {
        final CountDownLatch l = new CountDownLatch(1);
        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                Thread.currentThread().interrupt();
                try {
                    l.await(LONG_DELAY_MS, MILLISECONDS);
                    shouldThrow();
                } catch (InterruptedException success) {}
                assertFalse(Thread.interrupted());

                pleaseInterrupt.countDown();
                try {
                    l.await(LONG_DELAY_MS, MILLISECONDS);
                    shouldThrow();
                } catch (InterruptedException success) {}
                assertFalse(Thread.interrupted());

                assertEquals(1, l.getCount());
            }});

        await(pleaseInterrupt);
        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
        t.interrupt();
        awaitTermination(t);
    }

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

        awaitTermination(t);
        assertEquals(1, l.getCount());
    }

    /**
     * toString indicates current count
     */
    public void testToString() {
        CountDownLatch s = new CountDownLatch(2);
        assertTrue(s.toString().contains("Count = 2"));
        s.countDown();
        assertTrue(s.toString().contains("Count = 1"));
        s.countDown();
        assertTrue(s.toString().contains("Count = 0"));
    }

}
Revision:	1.25
Committed:	Sun May 14 01:37:52 2017 UTC (7 years ago) by jsr166
Branch:	MAIN
Changes since 1.24:	+2 -2 lines
Log Message:	improve test descriptions
#	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/publicdomain/zero/1.0/
5	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	* Pat Fisher, Mike Judd.
7	*/
8
9	import static java.util.concurrent.TimeUnit.MILLISECONDS;
10
11	import java.util.concurrent.CountDownLatch;
12
13	import junit.framework.Test;
14	import junit.framework.TestSuite;
15
16	public class CountDownLatchTest extends JSR166TestCase {
17	public static void main(String[] args) {
18	main(suite(), args);
19	}
20	public static Test suite() {
21	return new TestSuite(CountDownLatchTest.class);
22	}
23
24	/**
25	* negative constructor argument throws IAE
26	*/
27	public void testConstructor() {
28	try {
29	new CountDownLatch(-1);
30	shouldThrow();
31	} catch (IllegalArgumentException success) {}
32	}
33
34	/**
35	* getCount returns initial count and decreases after countDown
36	*/
37	public void testGetCount() {
38	final CountDownLatch l = new CountDownLatch(2);
39	assertEquals(2, l.getCount());
40	l.countDown();
41	assertEquals(1, l.getCount());
42	}
43
44	/**
45	* countDown decrements count when positive and has no effect when zero
46	*/
47	public void testCountDown() {
48	final CountDownLatch l = new CountDownLatch(1);
49	assertEquals(1, l.getCount());
50	l.countDown();
51	assertEquals(0, l.getCount());
52	l.countDown();
53	assertEquals(0, l.getCount());
54	}
55
56	/**
57	* await returns after countDown to zero, but not before
58	*/
59	public void testAwait() {
60	final CountDownLatch l = new CountDownLatch(2);
61	final CountDownLatch pleaseCountDown = new CountDownLatch(1);
62
63	Thread t = newStartedThread(new CheckedRunnable() {
64	public void realRun() throws InterruptedException {
65	assertEquals(2, l.getCount());
66	pleaseCountDown.countDown();
67	l.await();
68	assertEquals(0, l.getCount());
69	}});
70
71	await(pleaseCountDown);
72	assertEquals(2, l.getCount());
73	l.countDown();
74	assertEquals(1, l.getCount());
75	assertThreadBlocks(t, Thread.State.WAITING);
76	l.countDown();
77	assertEquals(0, l.getCount());
78	awaitTermination(t);
79	}
80
81	/**
82	* timed await returns after countDown to zero
83	*/
84	public void testTimedAwait() {
85	final CountDownLatch l = new CountDownLatch(2);
86	final CountDownLatch pleaseCountDown = new CountDownLatch(1);
87
88	Thread t = newStartedThread(new CheckedRunnable() {
89	public void realRun() throws InterruptedException {
90	assertEquals(2, l.getCount());
91	pleaseCountDown.countDown();
92	assertTrue(l.await(LONG_DELAY_MS, MILLISECONDS));
93	assertEquals(0, l.getCount());
94	}});
95
96	await(pleaseCountDown);
97	assertEquals(2, l.getCount());
98	l.countDown();
99	assertEquals(1, l.getCount());
100	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
101	l.countDown();
102	assertEquals(0, l.getCount());
103	awaitTermination(t);
104	}
105
106	/**
107	* await throws InterruptedException if interrupted before counted down
108	*/
109	public void testAwait_Interruptible() {
110	final CountDownLatch l = new CountDownLatch(1);
111	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
112	Thread t = newStartedThread(new CheckedRunnable() {
113	public void realRun() throws InterruptedException {
114	Thread.currentThread().interrupt();
115	try {
116	l.await();
117	shouldThrow();
118	} catch (InterruptedException success) {}
119	assertFalse(Thread.interrupted());
120
121	pleaseInterrupt.countDown();
122	try {
123	l.await();
124	shouldThrow();
125	} catch (InterruptedException success) {}
126	assertFalse(Thread.interrupted());
127
128	assertEquals(1, l.getCount());
129	}});
130
131	await(pleaseInterrupt);
132	assertThreadBlocks(t, Thread.State.WAITING);
133	t.interrupt();
134	awaitTermination(t);
135	}
136
137	/**
138	* timed await throws InterruptedException if interrupted before counted down
139	*/
140	public void testTimedAwait_Interruptible() {
141	final CountDownLatch l = new CountDownLatch(1);
142	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
143	Thread t = newStartedThread(new CheckedRunnable() {
144	public void realRun() throws InterruptedException {
145	Thread.currentThread().interrupt();
146	try {
147	l.await(LONG_DELAY_MS, MILLISECONDS);
148	shouldThrow();
149	} catch (InterruptedException success) {}
150	assertFalse(Thread.interrupted());
151
152	pleaseInterrupt.countDown();
153	try {
154	l.await(LONG_DELAY_MS, MILLISECONDS);
155	shouldThrow();
156	} catch (InterruptedException success) {}
157	assertFalse(Thread.interrupted());
158
159	assertEquals(1, l.getCount());
160	}});
161
162	await(pleaseInterrupt);
163	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
164	t.interrupt();
165	awaitTermination(t);
166	}
167
168	/**
169	* timed await times out if not counted down before timeout
170	*/
171	public void testAwaitTimeout() throws InterruptedException {
172	final CountDownLatch l = new CountDownLatch(1);
173	Thread t = newStartedThread(new CheckedRunnable() {
174	public void realRun() throws InterruptedException {
175	assertEquals(1, l.getCount());
176	assertFalse(l.await(timeoutMillis(), MILLISECONDS));
177	assertEquals(1, l.getCount());
178	}});
179
180	awaitTermination(t);
181	assertEquals(1, l.getCount());
182	}
183
184	/**
185	* toString indicates current count
186	*/
187	public void testToString() {
188	CountDownLatch s = new CountDownLatch(2);
189	assertTrue(s.toString().contains("Count = 2"));
190	s.countDown();
191	assertTrue(s.toString().contains("Count = 1"));
192	s.countDown();
193	assertTrue(s.toString().contains("Count = 0"));
194	}
195
196	}