1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package org.apache.mina.common.support;
21
22 import java.io.IOException;
23 import java.net.SocketAddress;
24
25 import junit.framework.TestCase;
26
27 import org.apache.mina.common.IoFilterChain;
28 import org.apache.mina.common.IoFuture;
29 import org.apache.mina.common.IoFutureListener;
30 import org.apache.mina.common.IoHandler;
31 import org.apache.mina.common.IoService;
32 import org.apache.mina.common.IoServiceConfig;
33 import org.apache.mina.common.IoSession;
34 import org.apache.mina.common.IoSessionConfig;
35 import org.apache.mina.common.TransportType;
36
37
38
39
40
41
42
43 public class FutureTest extends TestCase {
44
45 public void testCloseFuture() throws Exception {
46 DefaultCloseFuture future = new DefaultCloseFuture(null);
47 assertFalse(future.isReady());
48 assertFalse(future.isClosed());
49
50 TestThread thread = new TestThread(future);
51 thread.start();
52
53 future.setClosed();
54 thread.join();
55
56 assertTrue(thread.success);
57 assertTrue(future.isReady());
58 assertTrue(future.isClosed());
59 }
60
61 public void testConnectFuture() throws Exception {
62 DefaultConnectFuture future = new DefaultConnectFuture();
63 assertFalse(future.isReady());
64 assertFalse(future.isConnected());
65 assertNull(future.getSession());
66
67 TestThread thread = new TestThread(future);
68 thread.start();
69
70 IoSession session = new BaseIoSession() {
71 public IoHandler getHandler() {
72 return null;
73 }
74
75 public IoFilterChain getFilterChain() {
76 return null;
77 }
78
79 public TransportType getTransportType() {
80 return null;
81 }
82
83 public SocketAddress getRemoteAddress() {
84 return null;
85 }
86
87 public SocketAddress getLocalAddress() {
88 return null;
89 }
90
91 public int getScheduledWriteRequests() {
92 return 0;
93 }
94
95 protected void updateTrafficMask() {
96 }
97
98 public boolean isClosing() {
99 return false;
100 }
101
102 public IoService getService() {
103 return null;
104 }
105
106 public IoSessionConfig getConfig() {
107 return null;
108 }
109
110 public SocketAddress getServiceAddress() {
111 return null;
112 }
113
114 public int getScheduledWriteBytes() {
115 return 0;
116 }
117
118 public IoServiceConfig getServiceConfig() {
119 return null;
120 }
121 };
122
123 future.setSession(session);
124 thread.join();
125
126 assertTrue(thread.success);
127 assertTrue(future.isReady());
128 assertTrue(future.isConnected());
129 assertEquals(session, future.getSession());
130
131 future = new DefaultConnectFuture();
132 thread = new TestThread(future);
133 thread.start();
134 future.setException(new IOException());
135 thread.join();
136
137 assertTrue(thread.success);
138 assertTrue(future.isReady());
139 assertFalse(future.isConnected());
140
141 try {
142 future.getSession();
143 fail("IOException should be thrown.");
144 } catch (Exception e) {
145 }
146 }
147
148 public void testWriteFuture() throws Exception {
149 DefaultWriteFuture future = new DefaultWriteFuture(null);
150 assertFalse(future.isReady());
151 assertFalse(future.isWritten());
152
153 TestThread thread = new TestThread(future);
154 thread.start();
155
156 future.setWritten(true);
157 thread.join();
158
159 assertTrue(thread.success);
160 assertTrue(future.isReady());
161 assertTrue(future.isWritten());
162
163 future = new DefaultWriteFuture(null);
164 thread = new TestThread(future);
165 thread.start();
166
167 future.setWritten(false);
168 thread.join();
169
170 assertTrue(thread.success);
171 assertTrue(future.isReady());
172 assertFalse(future.isWritten());
173 }
174
175 public void testAddListener() throws Exception {
176 DefaultCloseFuture future = new DefaultCloseFuture(null);
177 assertFalse(future.isReady());
178 assertFalse(future.isClosed());
179
180 TestListener listener1 = new TestListener();
181 TestListener listener2 = new TestListener();
182 future.addListener(listener1);
183 future.addListener(listener2);
184
185 TestThread thread = new TestThread(future);
186 thread.start();
187
188 future.setClosed();
189 thread.join();
190
191 assertTrue(thread.success);
192 assertTrue(future.isReady());
193 assertTrue(future.isClosed());
194
195 assertSame(future, listener1.notifiedFuture);
196 assertSame(future, listener2.notifiedFuture);
197 }
198
199 public void testLateAddListener() throws Exception {
200 DefaultCloseFuture future = new DefaultCloseFuture(null);
201 assertFalse(future.isReady());
202 assertFalse(future.isClosed());
203
204 TestThread thread = new TestThread(future);
205 thread.start();
206
207 future.setClosed();
208 thread.join();
209
210 assertTrue(thread.success);
211 assertTrue(future.isReady());
212 assertTrue(future.isClosed());
213
214 TestListener listener = new TestListener();
215 future.addListener(listener);
216 assertSame(future, listener.notifiedFuture);
217 }
218
219 public void testRemoveListener1() throws Exception {
220 DefaultCloseFuture future = new DefaultCloseFuture(null);
221 assertFalse(future.isReady());
222 assertFalse(future.isClosed());
223
224 TestListener listener1 = new TestListener();
225 TestListener listener2 = new TestListener();
226 future.addListener(listener1);
227 future.addListener(listener2);
228 future.removeListener(listener1);
229
230 TestThread thread = new TestThread(future);
231 thread.start();
232
233 future.setClosed();
234 thread.join();
235
236 assertTrue(thread.success);
237 assertTrue(future.isReady());
238 assertTrue(future.isClosed());
239
240 assertSame(null, listener1.notifiedFuture);
241 assertSame(future, listener2.notifiedFuture);
242 }
243
244 public void testRemoveListener2() throws Exception {
245 DefaultCloseFuture future = new DefaultCloseFuture(null);
246 assertFalse(future.isReady());
247 assertFalse(future.isClosed());
248
249 TestListener listener1 = new TestListener();
250 TestListener listener2 = new TestListener();
251 future.addListener(listener1);
252 future.addListener(listener2);
253 future.removeListener(listener2);
254
255 TestThread thread = new TestThread(future);
256 thread.start();
257
258 future.setClosed();
259 thread.join();
260
261 assertTrue(thread.success);
262 assertTrue(future.isReady());
263 assertTrue(future.isClosed());
264
265 assertSame(future, listener1.notifiedFuture);
266 assertSame(null, listener2.notifiedFuture);
267 }
268
269 private static class TestThread extends Thread {
270 private final IoFuture future;
271
272 private boolean success;
273
274 public TestThread(IoFuture future) {
275 this.future = future;
276 }
277
278 public void run() {
279 success = future.join(10000);
280 }
281 }
282
283 private static class TestListener implements IoFutureListener {
284 private IoFuture notifiedFuture;
285
286 public void operationComplete(IoFuture future) {
287 this.notifiedFuture = future;
288 }
289 }
290 }