android中说TestSuite是Tests的混合物。这里的测试类，我们可以把它理解为很多的测试类。
我们可以通过TestSuite去收集一堆测试用例，然后去运行她们。
1.
android中给出了动态往TestSuite中添加测试用例的方式：
TestSuite suite= new TestSuite();
suite.addTest(new MathTest("testAdd"));
suite.addTest(new MathTest("testDivideByZero"));
先生成一个TestSuite对象，然后动态添加MathTest类的testXXX方法。
2.
除了上面的方式，TestSuite也可以把测试用例提取出来，然后去自动运行。
如果要这样做，就需要在new的时候传入包含测试用例的TestClass的类型。
TestSuite suite= new TestSuite(MathTest.class);
这个构造函数new出来的suite，包含的测试用例必须是以"test"开头，且是无参的。
我们看一下这个构造函数是怎么样的：
public TestSuite(final Class<?> theClass) {
addTestsFromTestCase(theClass);
}
里面有一个addTestsFromTestCase方法，从字面的意思理解：就是从对应的测试类中提取test测试用例。
我们来看一下它的具体实现，并且分析一下：
private void addTestsFromTestCase(final Class<?> theClass) {
fName= theClass.getName();
try {
getTestConstructor(theClass); // Avoid generating multiple error messages
} catch (NoSuchMethodException e) {
addTest(warning("Class "+theClass.getName()+" has no public constructor TestCase(String name) or TestCase()"));
return;
}
if (!Modifier.isPublic(theClass.getModifiers())) {
addTest(warning("Class "+theClass.getName()+" is not public"));
return;
}
Class<?> superClass= theClass;
List<String> names= new ArrayList<String>();
while (Test.class.isAssignableFrom(superClass)) {
for (Method each : superClass.getDeclaredMethods())
addTestMethod(each, names, theClass);
superClass= superClass.getSuperclass();
}
if (fTests.size() == 0)
addTest(warning("No tests found in "+theClass.getName()));
}
设置fName为测试类名，然后会通过getTestConstructor对传入的测试类做一个检测，检测是否有带String类型参数的公有构造函数或者是无参的公有构造函数。也就是说，
这里限定了测试员在写一个测试类的时候必须声明一个public constructor TestCase(String name)或者TestCase()，否则会给你抛出一个警告。
接下去判断测试类是否是一个公有类型的Class。
接着通过一个while循环，判断superClass是否可以转换为Test类型，我们知道android测试中定义的测试类一般都会继承AndroidTestCase或其他XXXTestCase，
而这些TestCase都实现了Test接口。所以通过这样一种方式，就可以去遍历继承体系中的所有方法，把需要的测试用例TestSuite中。最后在superClass为Test后，
在去getSuperclass，这时superClass就为Test的SuperClass，退出while循环。
上面讲到，我们声明的测试用例必须是公有无参且以"test"开头的，那么这在哪里检测呢？这就来看一下addTestMethod:
private void addTestMethod(Method m, List<String> names, Class<?> theClass) {
String name= m.getName();
if (names.contains(name))
return;
if (! isPublicTestMethod(m)) {
if (isTestMethod(m))
addTest(warning("Test method isn't public: "+ m.getName() + "(" + theClass.getCanonicalName() + ")"));
return;
}
names.add(name);
addTest(createTest(theClass, name));
}
会在isPublicTestMethod中判断是否公有无参且以"test"开头，如果否，会判断一下是否是"test"开头且无参，如果是，就告诉用户需要把测试用例声明为public（多么人性化
的代码，努力学习中。。。）
如果符合要求，我们就把方法名添加到一个List<String>中，避免重复添加。然后通过addTest去添加测试用例---根据测试类名和测试用例名去动态的生成一个Test。
static public Test createTest(Class<?> theClass, String name) {
Constructor<?> constructor;
try {
constructor= getTestConstructor(theClass);
} catch (NoSuchMethodException e) {
return warning("Class "+theClass.getName()+" has no public constructor TestCase(String name) or TestCase()");
}
Object test;
try {
if (constructor.getParameterTypes().length == 0) {
test= constructor.newInstance(new Object[0]);
if (test instanceof TestCase)
((TestCase) test).setName(name);
} else {
test= constructor.newInstance(new Object[]{name});
}
} catch (InstantiationException e) {
return(warning("Cannot instantiate test case: "+name+" ("+exceptionToString(e)+")"));
} catch (InvocationTargetException e) {
return(warning("Exception in constructor: "+name+" ("+exceptionToString(e.getTargetException())+")"));
} catch (IllegalAccessException e) {
return(warning("Cannot access test case: "+name+" ("+exceptionToString(e)+")"));
}
return (Test) test;
}
根据用户TestClass构造函数不同回去生成以测试用例命名的Test。如果是无参的，会调用setName去设置；如果有参，会往newInstance中传入new Object[]{name}。
那么Test存放在哪里呢？
private Vector<Test> fTests= new Vector<Test>(10);
我们看到前面声明了一个Vector，所有Test都是保存在这个Vector中。
public void addTest(Test test) {
fTests.add(test);
}
addTestsFromTestCase的最后会判断fTests.size()时候等于0，如果等于0，就说明没有找到相关的Test。
3.
我们也可以定义一个Class[]对象作为参数传入构造函数，里面包含各种测试类。
Class[] testClasses = { MathTest.class, AnotherTest.class }
TestSuite suite= new TestSuite(testClasses);
这里以Class[]数组类型为参数的构造函数，实际也只是循环调用2中的构造函数，如下:
public TestSuite (Class<?>... classes) {
for (Class<?> each : classes)
addTest(testCaseForClass(each));
}
private Test testCaseForClass(Class<?> each) {
if (TestCase.class.isAssignableFrom(each))
return new TestSuite(each.asSubclass(TestCase.class));
else
return warning(each.getCanonicalName() + " does not extend TestCase");
}
通过testCaseForClass获取每一个类中的所有Test。
4.
讲完了怎么生成一个TestSuite，那么TestSuite中包含的Test是怎么被运行的呢。
我们这里假设Test是放在InstrumentationTestRunner中运行，首先进入onCreate:
public void onCreate(Bundle arguments) {
。。。。。。。
mTestRunner = getAndroidTestRunner();
mTestRunner.setContext(getTargetContext());
mTestRunner.setInstrumentation(this);
mTestRunner.setSkipExecution(logOnly);
mTestRunner.setTest(testSuiteBuilder.build());
。。。。。。
}
我们会看到这里会获取到一个AndroidTestRunner对象，然后在其中运行测试用例，
mTestRunner.setTest(testSuiteBuilder.build())就是设置要在AndroidTestRunner中运行的TestSuite。
那么在setTest中做了哪些操作？
public void setTest(Test test) {
setTest(test, test.getClass());
}
private void setTest(Test test, Class<? extends Test> testClass) {
mTestCases = (List<TestCase>) TestCaseUtil.getTests(test, true);
if (TestSuite.class.isAssignableFrom(testClass)) {
mTestClassName = TestCaseUtil.getTestName(test);
} else {
mTestClassName = testClass.getSimpleName();
}
}
看到会用一个mTestCases去保存所有TestCase，然后会在InstrumentationTestRunner的onStart中去执行runTest()，逐个运行所有TestCase。
public void runTest(TestResult testResult) {
mTestResult = testResult;
for (TestListener testListener : mTestListeners) {
mTestResult.addListener(testListener);
}
Context testContext = mInstrumentation == null ? mContext : mInstrumentation.getContext();
for (TestCase testCase : mTestCases) {
setContextIfAndroidTestCase(testCase, mContext, testContext);
setInstrumentationIfInstrumentationTestCase(testCase, mInstrumentation);
setPerformanceWriterIfPerformanceCollectorTestCase(testCase, mPerfWriter);
testCase.run(mTestResult);
}
}
这里看到for循环里会调用testCase自己的run方法，运行结果放在TestResult中。
版权声明：本文为博主原创文章，未经博主允许不得转载。