test/tck/CyclicBarrierTest.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.*;
import java.util.concurrent.*;

public class CyclicBarrierTest extends JSR166TestCase{
    
    public static void main(String[] args) {
        junit.textui.TestRunner.run (suite());  
    }
    
    
    public static Test suite() {
        return new TestSuite(CyclicBarrierTest.class);
    }
    
    public void testConstructor1(){
        try{
            new CyclicBarrier(-1, (Runnable)null);
            fail("should throw");
        } catch(IllegalArgumentException e){}
    }

    public void testConstructor2(){
        try{
            new CyclicBarrier(-1);
            fail("should throw");
        } catch(IllegalArgumentException e){}
    }

    public void testConstructor3(){
        CyclicBarrier b = new CyclicBarrier(2);
        assertEquals(2, b.getParties());
        assertEquals(0, b.getNumberWaiting());
    }

    public void testSingleParty() {
        try {
            CyclicBarrier b = new CyclicBarrier(1);
            assertEquals(1, b.getParties());
            assertEquals(0, b.getNumberWaiting());
            b.await();
            b.await();
            assertEquals(0, b.getNumberWaiting());
        }
        catch(Exception e) {
            fail("unexpected exception");
        }
    }
    
    private volatile int countAction;
    private class MyAction implements Runnable {
        public void run() { ++countAction; }
    }

    public void testBarrierAction() {
        try {
            countAction = 0;
            CyclicBarrier b = new CyclicBarrier(1, new MyAction());
            assertEquals(1, b.getParties());
            assertEquals(0, b.getNumberWaiting());
            b.await();
            b.await();
            assertEquals(0, b.getNumberWaiting());
            assertEquals(countAction, 2);
        }
        catch(Exception e) {
            fail("unexpected exception");
        }
    }


    public void testTwoParties(){
        final CyclicBarrier b = new CyclicBarrier(2);
        Thread t = new Thread(new Runnable() {
                public void run(){
                    try {
                        b.await();
                        b.await();
                        b.await();
                        b.await();
                    } catch(Exception e){
                        threadFail("unexpected exception");
                    }}});

        try {
            t.start();
            b.await();
            b.await();
            b.await();
            b.await();
            t.join();
        } catch(Exception e){
            fail("unexpected exception");
        }
    }


    public void testAwait1_Interrupted_BrokenBarrier(){
        final CyclicBarrier c = new CyclicBarrier(3);
        Thread t1 = new Thread(new Runnable() {
                public void run(){
                    try{
                        c.await();
                        threadFail("should throw");
                    } catch(InterruptedException success){}                
                    catch(Exception b){
                        threadFail("should throw IE");
                    }
                }
            });
        Thread t2 = new Thread(new Runnable(){
                public void run(){
                    try{
                        c.await();
                        threadFail("should throw");                        
                    } catch(BrokenBarrierException success){
                    } catch(Exception i){
                        threadFail("should throw BBE");
                    }
                }
            });
        try {
            t1.start();
            t2.start();
            Thread.sleep(SHORT_DELAY_MS);
            t1.interrupt();
            t1.join(); 
            t2.join();
        } catch(InterruptedException e){
            fail("unexpected exception");
        }
    }

    public void testAwait2_Interrupted_BrokenBarrier(){
      final CyclicBarrier c = new CyclicBarrier(3);
        Thread t1 = new Thread(new Runnable() {
                public void run(){
                    try{
                        c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadFail("should throw");
                    } catch(InterruptedException success){
                    } catch(Exception b){
                        threadFail("should throw IE");
                    }
                }
            });
        Thread t2 = new Thread(new Runnable(){
                public void run(){
                    try{
                        c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadFail("should throw");                        
                    } catch(BrokenBarrierException success){
                    } catch(Exception i){
                        threadFail("should throw BBE");
                    }
                }
            });
        try {
            t1.start();
            t2.start();
            Thread.sleep(SHORT_DELAY_MS);
            t1.interrupt();
            t1.join(); 
            t2.join();
        } catch(InterruptedException e){
            fail("unexpected exception");
        }
    }
    
