1   /*
2    *  Licensed to the Apache Software Foundation (ASF) under one
3    *  or more contributor license agreements.  See the NOTICE file
4    *  distributed with this work for additional information
5    *  regarding copyright ownership.  The ASF licenses this file
6    *  to you under the Apache License, Version 2.0 (the
7    *  "License"); you may not use this file except in compliance
8    *  with the License.  You may obtain a copy of the License at
9    *  
10   *    http://www.apache.org/licenses/LICENSE-2.0
11   *  
12   *  Unless required by applicable law or agreed to in writing,
13   *  software distributed under the License is distributed on an
14   *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   *  KIND, either express or implied.  See the License for the
16   *  specific language governing permissions and limitations
17   *  under the License. 
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   * Tests {@link IoFuture} implementations.
39   * 
40   * @author The Apache Directory Project (mina-dev@directory.apache.org)
41   * @version $Rev: 555855 $, $Date: 2007-07-13 05:19:00 +0200 (Fri, 13 Jul 2007) $ 
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 }