设计其实比较直接，把功能测试中的一些概念抽取出来包装下就可以了，XML要人可读可写，然后能够直接转换为对应的类，免去解析的过程最好。

我提取出来的主要概念如下：

• Library，对应的其实就是DLL，就像java中的jar一样，可以从指定的路径load，也可以从系统的GAC（windows特定的东西）里面load。
• Instance，其实本来想叫Object，因为是关键字，只能取这个比较紧似的名字，另外，声明的也确实是对象的instance而不是对象定义。
  • List，集合类型，可以当成List或者Array用。
  • WebService，这个是Instance的子类可能有点怪，但是框架的工作机制是生成WebService的Stub的对应的类，所以其实也是Instance，只是有一些额外的属性。
• Operation，其实就是操作了，有很多子类型：
  • Method，就是方法调用了
  • Verify，主要是为了做结果验证，其实也是Method，只不过掩盖了实现，我用的就是NUit的实现。
  • Task，Operation的集合，本来想加一个Function的，但是感觉Function和Task功能完全一样。Task就相当于功能测试或者单元测试的一个方法。
  • Express，表达式，主要是为了支持简单的字符串连接和数学运算。
  • Field，获取或者设置Instance的field，我掩盖了C#中的Property和Field的区别，只提供Field，两种都可以访问。
  • Loop，其实也是Operation的集合，但是会把集合中的Operation重复执行很多次，用于性能测试或者批量调用，会生成一个索引值供Operation引用生成不同的值。
  • Indexer，访问集合类型中的某个指定下标的元素，主要是因为C#没有像Java一样提供Get(int index)方法，否则这个完全没有，直接用Method 就可以实现了。
  • Finder，主要是简化了从集合类型中查找某个元素，框架没有提供if/else这样的逻辑控制，只能提供这个变向的方式。
  • Wait，主要是提供Sleep以及异步调用支持，是Verify的子类型，可以每隔一段时间Verify一下，看看结果是不是match，然后有超时，超时就认为Veirfy失败。
• Define，就是组件声明，里面包含的就是上面提到的那些东西。
• Suite，就是Test Case了，包含Define列表和Task列表，以及Startup/Teardown

基本上已经涵盖测试中需要的大部分内容了。

一些额外的想法，Operation还是有很大扩展余地的，例如可以支持外部调用，例如调用一个命令行或者其它的程序。

对INTJ性格人群来说，最重要的是独立自主以及能够根据他们的标准来生活。对别人来说，INTJ人群似乎可能制造了一种自信的气氛。这种自信被那些缺少判断力的人来说是一种毫无经验的自大而已。

   这种自信源于的知系，而大多的INTJ人群从很早就开始建立这种自信了。当问题是来自于他们的专业领域，–并且INTJ人群可能分布在各个领域-他们可 以几乎是立即告诉你，无论他们是否可以帮助你，如果可以,他们会告诉你怎么做。INTJ人群知道自己知道些什么，更重要的的是他们知道自己不知道什么。

    INTJ人群是完美主义者，他们看似有着永无止境的能力去改善任何他们感兴趣的事物。防止他们习惯性的陷入追求这种完美的是INTJ人群的性格特有的实用 主义：INTJ人群适用（冷酷）的标准"这有用吗？"对任何来自于盛行的社会模式以及在他们自己研究成就的事物。

    INTJ这类型的人群被誉为"系统的建设者"，可能部分因为他们拥有不寻常的集合虚幻性和确定性的显著特点。无论在何种体系下工作，对INTJ人群来说在 思想中是一样的,只因为他们是拥有INTJ性格的人群。完美主义并且藐视权威可能会在现实生活中体现，所以对INTJ人群来说他们可以在一个项目中对自己 和他人毫不留情。任何"松懈的"人，包括上司，将会失去INTJ人群对他们的尊敬-并且通常INTJ人群会让他们意识到这一点。INTJ人群也是可以作出 重大决定而不需询问他们的上司或同事的人群。另一个方面，他们能够小心谨慎公平地将一个项目中的个人贡献分清。他们天生具有抓住机遇的天赋，而有些机遇甚 至其他人都没有注意到。

    在最广泛的条件下，INTJ人群所做的一般是他们知道的。典型的INTJ人群择业的方向是在科学和工程方面的，但是他们也可能致力于那些需要智慧与犀利言 辞并重的领域（例如，律师，学术界的某些领域）。，如果他们愿意花时间去扩展他们的能力，INTJ人群可以从事管理，（无论是出于个人的野心或愿望）很多 INTJ人群觉得学习如何假意的因循守旧是很有利的，因为这可以在某种程度上掩饰他们内在的异常性格而在处理个人关系，特别是在爱情方面，他们缺乏罗曼蒂克，这对INTJ人群来说是致命的弱点。INTJ人群不乐意领会社会的礼仪；例如，他们很少有耐心并且 理解那些调情（大多数性格类型的人群被认为有一半的对这种关系有兴趣）。对于复杂的事，INTJ人群通常是那种特别自我的人群，他们很习惯的表现出冷漠， 而这一点容易被其他人误解。

