无聊写了个单元测试的基类，准备拿回公司用

package net.daniel.test;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.jmock.Mockery;
import org.jmock.lib.legacy.ClassImposteriser;
import org.junit.Before;
import org.objenesis.Objenesis;
import org.objenesis.ObjenesisStd;

/**
 * 本测试用例适用于JUnit4，提供以下功能：
 * 1. 通过标注（Annotation）进行测试用例对象域的创建和注入。提供以下标注：
 *  a）@Mock private MyType myField; 自动创建MyType类型的Mock对象，赋值给myField；
 *  b) @Create private MyType myField; 自动创建MyType类型的对象实例，赋值给myField；
 *  c）@Create @Inject private MyType myField; 自动创建MyType类型的对象，赋值给myField，并且注入到被测试用例的同名对象域中。
 * 2. 可通过反射机制直接访问被测试用例（或其它对象）的不可见对象域，支持继承的对象域；
 * 3. 可通过反射机制直接调用被测试用例（或其它对象）的不可见方法，支持继承的方法，支持自动匹配与参数表最接近的重载方法签名，无须另行指定参数类型列表。
 * 4. 支持通过Objnesis机制创建类实例
 * 5. 支持按测试用例对象域名称获取合适的mockery对象类型
 * 6. 提供若干集合处理的便利方法
 *
 * @author Daniel Deng
 * 
 * @param <CUT> 被测试的类型
 *            
 */
public abstract class AbstractTestCase<CUT> {

    /**
     * 被测试的对象
     */
    protected CUT toTest;

    /**
     * 用于Mock接口的Mockery
     */
    protected Mockery interfaceMockery = new Mockery();

    /**
     * 用于Mock具体类的Mockery
     */
    protected Mockery classMockery = new Mockery(){{
        setImposteriser(ClassImposteriser.INSTANCE);
    }};

    /**
     * 当前TestCase对象域的缓存，包括祖先类中的对象域。
     */
    private Map<String, Field> mockedFields,
                               createFields,
                               injectFields,
                               allFields;

    /**
     * 被测试对象的对象域缓存，包括祖先类中的对象域。
     */
    private Map<String, Field> sutFields;

    /**
     * 用于强行创建类实例的Objenesis对象，详情参考 http://code.google.com/p/objenesis/
     */
    private Objenesis objenesis;

    /**
     * 每次测试前执行的初始化方法，JUnit将保证此方法会在子类的@Before方法之前执行。
     * 在本基类中，此方法负责处理标注与注入
     * @throws Exception
     */
    @Before
    public void init() throws Exception {
        applyAnntation();
        toTest = createSUT();
        applyInjection();
    }

    /**
     * 子类应覆盖此方法，创建并返回被测试类的实例。
     * 此方法将在@Mock与@Create标注处理完成后才被调用。如果需要的话，在创建被测试类实例时可使用这些被标注的对象域。
     */
    protected abstract CUT createSUT();

    /**
     * 处理注入（{@link Inject}）标注。此方法应在createSUT()方法之后调用。
     * 
     * 
     * @throws Exception
     */
    protected void applyInjection() throws Exception {
        prepareSUTFields();
        for (Field f : injectFields.values()) {
            Inject injectAnno = f.getAnnotation(Inject.class);
            String injectFieldName = injectAnno.value();
            if (injectFieldName == null) injectFieldName = f.getName();
            Field fieldToInject = sutFields.get(injectFieldName);
            if (fieldToInject == null) {
                throw new NoSuchFieldException("Field [" + injectFieldName + "] is not found in Class [" + toTest.getClass().getName() + "].");
            }
             fieldToInject.set(toTest, f.get(this));
        }
    }

    private void prepareSUTFields() {
        if (sutFields == null) {
            Class<?> clazz = toTest.getClass();
            sutFields = newHashMap();
            while (notAtTopLevel(clazz)) {
                Field[] fields = clazz.getDeclaredFields();
                for (Field f : fields) {
                    f.setAccessible(true);
                    String fname = f.getName();
                    if (!sutFields.containsKey(fname)) {
                        sutFields.put(fname, f);
                    }
                }
                clazz = clazz.getSuperclass();
            }
        }
    }

