SimpleRunner.java

package org.nutz.test.utils;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.nutz.lang.Mirror;

/**
 * 可以传入多个test case作为参数。例如： java org.nutz.test.utils.SimpleRunner
 * org.nutz.log.JdkAdapterPerformanceTest:testCreation
 * org.nutz.log.JdkAdapterPerformanceTest:*
 * 
 * @author Young(sunonfire@gmail.com)
 * 
 */
public class SimpleRunner {

    public static void main(String[] args) throws IllegalArgumentException, ClassNotFoundException,
            IllegalAccessException, InvocationTargetException {

        for (String arg : args) {

            int index = arg.indexOf(':');

            String className = null;
            Set<String> methodNames = new HashSet<String>(5);

            if (index == -1) {
                className = arg;
            } else {
                className = arg.substring(0, index);

                String allNames = arg.substring(index + 1);

                if (!"*".equals(allNames)) {
                    String[] methodNameArray = allNames.split(",");

                    for (String m : methodNameArray) {
                        if (m.trim().length() != 0)
                            methodNames.add(m);
                    }
                }
            }

            runClassTest(className, methodNames);
        }
    }

    protected static void runClassTest(String className, Set<String> methodNames)
            throws ClassNotFoundException, IllegalArgumentException, IllegalAccessException,
            InvocationTargetException {

        Mirror<?> mi = Mirror.me(Class.forName(className));

        Method beforeClass = null;
        Method afterClass = null;
        Method before = null;
        Method after = null;
        List<Method> testMethods = new ArrayList<Method>(10);

        Method[] methods = mi.getMethods();

        final boolean methodNamesIsEmptyAtBeginning = methodNames.isEmpty();

        for (Method m : methods) {

            if (m.getName().indexOf("access$") != -1) {
                continue;
            }

            if (m.isAnnotationPresent(BeforeClass.class)) {
                beforeClass = m;
                continue;
            }

            if (m.isAnnotationPresent(AfterClass.class)) {
                afterClass = m;
                continue;
            }

            if (m.isAnnotationPresent(Before.class)) {
                before = m;
                continue;
            }

            if (m.isAnnotationPresent(After.class)) {
                after = m;
                continue;
            }

            if (methodNamesIsEmptyAtBeginning && m.isAnnotationPresent(Test.class)) {
                testMethods.add(m);
                continue;
            }

            if (methodNames.remove(m.getName())) {
                testMethods.add(m);
            }
        }

        if (!methodNames.isEmpty()) {

            System.out.println("Warning!!!: The following methods cannot find in class "
                                + className);

            for (String name : methodNames) {
                System.out.println(name);
            }
        }

        Object caze = mi.born();

        runClassTestInner(beforeClass, afterClass, before, after, testMethods, caze);
    }

    protected static void runClassTestInner(Method beforeClass,
                                            Method afterClass,
                                            Method before,
                                            Method after,
                                            List<Method> testMethods,
                                            Object caze) throws IllegalAccessException,
            InvocationTargetException {

        // System.out.println("Before run test case " +
        // caze.getClass().getName());

        if (beforeClass != null) {
            beforeClass.invoke(null);
        }

        if (afterClass != null) {
            afterClass.invoke(null);
        }

        for (Method test : testMethods) {

            // System.out.println("\tbefore run test " + test.getName());

            if (before != null) {
                before.invoke(caze);
            }

            test.invoke(caze);

            if (after != null)
                after.invoke(caze);
        }
    }
}