对INTJ人群的描述
独立、冷僻、聪明；富有想象力、具有创新意识，独特的；吹毛求疵、善于分析、理智；知性上的好奇、有干劲的去学习和提高自身的能力与知识；在交际方面警惕而有所保留的；明确而有组织的。

/**
 * Performance test annotation.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PerformanceTest
{
    public String name() default "";
    public int times();
    public boolean stopOnError() default false;
}

/**
 * Base function for performance test.
 */
public class BasePerformanceTest
{
    protected Logger logger = Logger.getLogger(this.getClass());
    List<PerformanceData> performanceData = new ArrayList<PerformanceData>();

    @BeforeClass
    public static void init()
    {
        ServiceUtil.init();
    }

    @AfterClass
    public static void report()
    {
        PerformanceReportManager.generatePerformanceReport();
    }

    private void execute(Method method)
    {
        PerformanceTest performanceTest = method.getAnnotation(PerformanceTest.class);
        String name = performanceTest.name();
        if (name.equals(""))
        {
            name = method.getName();
        }
        logger.debug("Start execute test case"+name);
        int times = performanceTest.times();
        boolean stopOnError = performanceTest.stopOnError();
        PerformanceData data = new PerformanceData(name, times);
        performanceData.add(data);
        for (int i = 0; i < times; i++)
        {
            long start = System.currentTimeMillis();
            boolean error = false;
            try
            {
                method.invoke(this);
            }
            catch (Throwable t)
            {
                logger.error("Execute performance test" + name + " error.", t);
                error = true;
                if (stopOnError)
                {
                    logger.error("Stop execute performance test" + name + " because of error.");
                    return;
                }
            }
            long end = System.currentTimeMillis();
            data.addData(end – start);
            if (error)
            {
                data.addError();
            }
        }
    }

    @Test
    public void doPerformanceTests() throws Throwable
    {
        Class c = this.getClass();
        PerformanceReportManager.addData(c, performanceData);
        Method[] methods = c.getMethods();
        for (Method method : methods)
        {
            if (method.isAnnotationPresent(PerformanceTest.class))
            {
                if (method.getParameterTypes().length == 0)
                {
                    execute(method);
                }
                else
                {
                    logger.warn("Can not support execute performance test method with parameters:" + method);
                }
            }
        }
    }

}

/**
 * Performance data.
 */
public class PerformanceData
{
    private String name;
    private int times;
    private long[] data;
    private int index = 0;
    private long max = Long.MIN_VALUE;
    private long min = Long.MAX_VALUE;
    private long total = 0;
    private int errors;

    public PerformanceData(String name, int times)
    {
        this.name = name;
        this.times = times;
        data = new long[times];
    }

    public String getName()
    {
        return name;
    }