    /**
     * 通过 Objenesis机制来强制创建类实例，不会执行构造方法.
     * @param clazz 需要创建实例的类
     * @return
     */
    @SuppressWarnings("unchecked")
    protected <T> T forceCreate(Class<T> clazz) {
        if (objenesis == null) objenesis = new ObjenesisStd();
        return ((T) objenesis.getInstantiatorOf(clazz).newInstance());
    }

    private void performCreateFields() throws Exception {

        for (Field f : createFields.values()) {
            Create create = f.getAnnotation(Create.class);
            assert (create != null);
            Class<?> clazz = create.value();
            if (clazz == Object.class) {
                clazz = f.getType();
            }
            Constructor<?> constructor = null;
            Object newInstance = normalInstanciate(clazz, constructor);

            if (newInstance == null) {
                newInstance = forceCreate(clazz);
            }

            if (newInstance != null) {
                f.set(this, newInstance);
            } else {
                throw new RuntimeException("Type [" + clazz.getName()
                        + "] of field [" + f.getName()
                        + "] cannot instanciate.");
            }
        }
    }

    private Object normalInstanciate(Class<?> clazz, Constructor<?> constructor) {
        Object newInstance = null;
        try {
            constructor = clazz.getConstructor();
        } catch (Exception e) {
            // Will be handled by objenesis later
        }
        if (constructor != null) {
            try {
                newInstance = clazz.newInstance();
            } catch (Exception e) {
                // Will be handled by objenesis later
            }
        }
        return newInstance;
    }

    /**
     * 处理{@link Create}与{@link Mock}标注，实例化测试用例的对象域
     * @throws Exception
     */
    protected void applyAnntation() throws Exception {
        prepareTestCaseFields();
        performCreateFields();
        performMockFields();
    }

    private void performMockFields() throws Exception{
        for (Field f : mockedFields.values()) {
            Class<?> clazz = f.getType();
            if (clazz.isInterface()) {
                f.set(this, interfaceMockery.mock(clazz));
            } else {
                f.set(this, classMockery.mock(clazz));
            }
        }
    }

    /**
     * JMock需要根据Mock对象的类型不同而选用不同的mockery实例，容易引起混淆和错误。此方法将根据传入的测试用例对象域名称自动选用合适的mockery实例。
     * @param fieldName 采用了Mock对象的测试用例对象域名称
     * @return 与指定对象域类型对应的Mockery实例
     * @throws Exception
     */
    protected Mockery mockery(String fieldName) throws Exception {
        prepareTestCaseFields();
        Field f = allFields.get(fieldName);
        if (f == null) throw new NoSuchFieldException("Field [" + fieldName + "] is not found in Class [" + this.getClass().getName() + "]");
        if (f.getType().isInterface()) {
            return interfaceMockery;
        } else {
            return classMockery;
        }
    }

    private void prepareTestCaseFields() {
        if (mockedFields == null) {
            Class<?> clazz = this.getClass();
            mockedFields = newHashMap();
            createFields = newHashMap();
            injectFields = newHashMap();
            allFields = newHashMap();
            while (notAtTopLevel(clazz)) {
                Field[] fields = clazz.getDeclaredFields();
                for (Field f : fields) {
                    f.setAccessible(true);
                    String fname = f.getName();
                    if (!allFields.containsKey(fname)) {
                        allFields.put(fname, f);
                    }
                    if (f.getAnnotation(Mock.class) != null
                            && !mockedFields.containsKey(fname)) {
                        mockedFields.put(fname, f);
                    }
                    if (f.getAnnotation(Create.class) != null
                            && !createFields.containsKey(fname)) {
                        createFields.put(fname, f);
                    }
                    if (f.getAnnotation(Inject.class) != null
                            && !injectFields.containsKey(fname)) {
                        injectFields.put(fname, f);
                    }
                }
                clazz = clazz.getSuperclass();
            }
        }
    }

