Android测试三----TestSuite分析。

标签：testsuite   android   cts   runtest   testcase   

android中说TestSuite是Tests的混合物。这里的测试类，我们可以把它理解为很多的测试类。

我们可以通过TestSuite去收集一堆测试用例，然后去运行她们。

1.

android中给出了动态往TestSuite中添加测试用例的方式：

TestSuite suite= new TestSuite();
suite.addTest(new MathTest("testAdd"));
suite.addTest(new MathTest("testDivideByZero"));

2.

除了上面的方式，TestSuite也可以把测试用例提取出来，然后去自动运行。

如果要这样做，就需要在new的时候传入包含测试用例的TestClass的类型。

TestSuite suite= new TestSuite(MathTest.class);

我们看一下这个构造函数是怎么样的：

	public TestSuite(final Class<?> theClass) {
		addTestsFromTestCase(theClass);
	}

我们来看一下它的具体实现，并且分析一下：

	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()));
	}

这里限定了测试员在写一个测试类的时候必须声明一个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));
	}

的代码，努力学习中。。。）

如果符合要求，我们就把方法名添加到一个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;
	}

那么Test存放在哪里呢？

private Vector<Test> fTests= new Vector<Test>(10);

public void addTest(Test test) {
		fTests.add(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");
	}

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());
        。。。。。。

}

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();
        }
    }

    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);
        }
    }

Android测试三----TestSuite分析。

标签：testsuite   android   cts   runtest   testcase   

原文地址：http://blog.csdn.net/nitibu/article/details/47975137