[MO-java-dev] CVS: mockobjects-java/src/core/com/mockobjects/dynamic CallableList.java,NONE,1.1 CallBag.java,1.5,1.6 CallCollection.java,1.4,1.5 CallSequence.java,1.7,1.8

[Steve F. <sm...@us...>]

Update of /cvsroot/mockobjects/mockobjects-java/src/core/com/mockobjects/dynamic
In directory sc8-pr-cvs1:/tmp/cvs-serv1086/src/core/com/mockobjects/dynamic

Modified Files:
	CallBag.java CallCollection.java CallSequence.java 
Added Files:
	CallableList.java 
Log Message:
restructured CallBag, CallCollection, and CallSequence. Factored out CallableList

--- NEW FILE: CallableList.java ---
/*
 * Copyright mockobjects.com 05-Jul-2003
 */
package com.mockobjects.dynamic;

import java.util.ArrayList;

import com.mockobjects.Verifiable;

public class CallableList implements Verifiable {
	public interface Handler  {
		Callable handle(int index, Callable callable);
	}
	
	public ArrayList list = new ArrayList();
	
	public void add(Callable callable)  {
		list.add(callable);
	}
	
	public boolean isEmpty()  {
		return list.isEmpty();
	}

	public Callable get(int index) {
		return (Callable)list.get(index);
	}

	public int size() {
		return list.size();
	}

	public void clear()  {
		list.clear();
	}

	public Callable firstMatchingCall(final ActiveCall call) {
		return apply(new Handler()  {
			public Callable handle(int index, Callable callable)  {
				return callable.matches(call) ? callable : null;
			}
		});
	}

	public Callable apply(final Handler handler)  {
		for (int i = 0; i < list.size(); i++) 	 {
			Callable result = handler.handle(i, (Callable)list.get(i));
			if (null != result)  {
				return result;
			}
		}
		return null;
	}
	
	public void verify() {
		apply(new Handler()  {
			public Callable handle(int index, Callable callable)  {
				callable.verify();
				return null;
			}
		});
	}
}