    /**
     * 绕过可见性限制，为被测试对象的对象域赋值
     * @param fieldName 要赋值的对象域名称
     * @param value 将要赋予对象域的值
     * @throws Exception
     */
    protected void setSUTField(String fieldName, Object value) throws Exception {
        Field f = findSUTField(fieldName);
        f.set(toTest, value);
    }

    /**
     * 绕过可见性限制，获取被测试对象的对象域取值
     * @param fieldName 要获取的对象域名称
     * @return 被测试对象中指定对象域的取值
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    protected <T> T getSUTField(String fieldName) throws Exception {
        Field f = findSUTField(fieldName);
        return (T) f.get(toTest);
    }

    private Field findSUTField(String fieldName) throws NoSuchFieldException {
        prepareSUTFields();
        Field f = sutFields.get(fieldName);
        if (f == null) throw new NoSuchFieldException("Field [" + fieldName + "] is not found in Class [" + toTest.getClass().getName() + "]");
        f.setAccessible(true);
        return f;
    }

    /**
     * 绕过可见性限制，为一个指定对象的对象域赋值
     * @param obj 需要赋值的对象实例
     * @param fieldName 要赋值的对象域名称
     * @param value 将要赋予对象域的值
     * @throws Exception
     */
    protected void setField(Object obj, String fieldName, Object value) throws Exception {
        Field f = findField(obj, fieldName);
        f.set(obj, value);
    }

    /**
     * 绕过可见性限制，获取一个指定对象的对象域取值
     * @param obj 需要获取对象域取值的对象实例
     * @param fieldName 要获取的对象域名称
     * @return 指定对象中指定对象域的取值
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    protected <T> T getField(Object obj, String fieldName) throws Exception {
        Field f = findField(obj, fieldName);
        return (T) f.get(obj);
    }

    /**
     * 获取指定对象中指定名称的对象域反射引用
     * @param obj 指定的对象实例
     * @param fieldName 对象域名称
     * @return
     * @throws Exception
     */
    protected Field findField(Object obj, String fieldName) throws Exception {
        Class<?> clazz = obj.getClass();
        Field field = null;
        while (notAtTopLevel(clazz)) {
            try {
                field = clazz.getDeclaredField(fieldName);
            }catch (NoSuchFieldException e) {
                //leave the field as null
            }
            if (field != null) {
                field.setAccessible(true);
                return field;
            }
            clazz = clazz.getSuperclass();
        }
        throw new NoSuchFieldException("Field [" + fieldName + "] is not found in Class [" + toTest.getClass().getName() + "]");
    }

    private boolean notAtTopLevel(Class<?> clazz) {
        return clazz != null && clazz != Object.class;
    }

    /**
     * 绕过可见性限制，调用被测试对象实例中的指定方法（包括父类中的方法）。本方法将根据传入的参数表自动选择匹配的重载方法。
     * @param methodName 方法名称
     * @param parameters 调用阐述表
     * @return 调用方法的返回值
     * @throws Exception
     */
    protected <T> T invokeSUTMethod(String methodName, Object... parameters) throws Exception {
        return invokeMethod(toTest, methodName, parameters);
    }

    /**
     * 绕过可见性限制，调用指定对象实例中的指定方法（包括父类中的方法）。本方法将根据传入的参数表自动选择匹配的重载方法。
     * @param obj 指定的对象实例
     * @param methodName 方法名称
     * @param parameters 调用阐述表
     * @return 调用方法的返回值
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    protected <T> T invokeMethod(Object obj, String methodName, Object... parameters) throws Exception {
        Method m = findMethod(obj.getClass(), methodName, map(Arrays.asList(parameters), new Fun1<Object, Class<?>>(){
            public Class<?> f(Object arg0) throws Exception {
                return arg0 != null ? arg0.getClass() : null;
            }
        }));
        return (T) m.invoke(obj, parameters);
    }

    /**
     * 获取指定基础类型的对应装箱类型。
     * @param clazz 需要装箱的类型
     * @return 如果clazz为java基础类型，返回其对应的装箱类型。否则，返回clazz本身。
     */
    protected Class<?> Boxing(Class<?> clazz) {
        if (clazz == null) return null;
        if (clazz == Boolean.TYPE) return Boolean.class;
        if (clazz == Byte.TYPE) return Byte.class;
        if (clazz == Short.TYPE) return Short.class;
        if (clazz == Integer.TYPE) return Integer.class;
        if (clazz == Long.TYPE) return Long.class;
        if (clazz == Float.TYPE) return Float.class;
        if (clazz == Double.TYPE) return Double.class;
        return clazz;
    }