    public int getTimes()
    {
        return times;
    }

    public long[] getData()
    {
        return data;
    }

    public void addData(long data)
    {
        this.data[index++] = data;
        max = Math.max(max, data);
        min = Math.min(min, data);
        total += data;
    }

    public long getMax()
    {
        return max;
    }

    public long getMin()
    {
        return min;
    }

    public long getAveg()
    {
        if (times == 0)
        {
            return 0;
        }
        return getTotal() / times;
    }

    public long getTotal()
    {
        return total;
    }

    public int getErrors()
    {
        return errors;
    }

    public void addError()
    {
        errors++;
    }
}

/**
 * Performance report manager.
 */
public class PerformanceReportManager
{
    private static Map<Class, List<PerformanceData>> allData = new HashMap<Class, List<PerformanceData>>();
    private static PerformanceReporter performanceReporter = new DirectOutputPerformanceReporter();

    public static void addData(Class c, List<PerformanceData> data)
    {
        allData.put(c, data);
    }

    public static void generatePerformanceReport()
    {
        performanceReporter.generateReport(allData);
    }

    public static PerformanceReporter getPerformanceReporter()
    {
        return performanceReporter;
    }

    public static void setPerformanceReporter(PerformanceReporter performanceReporter)
    {
        PerformanceReportManager.performanceReporter = performanceReporter;
    }
}

public interface PerformanceReporter
{
    public void generateReport(Map<Class, List<PerformanceData>> allData);
}

结论：你对自己信心十足，明白自己的优点，同时也清楚自己的缺点。不过在别人眼里，你可能过于狂傲、甚至有点嚣张，你可以在别人面前表现得谦虚一点，这样对处理人际关系有好处。

import java.lang.reflect.Method;
import java.util.Iterator;

import javax.jms.MessageListener;
import javax.naming.InitialContext;
import javax.naming.NamingException;

import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.mockejb.EntityBeanDescriptor;
import org.mockejb.MDBDescriptor;
import org.mockejb.MockContainer;
import org.mockejb.SessionBeanDescriptor;
import org.mockejb.interceptor.Aspect;
import org.mockejb.interceptor.AspectSystem;
import org.mockejb.interceptor.ClassPointcut;
import org.mockejb.interceptor.InvocationRecorder;

import test.util.ClassUtil;
import test.util.CommandUtil;
import test.util.DataUtil;
import test.util.DummyDataUtil;
import test.util.EJBUtil;

public class ARInitialContext extends InitialContext
{
    private static Logger log = LogManager.getLogger(ARInitialContext.class);

    private MockContainer mockContainer;

    private AspectSystem aspectSystem;

    public ARInitialContext() throws NamingException
    {

    }

    /**
     * @return the mockContainer
     */
    public MockContainer getMockContainer()
    {
        return mockContainer;
    }

    /**
     * @param mockContainer the mockContainer to set
     */
    public void setMockContainer(MockContainer mockContainer)
    {
        this.mockContainer = mockContainer;
    }

    /**
     * @return the aspectSystem
     */
    public AspectSystem getAspectSystem()
    {
        return aspectSystem;
    }

    /**
     * @param aspectSystem the aspectSystem to set
     */
    public void setAspectSystem(AspectSystem aspectSystem)
    {
        this.aspectSystem = aspectSystem;
    }

    /**
     * Lookup responding object, if not existed, try to init it.
     * First try to init from custom init method(init+jndiName’s final part),
     * if failed, try to get BeanInfo from config file and init it.
     * @param jndiName
     * @return
     * @throws Exception
     */
    public Object lookup(String jndiName) throws NamingException
    {
        return lookup(jndiName, true);
    }

    public Object lookup(String jndiName, boolean tryInit) throws NamingException
    {
        Object objRef = null;
        try
        {
            objRef = super.lookup(jndiName);
            if (objRef != null)
            {
                return objRef;
            }
        }
        catch (NamingException e)
        {

        }
        if (tryInit)
        {
            return tryToInitBean(jndiName);
        }
        else
        {
            return objRef;
        }
    }

