Junit 源码剖析（一）
采用Junit4.8.2分析Junit实现架构
源码架构两个大包：junit包 org包
首先分析org.junit.runners.model包下的几个类
org.junit.runners.modela.TestClass
org.junit.runners.modela.FrameworkMethod
org.junit.runners.modela.FrameworkMember
org.junit.runners.modela.FrameworkField
涉及到的类：
org.junit.Assert;
org.junit.Before;
org.junit.BeforeClass;
org.junit.internal.runners.model.ReflectiveCallable;
org.junit.runners.BlockJUnit4ClassRunner;
package org.junit.runners.model;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
/**
* Wraps a class to be run, providing method validation and annotation searching
*/
public class TestClass
{
// 封装的单元测试类的Class对象
private final Class<?> fClass;
// 注解类型->对应的方法List
private Map<Class<?>, List<FrameworkMethod>> fMethodsForAnnotations = new HashMap<Class<?>, List<FrameworkMethod>>();
// 注解类型->对应的属性List
private Map<Class<?>, List<FrameworkField>> fFieldsForAnnotations = new HashMap<Class<?>, List<FrameworkField>>();
//创建一个TestClass对象（包裹着klass对象，即要测试的类对象），
//每次该构造方法执行，klass对象将被扫描类当中的注解annotations
//这个操作过程是十分昂贵的（希望将来JDK将会优化它），因此，请尽量共享TestClass的实例。
public TestClass(Class<?> klass)
{
fClass = klass;
if (klass != null && klass.getConstructors().length > 1)
throw new IllegalArgumentException("Test class can only have one constructor");
//遍历该类和其父类
for (Class<?> eachClass : getSuperClasses(fClass))
{
//扫描该方法的注解
for (Method eachMethod : eachClass.getDeclaredMethods())
addToAnnotationLists(new FrameworkMethod(eachMethod), fMethodsForAnnotations);
for (Field eachField : eachClass.getDeclaredFields())
addToAnnotationLists(new FrameworkField(eachField), fFieldsForAnnotations);
}
}
//将该方法或者给属性拥有的注解，全部加入映射
private <T extends FrameworkMember<T>> void addToAnnotationLists(T member, Map<Class<?>, List<T>> map)
{
//遍历该member上的annotation
for (Annotation each : member.getAnnotations())
{
Class<? extends Annotation> type = each.annotationType();
//获取该annotation的Type对应的List
List<T> members = getAnnotatedMembers(map, type);
//防止重复加入List （子类父类的情况，执行子类的）
if (member.isShadowedBy(members))
return;
//如果是Before或者BeforeClass注解，insert到第一个位置
if (runsTopToBottom(type))
members.add(0, member);
//其余（test，after，afterclass）insert到后面
else
members.add(member);
}
}
//返回跟annotationClass相同类型的Method集合
public List<FrameworkMethod> getAnnotatedMethods(Class<? extends Annotation> annotationClass)
{
return getAnnotatedMembers(fMethodsForAnnotations, annotationClass);
}
//返回跟annotationClass相同类型的Field集合
public List<FrameworkField> getAnnotatedFields(Class<? extends Annotation> annotationClass)
{
return getAnnotatedMembers(fFieldsForAnnotations, annotationClass);
}
//获取该annotation的Type对应的List
private <T> List<T> getAnnotatedMembers(Map<Class<?>, List<T>> map, Class<? extends Annotation> type)
{
if (!map.containsKey(type))
map.put(type, new ArrayList<T>());
return map.get(type);
}
//确保后加入的before放到前面
private boolean runsTopToBottom(Class<? extends Annotation> annotation)
{
return annotation.equals(Before.class) || annotation.equals(BeforeClass.class);
}
//将该类和父类所有Class对象放入List当中返回
private List<Class<?>> getSuperClasses(Class<?> testClass)
{
ArrayList<Class<?>> results = new ArrayList<Class<?>>();
Class<?> current = testClass;
while (current != null)
{
results.add(current);
current = current.getSuperclass();
}
return results;
}
/**
* Returns the underlying Java class.
*/
public Class<?> getJavaClass()
{
return fClass;
}
/**
* Returns the class's name.
*/
public String getName()
{
if (fClass == null)
return "null";
return fClass.getName();
}
/**
* Returns the only public constructor in the class, or throws an {@code
* AssertionError} if there are more or less than one.
*/
public Constructor<?> getOnlyConstructor()
{
Constructor<?>[] constructors = fClass.getConstructors();
Assert.assertEquals(1, constructors.length);
return constructors[0];
}
/**
* Returns the annotations on this class
*/
public Annotation[] getAnnotations()
{
if (fClass == null)
return new Annotation[0];
return fClass.getAnnotations();
}
public <T> List<T> getAnnotatedFieldValues(Object test, Class<? extends Annotation> annotationClass, Class<T> valueClass)
{
List<T> results = new ArrayList<T>();
for (FrameworkField each : getAnnotatedFields(annotationClass))
{
try
{
results.add(valueClass.cast(each.get(test)));
}
catch(IllegalAccessException e)
{
throw new RuntimeException("How did getFields return a field we couldn't access?");
}
}
return results;
}
}
下面是一个测试实例，通过使用TestClass类测试TestUnit的几个方法
package mytest.TestClass;
import java.util.List;
import org.junit.Test;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.TestClass;
/**
* org.junit.runners.model.FrameworkMethod 封装一个被测试的方法
*
* @Test 、@Before、@After、@BeforeClass、@AfterClass、@Ignore
*/
public class TestClassDemo
{
public static void test() throws Throwable
{
TestClass klass = new TestClass(TestUnit.class);
System.out.println(klass.getName());
List<FrameworkMethod> list = klass.getAnnotatedMethods(Test.class);
for (FrameworkMethod fm : list)
{
try
{
fm.invokeExplosively((TestUnit) klass.getJavaClass().newInstance(), new Object[0]);
}
catch(Throwable e)
{
System.out.println(e);
} finally
{
System.out.println(fm.getName() + " invoked!");
}
}
}
public static void main(String[] args) throws Throwable
{
TestClassDemo.test();
}
}
package mytest.TestClass;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
public class TestUnit
{
public TestUnit()
{
}
@Test
public void addx(int x)
{
assertEquals(5, 1 + x);
}
@Test
public void add()
{
assertEquals(5.0, 4.0, 0.1);
}
@Test
public void hello()
{
assertEquals(5.0, 4.0, 0.1);
}
}
输出结果是：
mytest.TestClass.TestUnit java.lang.IllegalArgumentException: wrong number of arguments addx invoked! java.lang.AssertionError: expected:<5.0> but was:<4.0> hello invoked! java.lang.AssertionError: expected:<5.0> but was:<4.0> add invoked!
