test/tck/ExchangerTest.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 ExchangerTest extends JSR166TestCase {
   
    public static void main(String[] args) {
        junit.textui.TestRunner.run (suite());  
    }
    public static Test suite() {
        return new TestSuite(ExchangerTest.class);
    }

    public void testExchange() {
        final Exchanger e = new Exchanger();
        Thread t1 = new Thread(new Runnable(){
                public void run(){
                    try {
                        Object v = e.exchange(one);
                        threadAssertEquals(v, two);
                        Object w = e.exchange(v);
                        threadAssertEquals(w, one);
                    } catch(InterruptedException e){
                        threadFail("unexpected exception");
                    }
                }
            });
        Thread t2 = new Thread(new Runnable(){
                public void run(){
                    try {
                        Object v = e.exchange(two);
                        threadAssertEquals(v, one);
                        Object w = e.exchange(v);
                        threadAssertEquals(w, two);
                    } catch(InterruptedException e){
                        threadFail("unexpected exception");
                    }
                }
            });
        try {
            t1.start();
            t2.start();
            t1.join();
            t2.join();
        } catch(InterruptedException ex) {
            fail("unexpected exception");
        }
    }

    public void testTimedExchange() {
        final Exchanger e = new Exchanger();
        Thread t1 = new Thread(new Runnable(){
                public void run(){
                    try {
                        Object v = e.exchange(one, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadAssertEquals(v, two);
                        Object w = e.exchange(v, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadAssertEquals(w, one);
                    } catch(InterruptedException e){
                        threadFail("unexpected exception");
                    } catch(TimeoutException toe) {
                        threadFail("unexpected exception");
                    }
                }
            });
        Thread t2 = new Thread(new Runnable(){
                public void run(){
                    try {
                        Object v = e.exchange(two, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadAssertEquals(v, one);
                        Object w = e.exchange(v, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadAssertEquals(w, two);
                    } catch(InterruptedException e){
                        threadFail("unexpected exception");
                    } catch(TimeoutException toe) {
                        threadFail("unexpected exception");
                    }
                }
            });
        try {
            t1.start();
            t2.start();
            t1.join();
            t2.join();
        } catch(InterruptedException ex) {
            fail("unexpected exception");
        }
    }

    public void testExchange_InterruptedException(){
        final Exchanger e = new Exchanger();
        Thread t = new Thread(new Runnable() {
                public void run(){
                    try {
                        e.exchange(one);
                        threadFail("should throw");
                    } catch(InterruptedException success){
                    }
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(InterruptedException ex) {
            fail("unexpected exception");
        }
    }

    public void testTimedExchange_InterruptedException(){
        final Exchanger e = new Exchanger();
        Thread t = new Thread(new Runnable() {
                public void run(){
                    try {
                        e.exchange(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadFail("should throw");
                    } catch(InterruptedException success){
                    } catch(Exception e2){
                        threadFail("should throw IE");
                    }
                }
            });
        try {
            t.start();
            t.interrupt();
            t.join();
        } catch(InterruptedException ex){
            fail("unexpected exception");
        }
    }

    public void testExchange_TimeOutException(){
        final Exchanger e = new Exchanger();
        Thread t = new Thread(new Runnable() {
                public void run(){
                    try {
                        e.exchange(null, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadFail("should throw");
                    } catch(TimeoutException success){
                    } catch(InterruptedException e2){
                        threadFail("should throw TOE");
                    }
                }
            });
        try {
            t.start();
            t.join();
        } catch(InterruptedException ex){
            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:	+69 -36 lines
Log Message:	New base class JSR166TestCase
#	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.*;
10	import java.util.concurrent.*;
11
12	public class ExchangerTest extends JSR166TestCase {
13
14	public static void main(String[] args) {
15	junit.textui.TestRunner.run (suite());
16	}
17	public static Test suite() {
18	return new TestSuite(ExchangerTest.class);
19	}
20
21	public void testExchange() {
22	final Exchanger e = new Exchanger();
23	Thread t1 = new Thread(new Runnable(){
24	public void run(){
25	try {
26	Object v = e.exchange(one);
27	threadAssertEquals(v, two);
28	Object w = e.exchange(v);
29	threadAssertEquals(w, one);
30	} catch(InterruptedException e){
31	threadFail("unexpected exception");
32	}
33	}
34	});
35	Thread t2 = new Thread(new Runnable(){
36	public void run(){
37	try {
38	Object v = e.exchange(two);
39	threadAssertEquals(v, one);
40	Object w = e.exchange(v);
41	threadAssertEquals(w, two);
42	} catch(InterruptedException e){
43	threadFail("unexpected exception");
44	}
45	}
46	});
47	try {
48	t1.start();
49	t2.start();
50	t1.join();
51	t2.join();
52	} catch(InterruptedException ex) {
53	fail("unexpected exception");
54	}
55	}
56
57	public void testTimedExchange() {
58	final Exchanger e = new Exchanger();
59	Thread t1 = new Thread(new Runnable(){
60	public void run(){
61	try {
62	Object v = e.exchange(one, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
63	threadAssertEquals(v, two);
64	Object w = e.exchange(v, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
65	threadAssertEquals(w, one);
66	} catch(InterruptedException e){
67	threadFail("unexpected exception");
68	} catch(TimeoutException toe) {
69	threadFail("unexpected exception");
70	}
71	}
72	});
73	Thread t2 = new Thread(new Runnable(){
74	public void run(){
75	try {
76	Object v = e.exchange(two, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
77	threadAssertEquals(v, one);
78	Object w = e.exchange(v, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
79	threadAssertEquals(w, two);
80	} catch(InterruptedException e){
81	threadFail("unexpected exception");
82	} catch(TimeoutException toe) {
83	threadFail("unexpected exception");
84	}
85	}
86	});
87	try {
88	t1.start();
89	t2.start();
90	t1.join();
91	t2.join();
92	} catch(InterruptedException ex) {
93	fail("unexpected exception");
94	}
95	}
96
97	public void testExchange_InterruptedException(){
98	final Exchanger e = new Exchanger();
99	Thread t = new Thread(new Runnable() {
100	public void run(){
101	try {
102	e.exchange(one);
103	threadFail("should throw");
104	} catch(InterruptedException success){
105	}
106	}
107	});
108	try {
109	t.start();
110	Thread.sleep(SHORT_DELAY_MS);
111	t.interrupt();
112	t.join();
113	} catch(InterruptedException ex) {
114	fail("unexpected exception");
115	}
116	}
117
118	public void testTimedExchange_InterruptedException(){
119	final Exchanger e = new Exchanger();
120	Thread t = new Thread(new Runnable() {
121	public void run(){
122	try {
123	e.exchange(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
124	threadFail("should throw");
125	} catch(InterruptedException success){
126	} catch(Exception e2){
127	threadFail("should throw IE");
128	}
129	}
130	});
131	try {
132	t.start();
133	t.interrupt();
134	t.join();
135	} catch(InterruptedException ex){
136	fail("unexpected exception");
137	}
138	}
139
140	public void testExchange_TimeOutException(){
141	final Exchanger e = new Exchanger();
142	Thread t = new Thread(new Runnable() {
143	public void run(){
144	try {
145	e.exchange(null, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
146	threadFail("should throw");
147	} catch(TimeoutException success){
148	} catch(InterruptedException e2){
149	threadFail("should throw TOE");
150	}
151	}
152	});
153	try {
154	t.start();
155	t.join();
156	} catch(InterruptedException ex){
157	fail("unexpected exception");
158	}
159	}
160	}