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.handler.demux;
021:
022: import junit.framework.TestCase;
023:
024: import org.apache.mina.common.IoSession;
025: import org.easymock.MockControl;
026:
027: /**
028: * Tests {@link org.apache.mina.handler.demux.DemuxingIoHandler}.
029: *
030: * @author The Apache MINA Project (dev@mina.apache.org)
031: * @version $Rev$, $Date$
032: */
033: @SuppressWarnings("unchecked")
034: public class DemuxingIoHandlerTest extends TestCase {
035: MockControl mockHandler1;
036:
037: MockControl mockHandler2;
038:
039: MockControl mockHandler3;
040:
041: MessageHandler handler1;
042:
043: MessageHandler handler2;
044:
045: MessageHandler handler3;
046:
047: IoSession session;
048:
049: Object[] msg;
050:
051: @Override
052: protected void setUp() throws Exception {
053: super .setUp();
054:
055: /*
056: * Create the messages.
057: */
058: msg = new Object[9];
059: msg[0] = new C1();
060: msg[1] = new C2();
061: msg[2] = new C3();
062: msg[3] = new C1();
063: msg[4] = new C2();
064: msg[5] = new C3();
065: msg[6] = new C1();
066: msg[7] = new C2();
067: msg[8] = new C3();
068:
069: /*
070: * Create mocks.
071: */
072: mockHandler1 = MockControl.createControl(MessageHandler.class);
073: mockHandler2 = MockControl.createControl(MessageHandler.class);
074: mockHandler3 = MockControl.createControl(MessageHandler.class);
075:
076: handler1 = (MessageHandler) mockHandler1.getMock();
077: handler2 = (MessageHandler) mockHandler2.getMock();
078: handler3 = (MessageHandler) mockHandler3.getMock();
079:
080: session = MockControl.createControl(IoSession.class).getMock();
081: }
082:
083: public void testFindHandlerByClass() throws Exception {
084: /*
085: * Record expectations.
086: */
087: handler1.handleMessage(session, msg[0]);
088: handler1.handleMessage(session, msg[1]);
089: handler1.handleMessage(session, msg[2]);
090: handler1.handleMessage(session, msg[3]);
091: handler2.handleMessage(session, msg[4]);
092: handler2.handleMessage(session, msg[5]);
093: handler1.handleMessage(session, msg[6]);
094: handler2.handleMessage(session, msg[7]);
095: handler3.handleMessage(session, msg[8]);
096:
097: /*
098: * Replay.
099: */
100: mockHandler1.replay();
101: mockHandler2.replay();
102: mockHandler3.replay();
103:
104: DemuxingIoHandler ioHandler = new DemuxingIoHandler();
105:
106: /*
107: * First round. All messages should be handled by handler1
108: */
109: ioHandler.addReceivedMessageHandler(C1.class,
110: (MessageHandler) mockHandler1.getMock());
111: ioHandler.messageReceived(session, msg[0]);
112: ioHandler.messageReceived(session, msg[1]);
113: ioHandler.messageReceived(session, msg[2]);
114:
115: /*
116: * Second round. C1 messages should be handled by handler1. C2 and C3
117: * messages should be handled by handler2.
118: */
119: ioHandler.addReceivedMessageHandler(C2.class,
120: (MessageHandler) mockHandler2.getMock());
121: ioHandler.messageReceived(session, msg[3]);
122: ioHandler.messageReceived(session, msg[4]);
123: ioHandler.messageReceived(session, msg[5]);
124:
125: /*
126: * Third round. C1 messages should be handled by handler1, C2 by
127: * handler2 and C3 by handler3.
128: */
129: ioHandler.addReceivedMessageHandler(C3.class,
130: (MessageHandler) mockHandler3.getMock());
131: ioHandler.messageReceived(session, msg[6]);
132: ioHandler.messageReceived(session, msg[7]);
133: ioHandler.messageReceived(session, msg[8]);
134:
135: /*
136: * Verify.
137: */
138: mockHandler1.verify();
139: mockHandler2.verify();
140: mockHandler3.verify();
141: }
142:
143: public void testFindHandlerByInterface() throws Exception {
144: /*
145: * Record expectations.
146: */
147: handler1.handleMessage(session, msg[0]);
148: handler1.handleMessage(session, msg[1]);
149: handler1.handleMessage(session, msg[2]);
150: handler1.handleMessage(session, msg[3]);
151: handler2.handleMessage(session, msg[4]);
152: handler1.handleMessage(session, msg[5]);
153: handler3.handleMessage(session, msg[6]);
154: handler2.handleMessage(session, msg[7]);
155: handler3.handleMessage(session, msg[8]);
156:
157: /*
158: * Replay.
159: */
160: mockHandler1.replay();
161: mockHandler2.replay();
162: mockHandler3.replay();
163:
164: DemuxingIoHandler ioHandler = new DemuxingIoHandler();
165:
166: /*
167: * First round. All messages should be handled by handler1
168: */
169: ioHandler.addReceivedMessageHandler(I4.class,
170: (MessageHandler) mockHandler1.getMock());
171: ioHandler.messageReceived(session, msg[0]);
172: ioHandler.messageReceived(session, msg[1]);
173: ioHandler.messageReceived(session, msg[2]);
174:
175: /*
176: * Second round. C1 and C3 messages should be handled by handler1. C2
177: * messages should be handled by handler2.
178: */
179: ioHandler.addReceivedMessageHandler(I6.class,
180: (MessageHandler) mockHandler2.getMock());
181: ioHandler.messageReceived(session, msg[3]);
182: ioHandler.messageReceived(session, msg[4]);
183: ioHandler.messageReceived(session, msg[5]);
184:
185: /*
186: * Third round. C1 and C3 messages should be handled by handler3. C2
187: * messages should be handled by handler2.
188: */
189: ioHandler.addReceivedMessageHandler(I3.class,
190: (MessageHandler) mockHandler3.getMock());
191: ioHandler.messageReceived(session, msg[6]);
192: ioHandler.messageReceived(session, msg[7]);
193: ioHandler.messageReceived(session, msg[8]);
194:
195: /*
196: * Verify.
197: */
198: mockHandler1.verify();
199: mockHandler2.verify();
200: mockHandler3.verify();
201: }
202:
203: /*
204: * Define some interfaces and classes used when testing the findHandler
205: * method. This is what the hierarchy looks like:
206: *
207: * C3 - I7 - I9
208: * | | /\
209: * | I8 I3 I4
210: * |
211: * C2 - I5 - I6
212: * |
213: * C1 - I1 - I2 - I4
214: * |
215: * I3
216: */
217:
218: public interface I1 {
219: }
220:
221: public interface I2 extends I3 {
222: }
223:
224: public interface I3 {
225: }
226:
227: public interface I4 {
228: }
229:
230: public static class C1 implements I1, I2, I4 {
231: }
232:
233: public interface I5 {
234: }
235:
236: public interface I6 {
237: }
238:
239: public static class C2 extends C1 implements I5, I6 {
240: }
241:
242: public interface I7 extends I8 {
243: }
244:
245: public interface I8 {
246: }
247:
248: public interface I9 extends I3, I4 {
249: }
250:
251: public static class C3 extends C2 implements I7, I9 {
252: }
253: }
|