Index: CallBag.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/com/mockobjects/dynamic/CallBag.java,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -r1.5 -r1.6
--- CallBag.java	5 Jul 2003 15:15:54 -0000	1.5
+++ CallBag.java	5 Jul 2003 16:35:51 -0000	1.6
@@ -3,82 +3,37 @@
  */
 package com.mockobjects.dynamic;
 
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-
-
-public class CallBag extends CallCollection implements Callable, CallableAddable {
-	private List expectedCalls = new ArrayList();
-	private List expectedMatches = new ArrayList();
-
-	public CallBag() {
-	}
-
-    public void reset() {
-        this.expectedCalls.clear();
-        this.expectedMatches.clear();
-    }
 
+public class CallBag extends CallCollection  {
 	public Object call(ActiveCall call)
 		throws Throwable {
 			
-		Callable matchingCall = findMatchingCall(call, this.expectedCalls);
-		if(matchingCall == null) {
-			matchingCall = findMatchingCall(call, this.expectedMatches);
-		}
-		if(matchingCall == null) {
-			throw createUnexpectedCallError(call);
+		Callable foundCall = expectedCalls.firstMatchingCall(call);
+		if (foundCall == null) {
+			foundCall = findMatchingCall(call);
 		}
 		
-		return matchingCall.call(call);
-	}
-
-	private Callable findMatchingCall(ActiveCall call, List callList) {
-		for (Iterator nextCall = callList.iterator(); nextCall.hasNext();) {
-			Callable element = (Callable) nextCall.next();
-
-			if (element.matches(call)) {
-				return element;
-			}
-		}
-
-		return null;
+		return foundCall.call(call);
 	}
 
 	public String getDescription() {
-		if (this.expectedCalls.isEmpty()) {
+		if (expectedCalls.isEmpty()) {
 			return "no methods";
 		} else {
-			StringBuffer buf = new StringBuffer();
+			final StringBuffer buf = new StringBuffer();
 
 			buf.append("one of:\n");
 
-			for (Iterator i = this.expectedCalls.iterator(); i.hasNext();) {
-				buf.append(((Callable) i.next()).getDescription());
-				buf.append("\n");
-			}
+			expectedCalls.apply(
+				new CallableList.Handler()  {
+					public Callable handle(int index, Callable callable)  {
+						buf.append(callable.getDescription());
+						buf.append("\n");
+						return null;
+					}					
+				});
 
 			return buf.toString();
 		}
-	}
-
-	public boolean matches(ActiveCall activeCall) {
-		throw new Error("not implemented");
-	}
-
-	public void verify() {
-		for (Iterator call = this.expectedCalls.iterator(); call.hasNext();) {
-			Callable element = (Callable) call.next();
-			element.verify();
-		}
-	}
-
-	public void addExpect(Callable call) {
-		this.expectedCalls.add(call);
-	}
-
-	public void addMatch(Callable call) {
-		this.expectedMatches.add(call);
 	}
 }

Index: CallCollection.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/com/mockobjects/dynamic/CallCollection.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- CallCollection.java	5 Jul 2003 15:15:54 -0000	1.4
+++ CallCollection.java	5 Jul 2003 16:35:51 -0000	1.5
@@ -2,10 +2,35 @@
 
 import junit.framework.AssertionFailedError;
 
-abstract public class CallCollection {
+abstract public class CallCollection implements Callable, CallableAddable {
 
-    protected AssertionFailedError createUnexpectedCallError(ActiveCall call) {
-            
+	abstract public String getDescription();
+
+	public boolean matches(ActiveCall activeCall) {
+		throw new AssertionFailedError("matches() operation not supported in CallCollection");
+	}
+
+	public void reset() {
+		expectedCalls.clear();
+		matchingCalls.clear();
+	}
+
+	public void addExpect(Callable call) {
+		this.expectedCalls.add(call);
+	}
+
+	public void addMatch(Callable call) {
+		this.matchingCalls.add(call);
+	}
+
+	public void verify() {
+		expectedCalls.verify();
+	}
+
+	protected CallableList expectedCalls = new CallableList();
+	protected CallableList matchingCalls = new CallableList();
+
+    protected AssertionFailedError createUnexpectedCallError(ActiveCall call) {            
         StringBuffer buf = new StringBuffer();
         buf.append("Unexpected call: ");
         buf.append(DynamicUtil.methodToString(call));
@@ -15,5 +40,12 @@
         return new AssertionFailedError(buf.toString());
     }
 
-    abstract protected String getDescription();
+	protected Callable findMatchingCall(ActiveCall call) throws AssertionFailedError {
+		Callable foundCall = matchingCalls.firstMatchingCall(call);
+		if (foundCall == null) {
+			throw createUnexpectedCallError(call);
+		}
+		return foundCall;
+	}
+
 }

Index: CallSequence.java
===================================================================
RCS file: /cvsroot/mockobjects/mockobjects-java/src/core/com/mockobjects/dynamic/CallSequence.java,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -r1.7 -r1.8
--- CallSequence.java	5 Jul 2003 15:15:54 -0000	1.7
+++ CallSequence.java	5 Jul 2003 16:35:51 -0000	1.8
@@ -1,73 +1,45 @@
 package com.mockobjects.dynamic;
 
-import java.util.ArrayList;
-import java.util.Iterator;
-
 import junit.framework.AssertionFailedError;
 
-public class CallSequence extends CallCollection implements Callable, CallableAddable {
+public class CallSequence extends CallCollection {
 	
-	private ArrayList expectedCalls = new ArrayList();
-	private CallBag matchedCalls = new CallBag();
 	int callIndex = 0;
 	
-    public void reset()
-    {
-        this.expectedCalls.clear();
-        this.matchedCalls.reset();        
-    }
-    
-	public Object call(ActiveCall activeCall) throws Throwable {
-		if (expectedCalls.size() == 0) throw new AssertionFailedError("no methods defined on mock, received: " + DynamicUtil.methodToString(activeCall));
-		if (callIndex == expectedCalls.size()) throw new AssertionFailedError("mock called too many times, received: " + DynamicUtil.methodToString(activeCall));
+    public Object call(ActiveCall activeCall) throws Throwable {
+		if (expectedCalls.isEmpty()) 
+			throw new AssertionFailedError("no methods defined on mock, received: " + DynamicUtil.methodToString(activeCall));
+		if (callIndex == expectedCalls.size()) 
+			throw new AssertionFailedError("mock called too many times, received: " + DynamicUtil.methodToString(activeCall));
 		
-		Callable callable = (Callable)expectedCalls.get(callIndex++);
-		if (callable.matches(activeCall))
+		Callable callable = expectedCalls.get(callIndex++);
+		if (callable.matches(activeCall)) {
+			//TODO shouldn't callIndex be incremented here?
 			return callable.call(activeCall);
-			
-		try {
-			return matchedCalls.call(activeCall);
-		} catch (AssertionFailedError ex) {
-			throw createUnexpectedCallError(activeCall);
 		}
+			
+		return findMatchingCall(activeCall).call(activeCall);
 	}
 
     public String getDescription() {
         if (expectedCalls.isEmpty()) {
             return "no methods";
         } else {
-            StringBuffer buf = new StringBuffer();
-    
+            final StringBuffer buf = new StringBuffer();
             buf.append("in sequence:\n");
     
-            int j=0;
-            for (Iterator i = expectedCalls.iterator(); i.hasNext();) {
-                buf.append(((Callable)i.next()).getDescription());
-                if (j++==(callIndex-1)) buf.append(" <<< Next Expected Call");
-                buf.append("\n");
-            }
-    
+			expectedCalls.apply(
+				new CallableList.Handler()  {
+					public Callable handle(int index, Callable callable)  {
+						buf.append(callable.getDescription());
+						if (index == (callIndex - 1)) 
+							buf.append(" <<< Next Expected Call");
+						buf.append("\n");
+						return null;
+					}					
+				});
             return buf.toString();
         }
     }
-    
-	public boolean matches(ActiveCall activeCall) {
-		throw new AssertionFailedError("matches() operation not supported in CallSequence");
-	}
-
-	public void addExpect(Callable call) {
-		expectedCalls.add(call);
-	}
-	
-	public void addMatch(Callable call) {
-		matchedCalls.addMatch(call);
-	}
-
-	public void verify() {
-		for (Iterator iter = expectedCalls.iterator(); iter.hasNext();) {
-			Callable callable = (Callable) iter.next();
-			callable.verify();
-		}
-	}
 
 }