001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one
003: * or more contributor license agreements. See the NOTICE file
004: * distributed with this work for additional information
005: * regarding copyright ownership. The ASF licenses this file
006: * to you under the Apache License, Version 2.0 (the
007: * "License"); you may not use this file except in compliance
008: * with the License. You may obtain a copy of the License at
009: *
010: * http://www.apache.org/licenses/LICENSE-2.0
011: *
012: * Unless required by applicable law or agreed to in writing,
013: * software distributed under the License is distributed on an
014: * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015: * KIND, either express or implied. See the License for the
016: * specific language governing permissions and limitations
017: * under the License.
018: *
019: */
020: package org.apache.mina.common;
021:
022: import java.net.InetSocketAddress;
023: import java.net.SocketAddress;
024:
025: import junit.framework.Assert;
026: import junit.framework.TestCase;
027:
028: import org.easymock.MockControl;
029:
030: /**
031: * Tests {@link IoServiceListenerSupport}.
032: *
033: * @author The Apache MINA Project (dev@mina.apache.org)
034: * @version $Rev: 601762 $, $Date: 2007-12-06 08:51:03 -0700 (Thu, 06 Dec 2007) $
035: */
036: public class IoServiceListenerSupportTest extends TestCase {
037: private static final SocketAddress ADDRESS = new InetSocketAddress(
038: 8080);
039:
040: private final IoService mockService = MockControl.createControl(
041: IoService.class).getMock();
042:
043: public void testServiceLifecycle() throws Exception {
044: IoServiceListenerSupport support = new IoServiceListenerSupport(
045: mockService);
046:
047: MockControl listenerControl = MockControl
048: .createStrictControl(IoServiceListener.class);
049: IoServiceListener listener = (IoServiceListener) listenerControl
050: .getMock();
051:
052: // Test activation
053: listener.serviceActivated(mockService);
054:
055: listenerControl.replay();
056:
057: support.add(listener);
058: support.fireServiceActivated();
059:
060: listenerControl.verify();
061:
062: // Test deactivation & other side effects
063: listenerControl.reset();
064: listener.serviceDeactivated(mockService);
065:
066: listenerControl.replay();
067: //// Activate more than once
068: support.fireServiceActivated();
069: //// Deactivate
070: support.fireServiceDeactivated();
071: //// Deactivate more than once
072: support.fireServiceDeactivated();
073:
074: listenerControl.verify();
075: }
076:
077: public void testSessionLifecycle() throws Exception {
078: IoServiceListenerSupport support = new IoServiceListenerSupport(
079: mockService);
080:
081: DummySession session = new DummySession();
082: session.setService(mockService);
083: session.setLocalAddress(ADDRESS);
084:
085: MockControl handlerControl = MockControl
086: .createStrictControl(IoHandler.class);
087: IoHandler handler = (IoHandler) handlerControl.getMock();
088: session.setHandler(handler);
089:
090: MockControl listenerControl = MockControl
091: .createStrictControl(IoServiceListener.class);
092: IoServiceListener listener = (IoServiceListener) listenerControl
093: .getMock();
094:
095: // Test creation
096: listener.sessionCreated(session);
097: handler.sessionCreated(session);
098: handler.sessionOpened(session);
099:
100: listenerControl.replay();
101: handlerControl.replay();
102:
103: support.add(listener);
104: support.fireSessionCreated(session);
105:
106: listenerControl.verify();
107: handlerControl.verify();
108:
109: Assert.assertEquals(1, support.getManagedSessions().size());
110: Assert.assertTrue(support.getManagedSessions()
111: .contains(session));
112:
113: // Test destruction & other side effects
114: listenerControl.reset();
115: handlerControl.reset();
116: handler.sessionClosed(session);
117: listener.sessionDestroyed(session);
118:
119: listenerControl.replay();
120: //// Activate more than once
121: support.fireSessionCreated(session);
122: //// Deactivate
123: support.fireSessionDestroyed(session);
124: //// Deactivate more than once
125: support.fireSessionDestroyed(session);
126:
127: listenerControl.verify();
128:
129: Assert.assertTrue(session.isClosing());
130: Assert.assertEquals(0, support.getManagedSessions().size());
131: Assert.assertFalse(support.getManagedSessions().contains(
132: session));
133: }
134:
135: public void testDisconnectOnUnbind() throws Exception {
136: MockControl acceptorControl = MockControl
137: .createStrictControl(IoAcceptor.class);
138: IoAcceptor acceptor = (IoAcceptor) acceptorControl.getMock();
139:
140: final IoServiceListenerSupport support = new IoServiceListenerSupport(
141: acceptor);
142:
143: final DummySession session = new DummySession();
144: session.setService(acceptor);
145: session.setLocalAddress(ADDRESS);
146:
147: MockControl handlerControl = MockControl
148: .createStrictControl(IoHandler.class);
149: IoHandler handler = (IoHandler) handlerControl.getMock();
150: session.setHandler(handler);
151:
152: final MockControl listenerControl = MockControl
153: .createStrictControl(IoServiceListener.class);
154: IoServiceListener listener = (IoServiceListener) listenerControl
155: .getMock();
156:
157: // Activate a service and create a session.
158: listener.serviceActivated(acceptor);
159: listener.sessionCreated(session);
160: handler.sessionCreated(session);
161: handler.sessionOpened(session);
162:
163: listenerControl.replay();
164: handlerControl.replay();
165:
166: support.add(listener);
167: support.fireServiceActivated();
168: support.fireSessionCreated(session);
169:
170: listenerControl.verify();
171: handlerControl.verify();
172:
173: // Deactivate a service and make sure the session is closed & destroyed.
174: listenerControl.reset();
175: handlerControl.reset();
176:
177: listener.serviceDeactivated(acceptor);
178: acceptorControl.expectAndReturn(acceptor
179: .isCloseOnDeactivation(), true);
180: listener.sessionDestroyed(session);
181: handler.sessionClosed(session);
182:
183: listenerControl.replay();
184: acceptorControl.replay();
185: handlerControl.replay();
186:
187: new Thread() {
188: // Emulate I/O service
189: @Override
190: public void run() {
191: try {
192: Thread.sleep(500);
193: } catch (InterruptedException e) {
194: e.printStackTrace();
195: }
196: // This synchronization block is a workaround for
197: // the visibility problem of simultaneous EasyMock
198: // state update. (not sure if it fixes the failing test yet.)
199: synchronized (listenerControl) {
200: support.fireSessionDestroyed(session);
201: }
202: }
203: }.start();
204: support.fireServiceDeactivated();
205:
206: synchronized (listenerControl) {
207: listenerControl.verify();
208: }
209: acceptorControl.verify();
210: handlerControl.verify();
211:
212: Assert.assertTrue(session.isClosing());
213: Assert.assertEquals(0, support.getManagedSessions().size());
214: Assert.assertFalse(support.getManagedSessions().contains(
215: session));
216: }
217:
218: public void testConnectorActivation() throws Exception {
219: MockControl connectorControl = MockControl
220: .createStrictControl(IoConnector.class);
221: IoConnector connector = (IoConnector) connectorControl
222: .getMock();
223:
224: IoServiceListenerSupport support = new IoServiceListenerSupport(
225: connector);
226:
227: final DummySession session = new DummySession();
228: session.setService(connector);
229: session.setRemoteAddress(ADDRESS);
230:
231: MockControl handlerControl = MockControl
232: .createStrictControl(IoHandler.class);
233: IoHandler handler = (IoHandler) handlerControl.getMock();
234: session.setHandler(handler);
235:
236: MockControl listenerControl = MockControl
237: .createStrictControl(IoServiceListener.class);
238: IoServiceListener listener = (IoServiceListener) listenerControl
239: .getMock();
240:
241: // Creating a session should activate a service automatically.
242: listener.serviceActivated(connector);
243: listener.sessionCreated(session);
244: handler.sessionCreated(session);
245: handler.sessionOpened(session);
246:
247: listenerControl.replay();
248: handlerControl.replay();
249:
250: support.add(listener);
251: support.fireSessionCreated(session);
252:
253: listenerControl.verify();
254: handlerControl.verify();
255:
256: // Destroying a session should deactivate a service automatically.
257: listenerControl.reset();
258: handlerControl.reset();
259: listener.sessionDestroyed(session);
260: handler.sessionClosed(session);
261: listener.serviceDeactivated(connector);
262:
263: listenerControl.replay();
264: handlerControl.replay();
265:
266: support.fireSessionDestroyed(session);
267:
268: listenerControl.verify();
269: handlerControl.verify();
270:
271: Assert.assertEquals(0, support.getManagedSessions().size());
272: Assert.assertFalse(support.getManagedSessions().contains(
273: session));
274: }
275: }
|