    /**
     * Init bean according to BeanInfo, can init entity bean, session bean and message driven bean.
     * @param jndi
     * @param beanInfo
     * @throws Exception
     */
    private void initBean(String jndi, BeanInfo beanInfo) throws Exception
    {
        log.debug("Init bean:" + beanInfo.getShortName() + ", JNDI:" + jndi);
        if (beanInfo.getType() == BeanInfo.ENTITY_BEAN)
        {
            initEntityBean(jndi, beanInfo);
        }
        else if (beanInfo.getType() == BeanInfo.SESSION_BEAN)
        {
            initSessionBean(jndi, beanInfo);
        }
        else if (beanInfo.getType() == BeanInfo.MESSAGE_BEAN)
        {
            initMessageBean(beanInfo);
        }
        else
        {
            log.error("Unsupported bean type: " + beanInfo.getType());
        }
    }

    /**
     * Init message bean, if the jndi name is start with "topic/", then it is topic type, otherwise, it is queue type.
     * The factory also is depending on its jndi name.
     * @param beanInfo
     * @throws Exception
     */
    private void initMessageBean(BeanInfo beanInfo) throws Exception
    {
        Class bean = ClassUtil.getClassForName(beanInfo.getBean());
        String jndi = beanInfo.getJndi();
        String factoryJndi = null;
        if (jndi.startsWith(Constant.TOPIC))
        {
            factoryJndi = Constant.TOPIC_CONNECTION_FACTORY;
        }
        else
        {
            factoryJndi = Constant.QUEUE_CONNECTION_FACTORY;
        }
        MDBDescriptor descriptor = new MDBDescriptor(factoryJndi, jndi, bean.newInstance());
        if (jndi.startsWith(Constant.TOPIC))
        {
            descriptor.setIsTopic(true);
        }
        mockContainer.deploy(descriptor);
        InvocationRecorder recorder = new InvocationRecorder();
        aspectSystem.add(new ClassPointcut(MessageListener.class, false), recorder);
    }

    public void initQueueConnectionFactory(String factoryJndi) throws Exception
    {
        MDBDescriptor descriptor = new MDBDescriptor(factoryJndi, Constant.MOCK_QUEUE, new BaseMessageBean());
        descriptor.setIsTopic(false);
        mockContainer.deploy(descriptor);
    }

    public void initTopicConnectionFactory(String factoryJndi) throws Exception
    {
        MDBDescriptor descriptor = new MDBDescriptor(factoryJndi, Constant.MOCK_TOPIC, new BaseMessageBean());
        descriptor.setIsTopic(true);
        mockContainer.deploy(descriptor);
    }

    private Object tryToInitBean(String jndiName)
    {
        try
        {
            BeanInfo beanInfo = EJBUtil.getBeanInfoByJndi(jndiName);
            if (beanInfo == null)
            {
                log.error("Can not find BeanInfo for " + jndiName);
                return null;
            }
            else
            {
                initBean(jndiName, beanInfo);
            }
            return super.lookup(jndiName);
        }
        catch (Exception e)
        {
            log.error("Can not init bean:" + jndiName);
            return null;
        }
    }

