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){
                        threadUnexpectedException();
                    }
                }
            });
        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){
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t1.start();
            t2.start();
            t1.join();
            t2.join();
        } catch(InterruptedException ex) {
            unexpectedException();
        }
    }

    /**
     *
     */
    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){
                        threadUnexpectedException();
                    } catch(TimeoutException toe) {
                        threadUnexpectedException();
                    }
                }
            });
        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){
                        threadUnexpectedException();
                    } catch(TimeoutException toe) {
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t1.start();
            t2.start();
            t1.join();
            t2.join();
        } catch(InterruptedException ex) {
            unexpectedException();
        }
    }

    /**
     *
     */
    public void testExchange_InterruptedException(){
        final Exchanger e = new Exchanger();
        Thread t = new Thread(new Runnable() {
                public void run(){
                    try {
                        e.exchange(one);
                        threadShouldThrow();
                    } catch(InterruptedException success){
                    }
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(InterruptedException ex) {
            unexpectedException();
        }
    }

    /**
     *
     */
    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);
                        threadShouldThrow();
                    } catch(InterruptedException success){
                    } catch(Exception e2){
                        threadFail("should throw IE");
                    }
                }
            });
        try {
            t.start();
            t.interrupt();
            t.join();
        } catch(InterruptedException ex){
            unexpectedException();
        }
    }

    /**
     *
     */
    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);
                        threadShouldThrow();
                    } catch(TimeoutException success){
                    } catch(InterruptedException e2){
                        threadFail("should throw TOE");
                    }
                }
            });
        try {
            t.start();
            t.join();
        } catch(InterruptedException ex){
            unexpectedException();
        }
    }
}
Revision:	1.3
Committed:	Sat Sep 20 18:20:07 2003 UTC (20 years, 8 months ago) by dl
Branch:	MAIN
Changes since 1.2:	+29 -14 lines
Log Message:	Documentation scaffolding
#	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	/**
22	*
23	*/
24	public void testExchange() {
25	final Exchanger e = new Exchanger();
26	Thread t1 = new Thread(new Runnable(){
27	public void run(){
28	try {
29	Object v = e.exchange(one);
30	threadAssertEquals(v, two);
31	Object w = e.exchange(v);
32	threadAssertEquals(w, one);
33	} catch(InterruptedException e){
34	threadUnexpectedException();
35	}
36	}
37	});
38	Thread t2 = new Thread(new Runnable(){
39	public void run(){
40	try {
41	Object v = e.exchange(two);
42	threadAssertEquals(v, one);
43	Object w = e.exchange(v);
44	threadAssertEquals(w, two);
45	} catch(InterruptedException e){
46	threadUnexpectedException();
47	}
48	}
49	});
50	try {
51	t1.start();
52	t2.start();
53	t1.join();
54	t2.join();
55	} catch(InterruptedException ex) {
56	unexpectedException();
57	}
58	}
59
60	/**
61	*
62	*/
63	public void testTimedExchange() {
64	final Exchanger e = new Exchanger();
65	Thread t1 = new Thread(new Runnable(){
66	public void run(){
67	try {
68	Object v = e.exchange(one, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
69	threadAssertEquals(v, two);
70	Object w = e.exchange(v, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
71	threadAssertEquals(w, one);
72	} catch(InterruptedException e){
73	threadUnexpectedException();
74	} catch(TimeoutException toe) {
75	threadUnexpectedException();
76	}
77	}
78	});
79	Thread t2 = new Thread(new Runnable(){
80	public void run(){
81	try {
82	Object v = e.exchange(two, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
83	threadAssertEquals(v, one);
84	Object w = e.exchange(v, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
85	threadAssertEquals(w, two);
86	} catch(InterruptedException e){
87	threadUnexpectedException();
88	} catch(TimeoutException toe) {
89	threadUnexpectedException();
90	}
91	}
92	});
93	try {
94	t1.start();
95	t2.start();
96	t1.join();
97	t2.join();
98	} catch(InterruptedException ex) {
99	unexpectedException();
100	}
101	}
102
103	/**
104	*
105	*/
106	public void testExchange_InterruptedException(){
107	final Exchanger e = new Exchanger();
108	Thread t = new Thread(new Runnable() {
109	public void run(){
110	try {
111	e.exchange(one);
112	threadShouldThrow();
113	} catch(InterruptedException success){
114	}
115	}
116	});
117	try {
118	t.start();
119	Thread.sleep(SHORT_DELAY_MS);
120	t.interrupt();
121	t.join();
122	} catch(InterruptedException ex) {
123	unexpectedException();
124	}
125	}
126
127	/**
128	*
129	*/
130	public void testTimedExchange_InterruptedException(){
131	final Exchanger e = new Exchanger();
132	Thread t = new Thread(new Runnable() {
133	public void run(){
134	try {
135	e.exchange(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
136	threadShouldThrow();
137	} catch(InterruptedException success){
138	} catch(Exception e2){
139	threadFail("should throw IE");
140	}
141	}
142	});
143	try {
144	t.start();
145	t.interrupt();
146	t.join();
147	} catch(InterruptedException ex){
148	unexpectedException();
149	}
150	}
151
152	/**
153	*
154	*/
155	public void testExchange_TimeOutException(){
156	final Exchanger e = new Exchanger();
157	Thread t = new Thread(new Runnable() {
158	public void run(){
159	try {
160	e.exchange(null, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
161	threadShouldThrow();
162	} catch(TimeoutException success){
163	} catch(InterruptedException e2){
164	threadFail("should throw TOE");
165	}
166	}
167	});
168	try {
169	t.start();
170	t.join();
171	} catch(InterruptedException ex){
172	unexpectedException();
173	}
174	}
175	}