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.statemachine.transition;
021:
022: import java.lang.reflect.Method;
023:
024: import org.apache.mina.statemachine.State;
025: import org.apache.mina.statemachine.context.StateContext;
026: import org.apache.mina.statemachine.event.Event;
027: import org.apache.mina.statemachine.transition.MethodTransition;
028:
029: import com.agical.rmock.extension.junit.RMockTestCase;
030:
031: /**
032: * Tests {@link MethodTransition}.
033: *
034: * @author The Apache MINA Project (dev@mina.apache.org)
035: * @version $Rev: 586090 $, $Date: 2007-10-18 13:12:08 -0600 (Thu, 18 Oct 2007) $
036: */
037: public class MethodTransitionTest extends RMockTestCase {
038: State currentState;
039: State nextState;
040: TestStateContext context;
041: Target target;
042: Method subsetAllArgsMethod1;
043: Method subsetAllArgsMethod2;
044: Event noArgsEvent;
045: Event argsEvent;
046: Object[] args;
047:
048: protected void setUp() throws Exception {
049: super .setUp();
050:
051: currentState = new State("current");
052: nextState = new State("next");
053: target = (Target) mock(Target.class);
054: subsetAllArgsMethod1 = Target.class.getMethod("subsetAllArgs",
055: new Class[] { TestStateContext.class, B.class, A.class,
056: Integer.TYPE });
057: subsetAllArgsMethod2 = Target.class.getMethod("subsetAllArgs",
058: new Class[] { Event.class, B.class, B.class,
059: Boolean.TYPE });
060:
061: args = new Object[] { new A(), new B(), new C(),
062: new Integer(627438), Boolean.TRUE };
063: context = (TestStateContext) mock(TestStateContext.class);
064: noArgsEvent = new Event("event", context, new Object[0]);
065: argsEvent = new Event("event", context, args);
066: }
067:
068: public void testExecuteWrongEventId() throws Exception {
069: startVerification();
070: MethodTransition t = new MethodTransition("otherEvent",
071: nextState, "noArgs", target);
072: assertFalse(t.execute(noArgsEvent));
073: }
074:
075: public void testExecuteNoArgsMethodOnNoArgsEvent() throws Exception {
076: target.noArgs();
077: startVerification();
078: MethodTransition t = new MethodTransition("event", nextState,
079: "noArgs", target);
080: assertTrue(t.execute(noArgsEvent));
081: }
082:
083: public void testExecuteNoArgsMethodOnArgsEvent() throws Exception {
084: target.noArgs();
085: startVerification();
086: MethodTransition t = new MethodTransition("event", nextState,
087: "noArgs", target);
088: assertTrue(t.execute(argsEvent));
089: }
090:
091: public void testExecuteExactArgsMethodOnNoArgsEvent()
092: throws Exception {
093: startVerification();
094: MethodTransition t = new MethodTransition("event", nextState,
095: "exactArgs", target);
096: assertFalse(t.execute(noArgsEvent));
097: }
098:
099: public void testExecuteExactArgsMethodOnArgsEvent()
100: throws Exception {
101: target.exactArgs((A) args[0], (B) args[1], (C) args[2],
102: ((Integer) args[3]).intValue(), ((Boolean) args[4])
103: .booleanValue());
104: startVerification();
105: MethodTransition t = new MethodTransition("event", nextState,
106: "exactArgs", target);
107: assertTrue(t.execute(argsEvent));
108: }
109:
110: public void testExecuteSubsetExactArgsMethodOnNoArgsEvent()
111: throws Exception {
112: startVerification();
113: MethodTransition t = new MethodTransition("event", nextState,
114: "subsetExactArgs", target);
115: assertFalse(t.execute(noArgsEvent));
116: }
117:
118: public void testExecuteSubsetExactArgsMethodOnArgsEvent()
119: throws Exception {
120: target.subsetExactArgs((A) args[0], (A) args[1],
121: ((Integer) args[3]).intValue());
122: startVerification();
123: MethodTransition t = new MethodTransition("event", nextState,
124: "subsetExactArgs", target);
125: assertTrue(t.execute(argsEvent));
126: }
127:
128: public void testExecuteAllArgsMethodOnArgsEvent() throws Exception {
129: target.allArgs(argsEvent, context, (A) args[0], (B) args[1],
130: (C) args[2], ((Integer) args[3]).intValue(),
131: ((Boolean) args[4]).booleanValue());
132: startVerification();
133: MethodTransition t = new MethodTransition("event", nextState,
134: "allArgs", target);
135: assertTrue(t.execute(argsEvent));
136: }
137:
138: public void testExecuteSubsetAllArgsMethod1OnArgsEvent()
139: throws Exception {
140: target.subsetAllArgs(context, (B) args[1], (A) args[2],
141: ((Integer) args[3]).intValue());
142: startVerification();
143: MethodTransition t = new MethodTransition("event", nextState,
144: subsetAllArgsMethod1, target);
145: assertTrue(t.execute(argsEvent));
146: }
147:
148: public void testExecuteSubsetAllArgsMethod2OnArgsEvent()
149: throws Exception {
150: target.subsetAllArgs(argsEvent, (B) args[1], (B) args[2],
151: ((Boolean) args[4]).booleanValue());
152: startVerification();
153: MethodTransition t = new MethodTransition("event", nextState,
154: subsetAllArgsMethod2, target);
155: assertTrue(t.execute(argsEvent));
156: }
157:
158: public interface Target {
159: void noArgs();
160:
161: void exactArgs(A a, B b, C c, int integer, boolean bool);
162:
163: void allArgs(Event event, StateContext ctxt, A a, B b, C c,
164: int integer, boolean bool);
165:
166: void subsetExactArgs(A a, A b, int integer);
167:
168: void subsetAllArgs(TestStateContext ctxt, B b, A c, int integer);
169:
170: void subsetAllArgs(Event event, B b, B c, boolean bool);
171: }
172:
173: public interface TestStateContext extends StateContext {
174: }
175:
176: public static class A {
177: }
178:
179: public static class B extends A {
180: }
181:
182: public static class C extends B {
183: }
184: }
|