    public void testAwait3_TimeOutException(){
        final CyclicBarrier c = new CyclicBarrier(2);
        Thread t = new Thread(new Runnable() {
                public void run(){
                    try{
                        c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadFail("should throw");
                    } catch(TimeoutException success){
                    } catch(Exception b){
                        threadFail("should throw TOE");
                        
                    }
                }
            });
        try {
            t.start();
            t.join(); 
        } catch(InterruptedException e){
            fail("unexpected exception");
        }
    }
    
}
Revision:	1.2
Committed:	Sun Sep 14 20:42:40 2003 UTC (20 years, 8 months ago) by dl
Branch:	MAIN
Changes since 1.1:	+12 -16 lines
Log Message:	New base class JSR166TestCase
#	User	Rev	Content
1	dl	1.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.*;
10			import java.util.concurrent.*;
11
12	dl	1.2	public class CyclicBarrierTest extends JSR166TestCase{
13	dl	1.1
14			public static void main(String[] args) {
15			junit.textui.TestRunner.run (suite());
16			}
17
18
19			public static Test suite() {
20			return new TestSuite(CyclicBarrierTest.class);
21			}
22
23			public void testConstructor1(){
24			try{
25			new CyclicBarrier(-1, (Runnable)null);
26			fail("should throw");
27			} catch(IllegalArgumentException e){}
28			}
29
30			public void testConstructor2(){
31			try{
32			new CyclicBarrier(-1);
33			fail("should throw");
34			} catch(IllegalArgumentException e){}
35			}
36
37			public void testConstructor3(){
38			CyclicBarrier b = new CyclicBarrier(2);
39			assertEquals(2, b.getParties());
40			assertEquals(0, b.getNumberWaiting());
41			}
42
43			public void testSingleParty() {
44			try {
45			CyclicBarrier b = new CyclicBarrier(1);
46			assertEquals(1, b.getParties());
47			assertEquals(0, b.getNumberWaiting());
48			b.await();
49			b.await();
50			assertEquals(0, b.getNumberWaiting());
51			}
52			catch(Exception e) {
53			fail("unexpected exception");
54			}
55			}
56
57			private volatile int countAction;
58			private class MyAction implements Runnable {
59			public void run() { ++countAction; }
60			}
61
62			public void testBarrierAction() {
63			try {
64			countAction = 0;
65			CyclicBarrier b = new CyclicBarrier(1, new MyAction());
66			assertEquals(1, b.getParties());
67			assertEquals(0, b.getNumberWaiting());
68			b.await();
69			b.await();
70			assertEquals(0, b.getNumberWaiting());
71			assertEquals(countAction, 2);
72			}
73			catch(Exception e) {
74			fail("unexpected exception");
75			}
76			}
77
78
79			public void testTwoParties(){
80			final CyclicBarrier b = new CyclicBarrier(2);
81			Thread t = new Thread(new Runnable() {
82			public void run(){
83			try {
84			b.await();
85			b.await();
86			b.await();
87			b.await();
88			} catch(Exception e){
89	dl	1.2	threadFail("unexpected exception");
90	dl	1.1	}}});
91
92			try {
93			t.start();
94			b.await();
95			b.await();
96			b.await();
97			b.await();
98			t.join();
99			} catch(Exception e){
100			fail("unexpected exception");
101			}
102			}
103
104
105			public void testAwait1_Interrupted_BrokenBarrier(){
106			final CyclicBarrier c = new CyclicBarrier(3);
107			Thread t1 = new Thread(new Runnable() {
108			public void run(){
109			try{
110			c.await();
111	dl	1.2	threadFail("should throw");
112	dl	1.1	} catch(InterruptedException success){}
113			catch(Exception b){
114	dl	1.2	threadFail("should throw IE");
115	dl	1.1	}
116			}
117			});
118			Thread t2 = new Thread(new Runnable(){
119			public void run(){
120			try{
121			c.await();
122	dl	1.2	threadFail("should throw");
123	dl	1.1	} catch(BrokenBarrierException success){
124			} catch(Exception i){
125	dl	1.2	threadFail("should throw BBE");
126	dl	1.1	}
127			}
128			});
129			try {
130			t1.start();
131			t2.start();
132			Thread.sleep(SHORT_DELAY_MS);
133			t1.interrupt();
134			t1.join();
135			t2.join();
136			} catch(InterruptedException e){
137			fail("unexpected exception");
138			}
139			}
140
141			public void testAwait2_Interrupted_BrokenBarrier(){
142			final CyclicBarrier c = new CyclicBarrier(3);
143			Thread t1 = new Thread(new Runnable() {
144			public void run(){
145			try{
146			c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
147	dl	1.2	threadFail("should throw");
148	dl	1.1	} catch(InterruptedException success){
149			} catch(Exception b){
150	dl	1.2	threadFail("should throw IE");
151	dl	1.1	}
152			}
153			});
154			Thread t2 = new Thread(new Runnable(){
155			public void run(){
156			try{
157			c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
158	dl	1.2	threadFail("should throw");
159	dl	1.1	} catch(BrokenBarrierException success){
160			} catch(Exception i){
161	dl	1.2	threadFail("should throw BBE");
162	dl	1.1	}
163			}
164			});
165			try {
166			t1.start();
167			t2.start();
168			Thread.sleep(SHORT_DELAY_MS);
169			t1.interrupt();
170			t1.join();
171			t2.join();
172			} catch(InterruptedException e){
173			fail("unexpected exception");
174			}
175			}
176
177			public void testAwait3_TimeOutException(){
178			final CyclicBarrier c = new CyclicBarrier(2);
179			Thread t = new Thread(new Runnable() {
180			public void run(){
181			try{
182			c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
183	dl	1.2	threadFail("should throw");
184	dl	1.1	} catch(TimeoutException success){
185			} catch(Exception b){
186	dl	1.2	threadFail("should throw TOE");
187	dl	1.1
188			}
189			}
190			});
191			try {
192			t.start();
193			t.join();
194			} catch(InterruptedException e){
195			fail("unexpected exception");
196			}
197			}
198
199			}