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;
21  
22  import java.net.InetSocketAddress;
23  import java.net.SocketAddress;
24  
25  import junit.framework.Assert;
26  import junit.framework.TestCase;
27  
28  import org.easymock.MockControl;
29  
30  /**
31   * Tests {@link IoServiceListenerSupport}.
32   *
33   * @author The Apache MINA Project (dev@mina.apache.org)
34   * @version $Rev: 601762 $, $Date: 2007-12-06 08:51:03 -0700 (Thu, 06 Dec 2007) $
35   */
36  public class IoServiceListenerSupportTest extends TestCase {
37      private static final SocketAddress ADDRESS = new InetSocketAddress(8080);
38  
39      private final IoService mockService = MockControl
40              .createControl(IoService.class).getMock();
41  
42      public void testServiceLifecycle() throws Exception {
43          IoServiceListenerSupport support = new IoServiceListenerSupport(
44                  mockService);
45  
46          MockControl listenerControl = MockControl
47                  .createStrictControl(IoServiceListener.class);
48          IoServiceListener listener = (IoServiceListener) listenerControl
49                  .getMock();
50  
51          // Test activation
52          listener.serviceActivated(mockService);
53  
54          listenerControl.replay();
55  
56          support.add(listener);
57          support.fireServiceActivated();
58  
59          listenerControl.verify();
60  
61          // Test deactivation & other side effects
62          listenerControl.reset();
63          listener.serviceDeactivated(mockService);
64  
65          listenerControl.replay();
66          //// Activate more than once
67          support.fireServiceActivated();
68          //// Deactivate
69          support.fireServiceDeactivated();
70          //// Deactivate more than once
71          support.fireServiceDeactivated();
72  
73          listenerControl.verify();
74      }
75  
76      public void testSessionLifecycle() throws Exception {
77          IoServiceListenerSupport support = new IoServiceListenerSupport(
78                  mockService);
79  
80          DummySession session = new DummySession();
81          session.setService(mockService);
82          session.setLocalAddress(ADDRESS);
83  
84          MockControl handlerControl = MockControl
85                  .createStrictControl(IoHandler.class);
86          IoHandler handler = (IoHandler) handlerControl.getMock();
87          session.setHandler(handler);
88  
89          MockControl listenerControl = MockControl
90                  .createStrictControl(IoServiceListener.class);
91          IoServiceListener listener = (IoServiceListener) listenerControl
92                  .getMock();
93  
94          // Test creation
95          listener.sessionCreated(session);
96          handler.sessionCreated(session);
97          handler.sessionOpened(session);
98  
99          listenerControl.replay();
100         handlerControl.replay();
101 
102         support.add(listener);
103         support.fireSessionCreated(session);
104 
105         listenerControl.verify();
106         handlerControl.verify();
107 
108         Assert.assertEquals(1, support.getManagedSessions().size());
109         Assert.assertTrue(support.getManagedSessions().contains(session));
110 
111         // Test destruction & other side effects
112         listenerControl.reset();
113         handlerControl.reset();
114         handler.sessionClosed(session);
115         listener.sessionDestroyed(session);
116 
117         listenerControl.replay();
118         //// Activate more than once
119         support.fireSessionCreated(session);
120         //// Deactivate
121         support.fireSessionDestroyed(session);
122         //// Deactivate more than once
123         support.fireSessionDestroyed(session);
124 
125         listenerControl.verify();
126 
127         Assert.assertTrue(session.isClosing());
128         Assert.assertEquals(0, support.getManagedSessions().size());
129         Assert.assertFalse(support.getManagedSessions().contains(session));
130     }
131 
132     public void testDisconnectOnUnbind() throws Exception {
133         MockControl acceptorControl = MockControl
134                 .createStrictControl(IoAcceptor.class);
135         IoAcceptor acceptor = (IoAcceptor) acceptorControl.getMock();
136 
137         final IoServiceListenerSupport support = new IoServiceListenerSupport(
138                 acceptor);
139 
140         final DummySession session = new DummySession();
141         session.setService(acceptor);
142         session.setLocalAddress(ADDRESS);
143 
144         MockControl handlerControl = MockControl
145                 .createStrictControl(IoHandler.class);
146         IoHandler handler = (IoHandler) handlerControl.getMock();
147         session.setHandler(handler);
148 
149         final MockControl listenerControl = MockControl
150                 .createStrictControl(IoServiceListener.class);
151         IoServiceListener listener = (IoServiceListener) listenerControl
152                 .getMock();
153 
154         // Activate a service and create a session.
155         listener.serviceActivated(acceptor);
156         listener.sessionCreated(session);
157         handler.sessionCreated(session);
158         handler.sessionOpened(session);
159 
160         listenerControl.replay();
161         handlerControl.replay();
162 
163         support.add(listener);
164         support.fireServiceActivated();
165         support.fireSessionCreated(session);
166 
167         listenerControl.verify();
168         handlerControl.verify();
169 
170         // Deactivate a service and make sure the session is closed & destroyed.
171         listenerControl.reset();
172         handlerControl.reset();
173 
174         listener.serviceDeactivated(acceptor);
175         acceptorControl.expectAndReturn(acceptor.isCloseOnDeactivation(), true);
176         listener.sessionDestroyed(session);
177         handler.sessionClosed(session);
178 
179         listenerControl.replay();
180         acceptorControl.replay();
181         handlerControl.replay();
182 
183         new Thread() {
184             // Emulate I/O service
185             @Override
186             public void run() {
187                 try {
188                     Thread.sleep(500);
189                 } catch (InterruptedException e) {
190                     e.printStackTrace();
191                 }
192                 // This synchronization block is a workaround for
193                 // the visibility problem of simultaneous EasyMock
194                 // state update. (not sure if it fixes the failing test yet.)
195                 synchronized (listenerControl) {
196                     support.fireSessionDestroyed(session);
197                 }
198             }
199         }.start();
200         support.fireServiceDeactivated();
201 
202         synchronized (listenerControl) {
203             listenerControl.verify();
204         }
205         acceptorControl.verify();
206         handlerControl.verify();
207 
208         Assert.assertTrue(session.isClosing());
209         Assert.assertEquals(0, support.getManagedSessions().size());
210         Assert.assertFalse(support.getManagedSessions().contains(session));
211     }
212 
213     public void testConnectorActivation() throws Exception {
214         MockControl connectorControl = MockControl
215                 .createStrictControl(IoConnector.class);
216         IoConnector connector = (IoConnector) connectorControl.getMock();
217 
218         IoServiceListenerSupport support = new IoServiceListenerSupport(
219                 connector);
220 
221         final DummySession session = new DummySession();
222         session.setService(connector);
223         session.setRemoteAddress(ADDRESS);
224 
225         MockControl handlerControl = MockControl
226                 .createStrictControl(IoHandler.class);
227         IoHandler handler = (IoHandler) handlerControl.getMock();
228         session.setHandler(handler);
229 
230         MockControl listenerControl = MockControl
231                 .createStrictControl(IoServiceListener.class);
232         IoServiceListener listener = (IoServiceListener) listenerControl
233                 .getMock();
234 
235         // Creating a session should activate a service automatically.
236         listener.serviceActivated(connector);
237         listener.sessionCreated(session);
238         handler.sessionCreated(session);
239         handler.sessionOpened(session);
240 
241         listenerControl.replay();
242         handlerControl.replay();
243 
244         support.add(listener);
245         support.fireSessionCreated(session);
246 
247         listenerControl.verify();
248         handlerControl.verify();
249 
250         // Destroying a session should deactivate a service automatically.
251         listenerControl.reset();
252         handlerControl.reset();
253         listener.sessionDestroyed(session);
254         handler.sessionClosed(session);
255         listener.serviceDeactivated(connector);
256 
257         listenerControl.replay();
258         handlerControl.replay();
259 
260         support.fireSessionDestroyed(session);
261 
262         listenerControl.verify();
263         handlerControl.verify();
264 
265         Assert.assertEquals(0, support.getManagedSessions().size());
266         Assert.assertFalse(support.getManagedSessions().contains(session));
267     }
268 }