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