From e4d0b3d00494106ef641eb53bdb8789ca8cb9ca4 Mon Sep 17 00:00:00 2001
From: erik <erik@77661180-640e-0410-b3a8-9f9b13e6d0e0>
Date: Wed, 16 Jul 2008 10:13:22 +0000
Subject: [PATCH] resettablemock now also works with concrete classes with a
 default constructor. Non-default constructors cannot be supported since that
 would require support from mockito as well (spy() functionality).

---
 .../java/org/wamblee/test/ResettableMock.java | 169 ++++++++++--------
 1 file changed, 93 insertions(+), 76 deletions(-)

diff --git a/support/general/src/test/java/org/wamblee/test/ResettableMock.java b/support/general/src/test/java/org/wamblee/test/ResettableMock.java
index 47cc6747..4e321566 100644
--- a/support/general/src/test/java/org/wamblee/test/ResettableMock.java
+++ b/support/general/src/test/java/org/wamblee/test/ResettableMock.java
@@ -6,90 +6,107 @@ package org.wamblee.test;
 import static org.mockito.Mockito.*;
 
 import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 
+import net.sf.cglib.proxy.Enhancer;
+import net.sf.cglib.proxy.MethodInterceptor;
+import net.sf.cglib.proxy.MethodProxy;
+
 /**
- * Resettable mock is a utility to support reset functionality for mockito. 
+ * Resettable mock is a utility to support reset functionality for mockito.
+ * 
  * @author Erik Brakkee
- *
+ * 
  * @param <T>
  */
 public class ResettableMock<T> {
 
-	private static class MockitoInvocationHandler<T> implements
-			InvocationHandler {
-
-		private Class<T> _class;
-		private T _mock;
-
-		public MockitoInvocationHandler(Class<T> aClass) {
-			_class = aClass;
-			_mock = mock(aClass);
-		}
-
-		public void reset() {
-			_mock = mock(_class);
-		}
-
-		public T getMock() {
-			return _mock;
-		}
-
-		@Override
-		public Object invoke(Object aProxy, Method aMethod, Object[] aArgs)
-				throws Throwable {
-			return aMethod.invoke(_mock, aArgs);
-		}
-	}
-
-	/**
-	 * Invocation handler that delegates to the current mockito mock and allows
-	 * creation of a new mock. 
-	 */
-	private ResettableMock.MockitoInvocationHandler<T> _handler;
-	
-	/**
-	 * Proxy object to be passed to tested classes. 
-	 */
-	private T _proxy;
-
-	/**
-	 * Constructs the resettable mock. 
-	 * @param aType Type to mock. Must be an interface type. 
-	 */
-	public ResettableMock(Class<T> aType) {
-		if ( !aType.isInterface()) { 
-			throw new IllegalArgumentException("Class '" + aType.getName() + "' must be an interface");
-		}
-		_handler = new MockitoInvocationHandler(aType);
-		_proxy = (T) Proxy.newProxyInstance(aType.getClassLoader(),
-				new Class[] { aType }, _handler);
-	}
-
-	/**
-	 * Resets the mock effectively forgetting all previous interactions and verifications. 
-	 */
-	public void reset() {
-		_handler.reset();
-	}
-
-	/**
-	 * Gets the current mock object to pass to mockito calls. 
-	 * 
-	 * @return Mock object.
-	 */
-	public T getMock() {
-		return _handler.getMock();
-	}
-
-	/**
-	 * Returns the proxy that your tested classes will used.
-	 * 
-	 * @return Proxy object.
-	 */
-	public T getProxy() {
-		return _proxy;
-	}
+    private static class MockitoInvocationHandler<T> implements
+            MethodInterceptor {
+
+        private Class<T> _class;
+        private T _mock;
+
+        public MockitoInvocationHandler(Class<T> aClass) {
+            _class = aClass;
+            _mock = mock(aClass);
+        }
+
+        public void reset() {
+            _mock = mock(_class);
+        }
+
+        public T getMock() {
+            return _mock;
+        }
+
+        @Override
+        public Object intercept(Object aProxy, Method aInterceptedMethod,
+                Object[] aArgs, MethodProxy aMethodProxy) throws Throwable {
+            try {
+                return aInterceptedMethod.invoke(_mock, aArgs);
+            } catch (InvocationTargetException e) {
+                throw e.getCause();
+            }
+        }
+    }
+
+    /**
+     * Invocation handler that delegates to the current mockito mock and allows
+     * creation of a new mock.
+     */
+    private ResettableMock.MockitoInvocationHandler<T> _handler;
+
+    /**
+     * Proxy object to be passed to tested classes.
+     */
+    private T _proxy;
+
+    /**
+     * Constructs the resettable mock.
+     * 
+     * @param aType
+     *            Type to mock. Must be an interface or a non-final class with a 
+     *            default constructor.
+     */
+    public ResettableMock(Class<T> aType) {
+        if (!aType.isInterface()) {
+            throw new IllegalArgumentException("Class '" + aType.getName()
+                    + "' must be an interface");
+        }
+        _handler = new MockitoInvocationHandler(aType);
+        Enhancer enhancer = new Enhancer();
+        enhancer.setSuperclass(aType);
+        enhancer.setCallback(_handler);
+        _proxy = (T) enhancer.create();
+    }
+
+    /**
+     * Resets the mock effectively forgetting all previous interactions and
+     * verifications.
+     */
+    public void reset() {
+        _handler.reset();
+    }
+
+    /**
+     * Gets the current mock object to pass to mockito calls.
+     * 
+     * @return Mock object.
+     */
+    public T getMock() {
+        return _handler.getMock();
+    }
+
+    /**
+     * Returns the proxy that your tested classes will used.
+     * 
+     * @return Proxy object.
+     */
+    public T getProxy() {
+        return _proxy;
+    }
 
 }
\ No newline at end of file
-- 
2.31.1