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