    private Method findMethod(final Class<? extends Object> clazz, final String methodName, final List<Class<?>> argumentClasses) throws Exception {
        Class<?> c = clazz;
        while (notAtTopLevel(c)) {
            List<Method> methods = filter(Arrays.asList(c.getDeclaredMethods()), new Fun1<Method, Boolean>() {
                public Boolean f(Method arg0) throws Exception {
                    return methodName.equals(arg0.getName()) && (arg0.getParameterTypes().length == argumentClasses.size());
                }
            });
            for (Method m : methods) {
               Class<?>[] paramTypes = m.getParameterTypes();
               boolean matched = true;
               for (Pair<Class<?>, Class<?>> paramPair : zip(argumentClasses, Arrays.asList(paramTypes))) {
                   if (paramPair.first != null && !Boxing(paramPair.second).isAssignableFrom(paramPair.first)) {
                       matched = false;
                       break;
                   }
               }
               if (matched) {
                   m.setAccessible(true);
                   return m;
               }
            }
            c = c.getSuperclass();
        }
        throw new NoSuchMethodException("Method [" + methodName + "] is not found in class [" + clazz.getName() + "].");
    }

    //一些便利的集合初始方法。可免去在创建时重复指定泛型参数的麻烦。
    /**
     * 创建一个{@link HashMap}实例
     * @return
     */
    protected static <K, V> Map<K, V> newHashMap() {
        return new HashMap<K, V>();
    }

    /**
     * 创建一个{@link ArrayList}实例
     */
    protected static <E> List<E> newArrayList() {
        return new ArrayList<E>();
    }

    /**
     * 创建一个{@link HashSet}实例
     * @return
     */
    protected static <E> Set<E> newHashSet() {
        return new HashSet<E>();
    }

    //标注定义