    /**
     * Inint entity bean and create all dummy record from dummy xml database.
     * @param jndi
     * @param beanInfo
     * @throws Exception
     */
    private void initEntityBean(String jndi, BeanInfo beanInfo) throws Exception
    {
        Class home = ClassUtil.getClassForName(beanInfo.getHome());
        Class remote = ClassUtil.getClassForName(beanInfo.getRemote());
        Class bean = ClassUtil.getClassForName(beanInfo.getBean());
        Class create = ClassUtil.getClassForName(Constant.ASPECT_PACKAGE + beanInfo.getShortName() + "CreateAspect");
        Class find = ClassUtil.getClassForName(Constant.ASPECT_PACKAGE + beanInfo.getShortName() + "FindAspect");
        Class setter = ClassUtil.getClassForName(Constant.ASPECT_PACKAGE + beanInfo.getShortName() + "SetterAspect");
        Aspect createAspect = null;
        Aspect findAspect = null;
        Aspect setterAspect = null;
        if (create != null)
        {
            createAspect = (Aspect) create.getConstructor(new Class[]
            { BeanInfo.class }).newInstance(new Object[]
            { beanInfo });
        }
        else
        {
            createAspect = new BaseCreateAspect(beanInfo);
        }
        if (find != null)
        {
            findAspect = (Aspect) find.getConstructor(new Class[]
            { BeanInfo.class }).newInstance(new Object[]
            { beanInfo });
        }
        else
        {
            findAspect = new BaseFindAspect(beanInfo);
        }
        if (setter != null)
        {
            setterAspect = (Aspect) setter.getConstructor(new Class[]
            { BeanInfo.class }).newInstance(new Object[]
            { beanInfo });
        }
        else
        {
            setterAspect = new BaseSetterAspect(beanInfo);
        }
        aspectSystem.add(createAspect);
        aspectSystem.add(findAspect);
        aspectSystem.add(setterAspect);
        EntityBeanDescriptor descriptor = new EntityBeanDescriptor(jndi, home, remote, bean);
        mockContainer.deploy(descriptor);
        Object homeObject = lookup(jndi);
        try
        {
            Method createMethod = ClassUtil.getMostSimpleCreateMethod(homeObject);
            Class[] parameterTypes = createMethod.getParameterTypes();
            Object[] values = new Object[parameterTypes.length];
            Iterator pks = DummyDataUtil.getPkValues(EJBUtil.getBeanInfoByJndi(jndi).getShortName()).iterator();
            while (pks.hasNext())
            {
                Long pk = (Long) pks.next();
                DataUtil.setPk(beanInfo.getShortName(), pk);
                createMethod.invoke(homeObject, values);
            }
            CommandUtil.executeCommands();
        }
        catch (Exception e)
        {
            log.warn("Can not init dummy data for " + jndi, e);
            try
            {
                DummyDataUtil.initDatabaseInfo(beanInfo);
            }
            catch (Exception e1)
            {
                log.warn("Can not init database info for " + jndi, e);
            }
        }
    }

    /**
     * Init session bean, maybe local type, depending on the jndi name
     * @param jndi
     * @param beanInfo
     * @throws Exception
     */
    private void initSessionBean(String jndi, BeanInfo beanInfo) throws Exception
    {
        Class home = null;
        Class remote = null;
        Class bean = ClassUtil.getClassForName(beanInfo.getBean());
        if (jndi.equals(beanInfo.getJndi()))
        {
            home = ClassUtil.getClassForName(beanInfo.getHome());
            remote = ClassUtil.getClassForName(beanInfo.getRemote());
        }
        else
        {
            home = ClassUtil.getClassForName(beanInfo.getLocalHome());
            remote = ClassUtil.getClassForName(beanInfo.getLocal());
        }
        Class aspectClass = ClassUtil.getClassForName(Constant.ASPECT_PACKAGE + beanInfo.getShortName() + "Aspect");
        Aspect aspect = null;
        if (aspectClass != null)
        {
            aspect = (Aspect) aspectClass.getConstructor(new Class[]
            { BeanInfo.class }).newInstance(new Object[]
            { beanInfo });
            aspectSystem.add(aspect);
        }
        SessionBeanDescriptor descriptor = new SessionBeanDescriptor(jndi, home, remote, bean);
        mockContainer.deploy(descriptor);
    }

    public void deploySessionBean(String jndi, Class home, Class remote, Object bean) throws Exception
    {
        SessionBeanDescriptor descriptor = new SessionBeanDescriptor(jndi, home, remote, bean);
        mockContainer.deploy(descriptor);
    }

}