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