    /**
     * 标记了此标注的测试用例对象域会由{@link AbstractTestCase#applyAnntation()}方法自动赋予对应的Mock对象实例。
     * @author Daniel Deng
     *
     */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.FIELD)
    protected @interface Mock {
    }

    /**
     * 标记了此标注的测试用例对象域会由{@link AbstractTestCase#applyAnntation()}方法自动创建一个对象实例。如果指定了value属性，
     * 则创建由该属性所指定类型的对象实例，否则将创建被标注的对象域所定义类型的对象实例。如果该类型无法通过{@link Class#newInstance()}直
     * 接实例化，则将尝试采用Objnesis机制强制实例化。
     * @author Daniel
     *
     */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.FIELD)
    protected @interface Create {
        public Class<?> value() default Object.class;
    }

    /**
     * 标记了此标注的测试用例对象域会由{@link AbstractTestCase#applyInjection()}方法自动注入到被测试对象实例中。可以用value属性
     * 来指定被测试对象的对象域名称。如果未指定该属性，则默认注入到与被标注的测试用例对象域同名的对象域中。
     * @author Daniel
     *
     */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.FIELD)
    protected @interface Inject {
        public String value() default "";
    }

    //一些进行简单的函数式集合处理的通用接口
    protected static interface Fun<R> {
        R f() throws Exception;
    }

    protected static interface Fun1<P0, R> {
        R f(P0 arg0) throws Exception;
    }

    protected static interface Fun2<P0, P1, R> {
        R f(P0 arg0, P1 arg1) throws Exception;
    }

    protected static interface VoidFun {
        void f() throws Exception;
    }

    protected static interface VoidFun1<P0> {
        void f(P0 arg0) throws Exception;
    }

    protected static interface VoidFun2<P0, P1> {
        void f(P0 arg0, P1 arg1) throws Exception;
    }

    protected static class Pair<P1, P2> {
        public P1 first;
        public P2 second;
    }

    // 一些简单的模拟函数式集合处理的方法
    /**
     * 对原始集合中的所有元素进行转换，映射成新的集合
     * @param collection 原始集合实例
     * @param mapper 一个接受原始集合中的元素，将其转换为结果结合中的元素的函数对象
     * @return 经过转换后的新集合
     * @throws Exception
     */
    protected static <S, T> List<T> map(Collection<S> collection, Fun1<S, T> mapper) throws Exception {
        List<T> converted = newArrayList();
        if (collection != null && collection.size() > 0) {
            Iterator<S> it = collection.iterator();
            while (it.hasNext()) {
                S element = it.next();
                converted.add(mapper.f(element));
            }
        }
        return converted;
    }

    /**
     * 返回由原始集合中满足特定条件的元素所组成的新集合
     * @param collection 原始集合实例
     * @param condition 一个接受原始集合中的元素，返回该元素是否满足条件的函数对象。如果该函数对象返回true，则对应的元素会被保留到结果集合中
     * @return 由原始集合中满足特定条件的元素所组成的新集合
     * @throws Exception
     */
    protected static <S> List<S> filter(Collection<S> collection, Fun1<S, Boolean> condition) throws Exception {
        List<S> filtered = newArrayList();
        if (collection != null && collection.size() > 0) {
            Iterator<S> it = collection.iterator();
            while (it.hasNext()) {
                S el = it.next();
                if (Boolean.TRUE.equals(condition.f(el))) {
                    filtered.add(el);
                }
            }
        }
        return filtered;
    }

    /**
     * 将两个原始集合的元素按顺序两两配对，将配对结果形成新的集合
     * @param collection1 原始集合1
     * @param collection2 原始集合2
     * @return 一个由集合1与集合2中的元素两两配对所形成的新集合。该集合的元素为{@link Pair}类型，其中first域为集合1中的对应元素，second域为集合2中的对应元素。
     *         如果两个原始集合长度不同，则结果集合的长度等于最长的原始集合长度。在结果集合中，超出较短的原始集合长度部分对应的值{@link Pair}域值为null。
     * @throws Exception
     */
    protected static <P1, P2> List<Pair<P1, P2>> zip(Collection<P1> collection1, Collection<P2> collection2) throws Exception {
        Iterator<P1> it1 = collection1.iterator();
        Iterator<P2> it2 = collection2.iterator();
        List<Pair<P1, P2>> result = newArrayList();
        boolean is1HasNext = it1.hasNext();
        boolean is2HasNext = it2.hasNext();
        while (is1HasNext || is2HasNext) {
            Pair<P1, P2> pair = new Pair<P1, P2>();
            if (is1HasNext) pair.first = it1.next();
            if (is2HasNext) pair.second = it2.next();
            result.add(pair);
            is1HasNext = it1.hasNext();
            is2HasNext = it2.hasNext();
        }
        return result;
    }

}

pom.xml

	<dependencies>
		<dependency>
		    <groupId>junit</groupId>
		    <artifactId>junit</artifactId>
		    <version>4.10</version>
		</dependency>
		<dependency>
			<groupId>org.hamcrest</groupId>
			<artifactId>hamcrest-all</artifactId>
			<version>1.1</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.jmock</groupId>
			<artifactId>jmock</artifactId>
			<version>2.5.1</version>
			<scope>test</scope>
		</dependency>
		<dependency>
		  <groupId>org.jmock</groupId>
		  <artifactId>jmock-legacy</artifactId>
		  <version>2.5.1</version>
		  <scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.objenesis</groupId>
			<artifactId>objenesis</artifactId>
			<version>1.2</version>
			<scope>test</scope>
		</dependency>
	</dependencies>