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 java.util.concurrent.ThreadLocalRandom;

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 IllegalArgumentException
     */
    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());
        if (randomBoolean()) 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());
        if (randomBoolean()) 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);
        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
        t.interrupt();
        awaitTermination(t);
    }

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

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

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

        await(pleaseInterrupt);
        if (randomBoolean()) 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());

                long startTime = System.nanoTime();
                assertFalse(l.await(timeoutMillis(), MILLISECONDS));
                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());

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