Coverage Report

Coverage Report - biz.xsoftware.impl.mock.MockSuperclass

Classes in this File
Line Coverage
Branch Coverage
Complexity
MockSuperclass
74%
337/454
91%
100/110
MockSuperclass$LeftOverMethods
100%
8/8
100%
1/1
 package biz.xsoftware.impl.mock;
 
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import biz.xsoftware.mock.Behavior;
 import biz.xsoftware.mock.BehaviorMethod;
 import biz.xsoftware.mock.CalledMethod;
 import biz.xsoftware.mock.CloningBehavior;
 import biz.xsoftware.mock.ExpectFailedException;
 import biz.xsoftware.mock.MethodSignature;
 import biz.xsoftware.mock.MockObject;
 
 /**
  * This is a super class for mock Objects. It has the following options
  * <ol>
  * <li>Guarantee order of events and that events happen on one object</li>
  * <li>Guarantee events called with order not mattering on one object</li>
  * <li>Guarantee order of events is correct between two objects(One mock obj.
  * implements two interfaces)</li>
  * </ol>
  * This class will also return the parameters that were passed into the
  * MockObject so they can be introspected in testing to make sure they were
  * correct.
  * 
  * The MockObject extending this class can also be told to throw exceptions on
  * certain methods so we can test error leg behavior.
  * 
  * Example of how to use MockActionListener implements ActionListener and
  * extends this class The only method in MockActionListener is
  * 
  * <PRE>
  * 
  * public final static ACTION_METHOD = &quot;actionPerformed method&quot;; public void
  * actionPerformed(ActionEvent evt) { super.methodCalled(ACTION_METHOD, evt); }
  * 
  * </PRE>
  * 
  * In the test, when you expect an ActionEvent, you can call
  * 
  * <PRE>
  * 
  * Object o = MockActionListener.expectEvent(ACTION_METHOD);
  * ActionEvent evt = (ActionEvent) evt;
  * assertNonNull(evt.getSource());
  * 
  * </PRE>
  * 
  * Another useful behavior is throwing any type of exception using
  * setExceptionOnMethod(String method, Throwable e). This can test robustness in
  * a system to make sure listeners or services that throw exceptions don't
  * affect your system, or at least affect your system in the proper way.
  * 
  * @author Dean Hiller (dean@xsoftware.biz)
  */
 public abstract class MockSuperclass implements MockObject {
 
     private static final Logger log = Logger.getLogger(MockSuperclass.class.getName());
 
     /**
      * List of the current methods that have been called.
      */
     private final List<CalledMethod> methodsCalled = new LinkedList<CalledMethod>();
 
     /**
      * A map of queues, containing either 1. objects to return when methods are
      * called 2. Behaviors to run which return objects to return 3. Exceptions
      * to throw
      */
     protected final Map<Method, List<Action>> methodToReturnVal = new HashMap<Method, List<Action>>();
 
     /**
      * A map of default return values, which are used to return if the queue for
      * the method is empty.
      */
     protected final Map<Method, Action> methodToDefaultRetVal = new HashMap<Method, Action>();
 
     private final Set<String> ignoredMethods = new HashSet<String>();
 
     /**
      * Default wait time to wait for a method to be called once expectCall is
      * called.
      */
     public static final int DEFAULT_WAIT_TIME = 5000;
 
     private int waitTime = DEFAULT_WAIT_TIME;
 
     protected String id;
 
     private boolean isCaseSensitive = true;
 
     /**
      * Default constructor of superclass of all mockObjects with a delay of 10
      * seconds. This delay is the amount of time the mock object waits for a
      * method to be called when a client calls expectCall.
      */
     public MockSuperclass() {
     }
 
     /**
      * The constructor to use to override the default delay({@link #DEFAULT_WAIT_TIME})
      * such that the mock object will give methods a longer time to be called
      * before timing out to fail the test.
      * 
      * @param delay The amount of time in milliseconds to wait for a method to
      *            be called.
      */
     public MockSuperclass(int delay) {
         waitTime = delay;
     }
 
     public MockSuperclass(String id) {
         this.id = id;
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#setExpectTimeout(int)
      */
     public void setExpectTimeout(int delay) {
         this.waitTime = delay;
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#getExpectTimeout()
      */
     public int getExpectTimeout() {
         return waitTime;
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#addIgnore(java.lang.String[])
      */
     public void addIgnore(String... methods) {
         addIgnoreImpl(methods);
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#addIgnore(java.lang.String,
      *      java.lang.Class[])
      */
     public void addIgnore(MethodSignature... methodSignature) {
         throw new UnsupportedOperationException("This method has not been implemented yet");
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#removeIgnore(java.lang.String[])
      */
     public void removeIgnore(String... methods) {
         removeIgnoreImpl(methods);
     }
 
     /**
      * 
      */
     public void removeIgnore(MethodSignature... methodSignature) {
         throw new UnsupportedOperationException("This method has not been implemented yet");
     }
 
     private void removeIgnoreImpl(String... methods) {
         for (String method : methods) {
             ignoredMethods.remove(method);
         }
     }
 
     /**
      * 
      * @param methods
      */
     private void addIgnoreImpl(String... methods) {
         if (methods == null)
             return;
 
         // validate the given methods
         for (String method : methods) {
             if (method.equals(MockObject.ANY) || method.equals(MockObject.NONE)) {
                 throw new IllegalArgumentException("Cannot add MockObject.ANY or MockObject.NONE as an ignored method");
             }
             MethodVerifier.verifyMethodNameExist(getClasses(), method, isCaseSensitive);
         }
 
         // now add them
         for (String method : methods) {
             ignoredMethods.add(method);
         }
     }
 
     public void setIgnoredMethods(String[] methods) {
         if (methods == null)
             return;
 
         // validate the given methods
         for (String method : methods) {
             if (method.equals(MockObject.ANY) || method.equals(MockObject.NONE)) {
                 throw new IllegalArgumentException("Cannot add MockObject.ANY or MockObject.NONE as an ignored method");
             }
             MethodVerifier.verifyMethodNameExist(getClasses(), method, isCaseSensitive);
         }
 
         // now clear the list and add the new ones
         ignoredMethods.clear();
 
         for (String method : methods) {
             ignoredMethods.add(method);
         }
     }
 
     /**
      * Subclasses should call this method when a method on their interface is
      * called. This method is for users to create subclasses and call so they
      * don't have to wrap it in a try-catch block.
      * 
      * @param method The method name
      * @param parameters The parameter objects that were passed into the called
      *            method
      * @return whatever the client has specified using addReturnValue
      */
     protected Object methodCalled(final String method, final Object parameters) {
         try {
             Object[] resultParams;
             if (!(parameters instanceof Object[])) {
                 if (parameters != null) {
                     resultParams = new Object[] { parameters };
                 } else {
                     resultParams = new Object[0];
                 }
             } else {
                 resultParams = (Object[]) parameters;
             }
             return methodCalledImpl(method, resultParams);
         } catch (Throwable e) {
             if (e instanceof RuntimeException)
                 throw (RuntimeException) e;
             throw new RuntimeException("Sorry, must wrap exception, unwrap in "
                     + "your mockobject, or have mockObject call methodCalledImpl instead", e);
         }
     }
 
     protected Object methodCalledImpl(final String method, final Object... parameters) throws Throwable {
         String resultMethod = method.intern();
         Method m = getMethod(resultMethod, parameters);
         return methodCalledImpl(m, parameters);
     }
 
     /**
      * Subclasses should call this method when a method on their interface is
      * called. This method is for users to create subclasses and call so they
      * don't have to wrap it in a try-catch block.
      * 
      * @param method The method name that was called
      * @param parameters The parameters passed with the called method
      * 
      * @return whatever the client has specified using addReturnValue
      */
     protected synchronized Object methodCalledImpl(final Method method, final Object... parameters) throws Throwable {
         if (log.isLoggable(Level.FINE)) {
             String params = "";
             if (parameters == null) {
                 params = "no params";
             } else {
                 Object[] array = parameters;
                 if (array.length > 0) {
                     for (int i = 0; i < array.length - 1; i++) {
                         params += array[i] + ", ";
                     }
                     // write out the last parameter without the comma
                     params += array[array.length - 1];
                 }
             }
 
             log.log(Level.FINE, id + ": method called=" + method.getName() + "(" + params + ") on obj=" + this);
         }
 
         // sometimes, the contract is for the "code" to give a parameter
         // to a library and then modify the parameter after the library
         // is done with it. This means the object the "code" gave to
         // the MockObject will change out from under the MockObject and be
         // corrupted meaning you can't write a test to test the contract
         // without cloning the object so it can't be changed.
         Object[] newParams = clone(method, parameters);
         if (isCaseSensitive) {
             methodsCalled.add(new CalledMethod(method.getName(), method, newParams, new Throwable().fillInStackTrace()));
         } else {
             methodsCalled.add(new CalledMethod(method.getName().toLowerCase(), method, newParams,
                     new Throwable().fillInStackTrace()));
         }
 
         this.notifyAll();
 
         return runNextAction(method, parameters);
     }
 
     /**
      * Runs the next action
      * 
      * @param methodStr
      * @param params The parameter objects used when the method was called
      * @return
      * @throws Throwable
      */
     private Object runNextAction(Method method, Object[] params) throws Throwable {
 
         // if (log.isLoggable(Level.FINEST)) {
         // log.finest("locating next action for method: " + methodStr);
         // }
 
         // Method method = getMethod(methodStr, params);
 
         // load the default
         Action action = methodToDefaultRetVal.get(method);
 
         // the call order is to run any other set actions before the default
         List<Action> l = methodToReturnVal.get(method);
         if (l != null) {
             action = l.remove(0);
             // if that was the last one in the list, remove the list...
             if (l.size() <= 0)
                 methodToReturnVal.remove(method);
         }
 
         if (action != null)
             return action.execute(params);
 
         return null;
     }
 
     /**
      * Looks for the {@link Method} in the current object's interfaces using the
      * method string given and the parameters that were obtained when the method
      * was called. The method parameter types will be determined from the given
      * params
      * 
      * @param methodStr The method name
      * @param params The parameters that were passed to the method
      * @return The found {@link Method} obj, otherwise exceptions are thrown
      */
     private Method getMethod(String methodStr, Object[] params) {
         Class<?>[] argTypes = null;
 
         if (params != null) {
             // find the Method object for the given params
             argTypes = new Class<?>[params.length];
             for (int i = 0; i < params.length; i++) {
                 if (params[i] != null) {
                     argTypes[i] = params[i].getClass();
                 } else {
                     // we don't know what the class type is so we will try
                     // to match the class with any param object type
                     // will throw an exception if multiple methods match
                     argTypes[i] = MethodSignature.ANY_CLASS_TYPE;
                 }
             }
         }
 
         return MethodVerifier.getMethod(getClasses(), new MethodSignature(methodStr, argTypes), isCaseSensitive);
     }
 
     public CalledMethod expectUnordered(String method) {
         return expectUnordered(new String[] { method })[0];
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#expectUnordered(java.lang.String[])
      */
     public synchronized CalledMethod[] expectUnordered(String... methods) {
         if (methods == null)
             throw new IllegalArgumentException("methods cannot be null");
         else if (methods.length <= 0)
             throw new IllegalArgumentException("methods.length must be >= 1");
         for (int i = 0; i < methods.length; i++) {
             if (methods[i] == null)
                 throw new IllegalArgumentException("None of values in methods " + "can be null, yet methods[" + i
                         + "] was null");
         }
 
         String[] expectedMethods = new String[methods.length];
 
         for (int i = 0; i < methods.length && i < expectedMethods.length; i++) {
             if (isCaseSensitive)
                 expectedMethods[i] = methods[i];
             else
                 expectedMethods[i] = methods[i].toLowerCase();
         }
 
         Set<String> ignorables = createIgnorableMap(ignoredMethods);
         CalledMethod[] retVal = new CalledMethod[methods.length];
 
         List<CalledMethod> methodsCalledList = new ArrayList<CalledMethod>();
         for (int i = 0; i < methods.length; i++) {
             if (ANY.equals(methods[i]))
                 throw new IllegalArgumentException("The parameter 'methods' in "
                         + "expectUnorderedCalls cannot contain MockSuperclass.ANY(use expectOrderedCalls instead)");
 
             CalledMethod o = expectUnignoredCall(ANY, ignorables, methodsCalledList);
             if (o == null) {
                 String reason =
                         MessageHelper.putTogetherReason(methods, ignorables, methodsCalledList,
                                 "timed out on next expected method\n");
                 throw new ExpectFailedException("Timed out waiting for a method call\n" + reason, retVal,
                         ExpectFailedException.TIMED_OUT);
             }
 
             int index = -1;
 
             if (isCaseSensitive) {
                 index = stringArraySearch(o.getMethodName(), expectedMethods);
             } else {
                 index = stringArraySearch(o.getMethodName().toLowerCase(), expectedMethods);
             }
 
             if (index >= 0) {
                 // this is good, we found an expected method
                 // remove it from the list we're expected
                 expectedMethods[index] = null;
             } else {
                 String reason = MessageHelper.putTogetherReason(methods, ignorables, methodsCalledList, null);
                 throw new ExpectFailedException(reason, retVal, ExpectFailedException.UNEXPECTED_CALL_BEFORE);
             }
 
             retVal[index] = o;
         }
 
         LeftOverMethods leftOver = getLeftOverMethods(ignorables);
         if (leftOver != null) {
             String reason =
                     MessageHelper.putTogetherReason(methods, ignorables, methodsCalledList, "extra method(s)="
                             + leftOver + "\n");
             throw new ExpectFailedException("There was a method called after your expected methods.\n" + reason,
                     retVal, ExpectFailedException.UNEXPECTED_CALL_AFTER);
         }
 
         return retVal;
     }
 
     /**
      * This method does a search in the given string array for the given string
      * to match and returns the found index or -1 if not found
      * 
      * @param needle The string to search for
      * @param haystack The array of strings to search in
      * @return The index in the array where a match is found or -1 if there
      *         wasn't a match
      */
     private static int stringArraySearch(String needle, String[] haystack) {
         for (int i = 0; i < haystack.length; i++) {
             if (needle.equals(haystack[i])) {
                 return i;
             }
         }
         return -1;
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#expectUnorderedCalls(java.lang.String[])
      */
 
     @Deprecated
     public CalledMethod[] expectUnorderedCalls(String... methods) {
         return expectUnordered(methods);
     }
 
     /**
      * Calls {@link #addIgnore(String[])} with the given ignored methods, then
      * runs {@link #expectUnorderedCalls(String[])}, saving the result. Then
      * removes the ignored methods and finally returns the saved result
      * 
      * @deprecated This is no longer supported, the use of
      *             {@link #addIgnore(String)} in combination with
      *             {@link #expect(String[]) should be used
      */
     @Deprecated
     public CalledMethod[] expectUnorderedCalls(String[] methods, String[] ignoredMethods) {
         addIgnore(ignoredMethods);
         CalledMethod[] results = expectUnordered(methods);
         removeIgnoreImpl(ignoredMethods);
         return results;
     }
 
     private CalledMethod[] cleanup(CalledMethod[] methods, int size) {
         CalledMethod[] retVal = new CalledMethod[size];
         for (int i = 0; i < retVal.length; i++) {
             retVal[i] = methods[i];
         }
         return retVal;
     }
 
     /**
      * @see biz.xsoftware.mock.MockObject#expect(java.lang.String)
      */
     public CalledMethod expect(String method) {
         return expectImpl(method)[0];
     }
 
     /**
      * @deprecated Use {@link #expect(String)} now
      */
     @Deprecated
     public CalledMethod expectCall(String method) {
         return expectImpl(method)[0];
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#expectCall(java.lang.String,
      *      java.lang.String[])
      */
     @Deprecated
     public CalledMethod expectCall(String method, String... ignoredMethods) {
         addIgnore(ignoredMethods);
         CalledMethod result = expectImpl(method)[0];
         removeIgnoreImpl(ignoredMethods);
         return result;
     }
 
     /**
      * @see biz.xsoftware.mock.MockObject#expect(java.lang.String[])
      */
     public synchronized CalledMethod[] expect(String... methods) {
         return expectImpl(methods);
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#expectOrderedCalls(java.lang.String[])
      */
     @Deprecated
     public synchronized CalledMethod[] expectOrderedCalls(String... methods) {
         return expectImpl(methods);
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#expectOrderedCalls(java.lang.String[],
      *      java.lang.String[])
      */
     @Deprecated
     public CalledMethod[] expectOrderedCalls(String[] methods, String[] ignoredMethods) {
         addIgnoreImpl(ignoredMethods);
         return expectImpl(methods);
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#expect(java.lang.String, int)
      */
     public CalledMethod[] expect(String method, int times) {
         String[] methods = new String[times];
         Arrays.fill(methods, 0, times, method);
         return expectImpl(methods);
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#expectOnceThenIgnore(java.lang.String[])
      */
     public CalledMethod[] expectOnceThenIgnore(final String... methods) {
         if (methods == null)
             throw new IllegalArgumentException("methods cannot be null");
         else if (methods.length <= 0)
             throw new IllegalArgumentException("methods.length must be >= 1");
         for (int i = 0; i < methods.length; i++) {
             if (methods[i] == null)
                 throw new IllegalArgumentException("None of values in methods " + "can be null, yet methods[" + i
                         + "] was null");
         }
 
         // need to copy to another array so we can change to lowercase if needed
         // and to remove the item when a match is found
         String[] expectedMethods = new String[methods.length];
 
         for (int i = 0; i < methods.length && i < expectedMethods.length; i++) {
             if (ANY.equals(methods[i]))
                 throw new IllegalArgumentException("The parameter 'methods' in "
                         + "expectOnceThenIgnore cannot contain MockObject.ANY(use expectOrderedCalls instead)");
 
             if (isCaseSensitive)
                 expectedMethods[i] = methods[i];
             else
                 expectedMethods[i] = methods[i].toLowerCase();
         }
 
         if (log.isLoggable(Level.FINEST)) {
             StringBuilder sb = new StringBuilder();
             sb.append("expectedMethods={");
             for (String method : expectedMethods)
                 sb.append(method).append(",");
             sb.append("}");
             log.finest(sb.toString());
         }
 
         Set<String> ignorables = createIgnorableMap(ignoredMethods);
         CalledMethod[] retVal = new CalledMethod[methods.length];
 
         List<CalledMethod> methodsCalledList = new ArrayList<CalledMethod>();
 
         // We need to loop the expectedMethods number of times. We might not
         // actually be working on expectedMethods[i]... it could be another
         // expectedMethod
         for (int i = 0; i < expectedMethods.length; i++) {
 
             CalledMethod o = expectUnignoredCall(ANY, ignorables, methodsCalledList);
             if (log.isLoggable(Level.FINEST)) {
                 log.finest("received CalledMethod: " + o.getMethodName());
             }
             if (o == null) {
                 String reason =
                         MessageHelper.putTogetherReason(expectedMethods, ignorables, methodsCalledList,
                                 "timed out on next expected method\n");
                 throw new ExpectFailedException("Timed out waiting for a method call\n" + reason, retVal,
                         ExpectFailedException.TIMED_OUT);
             }
 
             int index = -1;
 
             if (isCaseSensitive) {
                 index = stringArraySearch(o.getMethodName(), expectedMethods);
             } else {
                 index = stringArraySearch(o.getMethodName().toLowerCase(), expectedMethods);
             }
 
             if (index >= 0) {
                 if (log.isLoggable(Level.FINEST)) {
                     log.finest("found method(" + o.getMethodName() + ") in expectedMethods, index=" + index
                             + ".  Now adding to ignorables");
                 }
 
                 // this is good, we found an expected method
                 // remove it from the expected list
                 expectedMethods[index] = null;
                 if (isCaseSensitive) {
                     ignorables.add(o.getMethodName());
                 } else {
                     ignorables.add(o.getMethodName().toLowerCase());
                 }
             } else {
                 String reason = MessageHelper.putTogetherReason(methods, ignorables, methodsCalledList, null);
                 throw new ExpectFailedException(reason, retVal, ExpectFailedException.UNEXPECTED_CALL_BEFORE);
             }
 
             retVal[index] = o;
         }
 
         LeftOverMethods leftOver = getLeftOverMethods(ignorables);
         if (leftOver != null) {
             String reason =
                     MessageHelper.putTogetherReason(methods, ignorables, methodsCalledList, "extra method(s)="
                             + leftOver + "\n");
             throw new ExpectFailedException("There was a method called after your expected methods.\n" + reason,
                     retVal, ExpectFailedException.UNEXPECTED_CALL_AFTER);
         }
 
         // clean up by removing the ignored methods
         for (String o : methods) {
             ignorables.remove(o);
         }
 
         return retVal;
     }
 
     /**
      * @see biz.xsoftware.mock.MockObject#expectOrderedCalls(java.lang.String[])
      */
     private synchronized CalledMethod[] expectImpl(String... methods) {
         if (methods == null)
             throw new IllegalArgumentException("methods cannot be null");
         else if (methods.length <= 0)
             throw new IllegalArgumentException("methods.length must be >= 1");
         for (int i = 0; i < methods.length; i++) {
             if (methods[i] == null)
                 throw new IllegalArgumentException("None of values in methods can be null, yet methods[" + i
                         + "] was null");
         }
 
         // validate the given methods
         for (String method : methods) {
             if (!method.equals(MockObject.ANY) && !method.equals(MockObject.NONE)) {
                 MethodVerifier.verifyMethodNameExist(getClasses(), method, isCaseSensitive);
             }
         }
 
         Set<String> ignorables = createIgnorableMap(ignoredMethods);
 
         List<CalledMethod> methodsCalledList = new ArrayList<CalledMethod>();
         CalledMethod[] retVal = new CalledMethod[methods.length];
         int i = 0;
         for (; i < methods.length; i++) {
             String method = methods[i];
 
             CalledMethod o = null;
             try {
                 o = expectUnignoredCall(method, ignorables, methodsCalledList);
             } catch (ExpectFailedException e) {
                 if (!ExpectFailedException.UNEXPECTED_ON_NONE.equals(e.getReason())) {
                     throw e;
                 }
                 CalledMethod[] leftOver = e.getCalledMethods();
                 throw new ExpectFailedException(e.getMessage(), leftOver, e.getReason());
             }
             if (o == null) {
                 String reason =
                         MessageHelper.putTogetherReason(methods, ignorables, methodsCalledList,
                                 "timed out on next expected method\n");
                 throw new ExpectFailedException("Timed out waiting for call=" + method + "\n" + reason, cleanup(retVal,
                         i), ExpectFailedException.TIMED_OUT);
             }
             retVal[i] = o;
 
             // see if the method method we're expecting matches the received
             // method name... with some case sensitive funny business
             if ((isCaseSensitive && !method.equals(o.getMethodName()) && !ANY.equals(method))
                     || (!isCaseSensitive && (!method.equalsIgnoreCase(o.getMethodName()) && !ANY.equals(method)))) {
                 String reason = MessageHelper.putTogetherReason(methods, ignorables, methodsCalledList, null);
                 reason += MessageHelper.getHowMethodWasCalled(o);
                 throw new ExpectFailedException(reason, cleanup(retVal, i), null);
             }
         }
 
         LeftOverMethods leftOver = getLeftOverMethods(ignorables);
         if (leftOver != null) {
             String reason =
                     MessageHelper.putTogetherReason(methods, ignorables, methodsCalledList, "extra method(s)="
                             + leftOver + "\n");
             reason += MessageHelper.getHowMethodWasCalled(leftOver.getMethods()[0]);
             CalledMethod[] calledOnes = new CalledMethod[retVal.length + 1];
             System.arraycopy(retVal, 0, calledOnes, 0, retVal.length);
             calledOnes[retVal.length] = leftOver.getMethods()[0];
             throw new ExpectFailedException("There was a method called after your expected methods.\n" + reason,
                     calledOnes, ExpectFailedException.UNEXPECTED_CALL_AFTER);
         }
 
         return retVal;
     }
 
     protected synchronized CalledMethod expectUnignoredCall(final String method, final Set<String> ignorables,
             final List<CalledMethod> calledMethods) {
 
         String expectedMethod = NONE;
 
         if (method != null) {
             expectedMethod = method;
         }
 
         // kind of dangerous if used with multiple threads because we might miss
         // a bad event coming in, but if you keep using the same listener for
         // every test
         // the problem should still manifest itself in a
         // different test case which sucks but works.
         if (expectedMethod.equals(NONE)) {
             if (log.isLoggable(Level.FINE)) {
                 log.log(Level.FINE, "method expected=" + NONE + " on obj=" + this);
             }
 
             // we have to strip out all of the ignored methods from
             // methodsCalled
             CalledMethod[] methods = methodsCalled.toArray(new CalledMethod[0]);
             for (CalledMethod calledMethod : methods) {
                 if (ignorables.contains(calledMethod.getMethodName())) {
                     while (methodsCalled.contains(calledMethod)) {
                         methodsCalled.remove(calledMethod);
                     }
                 }
             }
 
             LeftOverMethods leftOver = getLeftOverMethods(ignorables);
             if (leftOver != null) {
                 String reason =
                         "You were expecting no methods to be called, but method(s) not\n"
                                 + "in the ignore list were called earlier. method(s)=" + leftOver;
                 reason += MessageHelper.getHowMethodWasCalled(leftOver.getMethods()[0]);
                 throw new ExpectFailedException(reason, leftOver.getMethods(), ExpectFailedException.UNEXPECTED_ON_NONE);
             }
             return new CalledMethod(NONE, null, null);
         }
 
         try {
             return waitForUnignoredCall(expectedMethod, ignorables, calledMethods);
         } catch (InterruptedException e) {
             throw new RuntimeException(e);
         }
     }
 
     private CalledMethod waitForUnignoredCall(String logM, Set<String> ignorables, List<CalledMethod> calledMethods)
             throws InterruptedException {
 
         long waitTime2 = waitTime + 50;
         long currentTime;
         // only while waitTime is greater than 50 milliseconds
         while (waitTime2 >= 50) {
             // if there are no methods called yet, begin waiting
             if (methodsCalled.size() <= 0) {
                 currentTime = System.currentTimeMillis();
                 if (log.isLoggable(Level.FINE)) {
                     log.fine("method expected(not called yet-waiting)=" + logM + " on obj=" + this + " wait="
                             + waitTime2);
                 }
                 this.wait(waitTime2);
                 long waitedOnWait = System.currentTimeMillis() - currentTime;
                 waitTime2 -= waitedOnWait;
             }
 
             // check for new methods to be called now...if no non-ignorable
             // methods, then continue while loop
             for (int i = 0; i < methodsCalled.size(); i++) {
                 CalledMethod calledMethod = methodsCalled.remove(0);
                 calledMethods.add(calledMethod);
                 if (isCaseSensitive) {
                     if (!ignorables.contains(calledMethod.getMethodName())) {
                         if (log.isLoggable(Level.FINE)) {
                             log.fine("method expected and was called=" + logM + " on obj=" + this);
                         }
                         return calledMethod;
                     }
                 } else {
                     if (!ignorables.contains(calledMethod.getMethodName().toLowerCase())) {
                         if (log.isLoggable(Level.FINE)) {
                             log.fine("method expected and was called=" + logM + " on obj=" + this);
                         }
                         return calledMethod;
                     }
                 }
             }
         }
 
         // return null means timeout....
         return null;
     }
 
     private Set<String> createIgnorableMap(final Set<String> ignorableMethods) {
         final Set<String> ignorables = new HashSet<String>();
         if (ignorableMethods != null) {
             for (String method : ignorableMethods) {
                 if (isCaseSensitive) {
                     ignorables.add(method);
                 } else {
                     ignorables.add(method.toLowerCase());
                 }
             }
         }
         return ignorables;
     }
 
     private LeftOverMethods getLeftOverMethods(final Set<String> ignorables) {
         final List<CalledMethod> leftOver = new ArrayList<CalledMethod>();
         for (CalledMethod o : methodsCalled) {
             if (isCaseSensitive) {
                 if (o != null && !ignorables.contains(o.getMethodName())) {
                     leftOver.add(o);
                 }
             } else {
                 if (o != null && !ignorables.contains(o.getMethodName().toLowerCase())) {
                     leftOver.add(o);
                 }
             }
         }
         methodsCalled.clear();
 
         if (leftOver.size() <= 0) {
             return null;
         }
 
         return new LeftOverMethods(leftOver.toArray(new CalledMethod[0]));
     }
 
     private static final class LeftOverMethods {
 
         private final CalledMethod[] leftOver;
 
         public LeftOverMethods(CalledMethod[] m) {
             leftOver = m;
         }
 
         public CalledMethod[] getMethods() {
             return leftOver;
         }
 
         @Override
         public String toString() {
             String retVal = "";
             for (int i = 0; i < leftOver.length; i++) {
                 retVal += "\n" + leftOver[i].getMethodName();
             }
             return retVal;
         }
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#setDefaultBehavior(java.lang.String,
      *      biz.xsoftware.mock.Behavior)
      */
     public void setDefaultBehavior(String method, Behavior b) {
         setDefaultBehavior(new MethodSignature(method), b);
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#setDefaultBehavior(java.lang.String,
      *      biz.xsoftware.mock.Behavior, java.lang.Class<?>[])
      */
     @Deprecated
     public void setDefaultBehavior(String methodStr, Behavior b, Class<?>... argTypes) {
         setDefaultBehavior(new MethodSignature(methodStr, argTypes), b);
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#setDefaultBehavior(biz.xsoftware.mock.MethodSignature,
      *      biz.xsoftware.mock.Behavior)
      */
     public void setDefaultBehavior(MethodSignature methodSignature, Behavior b) {
         Method method = checkMethod(methodSignature.getName(), methodSignature.getParamTypes());
         setDefaultBehavior(method, b);
     }
 
     /**
      * This method should only be used when it is specifically necessary. The
      * passed in Method is not checked to insure the Method belongs to one of
      * the implemented interface classes. This was done intentionally because of
      * the BehaviorMethod(override) capability. The override is assuming the
      * user knows what they're doing
      * 
      * @param method Cannot be null
      * 
      * @param b Cannot be null
      */
     private void setDefaultBehavior(Method method, Behavior b) {
 
         if (method == null) {
             throw new NullPointerException("Method given cannot be null");
         }
 
         if (b == null) {
             throw new NullPointerException("Behavior given cannot be null");
         }
 
         BehaviorInfo action = createBehaviorInfo(method, b);
 
         methodToDefaultRetVal.put(method, action);
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#setDefaultReturnValue(java.lang.String,
      *      java.lang.Object)
      */
     public void setDefaultReturnValue(String method, Object returnValue) {
         setDefaultReturnValue(method, returnValue, new Class[] {});
     }
 
     public void setDefaultReturnValue(String methodStr, Object o, Class<?>... argTypes) {
         Method method = checkMethod(methodStr, argTypes);
 
         methodToDefaultRetVal.put(method, new ReturnValue(o));
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#setDefaultReturnValue(java.lang.reflect.Method,
      *      java.lang.Object)
      */
     public void setDefaultReturnValue(Method method, Object o) {
         methodToDefaultRetVal.put(method, new ReturnValue(o));
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#setBehavior(biz.xsoftware.mock.Behavior)
      */
     public void setBehavior(Behavior behavior) {
         // loop through all the methods in the given Behavior class and add the
         // found methods that are annotated with the BehaviorMethod
         for (Method m : behavior.getClass().getMethods()) {
             BehaviorMethod a = (BehaviorMethod) m.getAnnotation(BehaviorMethod.class);
             if (a != null) {
                 if (!a.override().equals(void.class)) {
                     // the user has attempted to override the Behavior class
                     // with a specific
                     // class type
                     try {
                         Method overrideMethod = a.override().getMethod(m.getName(), m.getParameterTypes());
                         // using the override method here because don't want to
                         // store the behavior using the interface
                         // method as the key. Instead we want to store the
                         // behavior using the override object's method
                         setDefaultBehavior(overrideMethod, behavior);
                     } catch (SecurityException e) {
                         throw new IllegalArgumentException(e);
                     } catch (NoSuchMethodException e) {
                         throw new IllegalArgumentException("The Behavior given attempted to override a method that"
                                 + " does not exist in the given override class", e);
                     }
                 } else {
                     // we need to build a MethodSignature here because we want
                     // to store the called method using the
                     // interface, not the Behavior's method
                     setDefaultBehavior(new MethodSignature(m.getName(), m.getParameterTypes()), behavior);
                 }
             }
         }
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#addBehavior(java.lang.String,
      *      biz.xsoftware.mock.Behavior)
      */
     public void addBehavior(String method, Behavior behavior) {
         addBehavior(new MethodSignature(method, (Class<?>[]) null), behavior);
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#addBehavior(java.lang.String,
      *      biz.xsoftware.mock.Behavior, java.lang.Class<?>[])
      */
     @Deprecated
     public void addBehavior(String method, Behavior behavior, Class<?>... argTypes) {
         addBehavior(new MethodSignature(method, argTypes), behavior);
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#addBehavior(biz.xsoftware.mock.MethodSignature,
      *      biz.xsoftware.mock.Behavior)
      */
     public void addBehavior(MethodSignature methodSignature, Behavior behavior) {
         if (methodSignature == null)
             throw new NullPointerException("methodSignature parameter cannot be null");
 
         if (behavior == null)
             throw new NullPointerException("behavior parameter cannot be null");
 
         Method m = MethodVerifier.getMethod(getClasses(), methodSignature, isCaseSensitive);
 
         BehaviorInfo action = createBehaviorInfo(m, behavior);
 
         addToActionList(action, m);
     }
 
     /**
      * Creates a BehaviorInfo instance using the given {@link Method} and
      * {@link Behavior}
      * 
      * @param classMethod The method to attach the given {@link Behavior} to
      * 
      * @param behavior The {@link Behavior} object that implements the method
      * 
      * @return The built object
      */
     private BehaviorInfo createBehaviorInfo(Method classMethod, Behavior behavior) {
         BehaviorInfo action = null;
 
         // verify behavior has correct methods
         Class<?> clazz = behavior.getClass();
 
         try {
             Method behaviorMethod =
                     clazz.getMethod(classMethod.getName(), (Class<?>[]) classMethod.getParameterTypes());
             action = new BehaviorInfo(behavior, behaviorMethod);
             behaviorMethod.setAccessible(true);
         } catch (SecurityException e) {
             throw new RuntimeException("Your Behavior class seems to be too secure.  "
                     + "I can't reflect on it and call getClass on it's class object");
         } catch (NoSuchMethodException e) {
             String methodSig = MessageHelper.getMethodSignature(null, classMethod, "");
             throw new IllegalArgumentException("You Behavior class is missing the method='" + methodSig);
         }
 
         try {
             if (!(behavior instanceof CloningBehavior))
                 return action;
 
             Method clonerMethod =
                     clazz.getMethod(classMethod.getName() + "Cloner", (Class<?>[]) classMethod.getParameterTypes());
             action.setClonerMethod(clonerMethod);
             if (!Object[].class.isAssignableFrom(clonerMethod.getReturnType()))
                 throw new IllegalArgumentException("Method=" + clonerMethod
                         + " does not return Object[] which it must do");
             clonerMethod.setAccessible(true);
         } catch (SecurityException e) {
             throw new RuntimeException("Your Behavior class seems to be too secure.  "
                     + "I can't reflect on it and call getClass on it's class object");
         } catch (NoSuchMethodException e) {
             String methodSig = MessageHelper.getMethodSignature("Object[]", classMethod, "Cloner");
             throw new IllegalArgumentException("You Behavior class is missing the method='" + methodSig);
         }
         return action;
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#addThrowException(java.lang.String,
      *      java.lang.Throwable)
      */
     public void addThrowException(String method, Throwable e) {
         addThrowException(new MethodSignature(method, (Class<?>[]) null), e);
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#addThrowException(biz.xsoftware.mock.MethodSignature,
      *      java.lang.Throwable)
      */
     public void addThrowException(MethodSignature ms, Throwable e) {
         Method m = MethodVerifier.getMethod(getClasses(), ms, isCaseSensitive);
         Action action = new ThrowException(e);
         addToActionList(action, m);
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#addReturnValue(java.lang.String,
      *      java.lang.Object[])
      */
     public void addReturnValue(String method, Object... objects) {
         addReturnValue(new MethodSignature(method, (Class<?>[]) null), objects);
     }
     
     /**
      * @deprecated  {@link #addReturnValue(Method, Object...)} was enhanced to detect if the given method returns
      * an array.  If it does then the object array passed in will be the object returned for a single method call
      */
     @Deprecated
     public void addReturnValue(String method, boolean isArray, Object... objects) {
         addReturnValue(method, objects);
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#addReturnValue(biz.xsoftware.mock.MethodSignature,
      *      java.lang.Object[])
      */
     public void addReturnValue(MethodSignature methodSignature, Object... objects) {
         Method m = MethodVerifier.getMethod(getClasses(), methodSignature, isCaseSensitive);
         // determine if the return type is an array, if it is then we'll assume
         // that the objects passed in is the array to set as the result
         if (m.getReturnType().isArray()) {
             if (objects.getClass().getName().startsWith("[[")) {
                 // for primitive type arrays for some reason we get an Object
                 // array that contains the primitive array.  This [[ appears
                 // to be unique to this situation (not the best implementation though)
                 addToActionList(new ReturnValue(objects[0]), m);
             } else {
                 addToActionList(new ReturnValue(objects), m);
             }
         } else {
             for (Object o : objects) {
                 Action action = new ReturnValue(o);
                 addToActionList(action, m);
             }
         }
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#addReturnValue(biz.xsoftware.mock.MethodSignature,
      *      java.lang.Object[])
      */
     public void addReturnValue(Method method, Object... objects) {
         if (method.getReturnType().isArray()) {
             addToActionList(new ReturnValue(objects), method);
         } else {
             for (Object o : objects) {
                 addToActionList(new ReturnValue(o), method);
             }
         }
     }
 
     /**
      * Adds the given action to the end of {@link Action} list mapped to the
      * given method
      * 
      * @param action
      * @param method
      */
     private void addToActionList(Action action, Method method) {
         List<Action> l = methodToReturnVal.get(method);
         if (l == null) {
             l = new ArrayList<Action>();
             methodToReturnVal.put(method, l);
         }
 
         l.add(action);
     }
 
     /**
      * This is the method that calls the cloner to clone objects like ByteBuffer
      * that can change after they are called.
      * 
      * @param o
      * @return
      * @throws Throwable
      */
     private Object[] clone(Method method, Object[] params) throws Throwable {
         if (params == null)
             return null;
 
         Action action = methodToDefaultRetVal.get(method);
 
         // now override the default if there is an override specified...
         List<Action> actions = methodToReturnVal.get(method);
         if (actions != null) {
             action = actions.get(0);
         }
 
         // check if action is a behaviorInfo object
         if (action instanceof BehaviorInfo) {
             BehaviorInfo behavior = (BehaviorInfo) action;
             if (behavior.hasClonerMethod())
                 return behavior.runClonerMethod(params);
         }
 
         return params;
     }
 
     public Class<?>[] getClasses() {
         return new Class<?>[] { this.getClass() };
     }
 
     /**
      * Looks for the method in the object
      * 
      * @param method The object's method to check for
      * @param argTypes The method argument types
      * @return The found method or null if not found
      */
     private Method checkMethod(String method, Class<?>[] argTypes) {
         return MethodVerifier.getMethod(getClasses(), new MethodSignature(method, argTypes), isCaseSensitive);
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#isCaseSensitive()
      */
     public boolean isCaseSensitive() {
         return isCaseSensitive;
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#setCaseSensitive(boolean)
      */
     public void setCaseSensitive(boolean isCaseSensitive) {
         this.isCaseSensitive = isCaseSensitive;
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see biz.xsoftware.mock.MockObject#reset()
      */
     public void reset() {
         methodsCalled.clear();
         ignoredMethods.clear();
         methodToReturnVal.clear();
         methodToDefaultRetVal.clear();
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see java.lang.Object#toString()
      */
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
         sb.append(id);
         sb.append(":");
         sb.append(super.toString());
         return sb.toString();
     }
 }