InstrumentationCoreTestRunnerpublic class InstrumentationCoreTestRunner extends InstrumentationTestRunner | This test runner extends the default InstrumentationTestRunner. It overrides
the {@code onCreate(Bundle)} method and sets the system properties necessary
for many core tests to run. This is needed because there are some core tests
that need writing access to the file system. We also need to set the harness
Thread's context ClassLoader. Otherwise some classes and resources will not
be found. Finally, we add a means to free memory allocated by a TestCase
after its execution. |
| Fields Summary |
|---|
| private static final String | TAGConvenience definition of our log tag. | | private boolean | singleTestTrue if (and only if) we are running in single-test mode (as opposed to
batch mode). |
| Methods Summary |
|---|
| protected AndroidTestRunner | getAndroidTestRunner()
AndroidTestRunner runner = super.getAndroidTestRunner();
runner.addTestListener(new TestListener() {
/**
* The last test class we executed code from.
*/
private Class<?> lastClass;
/**
* The minimum time we expect a test to take.
*/
private static final int MINIMUM_TIME = 100;
/**
* The start time of our current test in System.currentTimeMillis().
*/
private long startTime;
public void startTest(Test test) {
if (test.getClass() != lastClass) {
lastClass = test.getClass();
printMemory(test.getClass());
}
Thread.currentThread().setContextClassLoader(
test.getClass().getClassLoader());
startTime = System.currentTimeMillis();
}
public void endTest(Test test) {
if (test instanceof TestCase) {
cleanup((TestCase)test);
/*
* Make sure all tests take at least MINIMUM_TIME to
* complete. If they don't, we wait a bit. The Cupcake
* Binder can't handle too many operations in a very
* short time, which causes headache for the CTS.
*/
long timeTaken = System.currentTimeMillis() - startTime;
if (timeTaken < MINIMUM_TIME) {
try {
Thread.sleep(MINIMUM_TIME - timeTaken);
} catch (InterruptedException ignored) {
// We don't care.
}
}
}
}
public void addError(Test test, Throwable t) {
// This space intentionally left blank.
}
public void addFailure(Test test, AssertionFailedError t) {
// This space intentionally left blank.
}
/**
* Dumps some memory info.
*/
private void printMemory(Class<? extends Test> testClass) {
Runtime runtime = Runtime.getRuntime();
long total = runtime.totalMemory();
long free = runtime.freeMemory();
long used = total - free;
Log.d(TAG, "Total memory : " + total);
Log.d(TAG, "Used memory : " + used);
Log.d(TAG, "Free memory : " + free);
Log.d(TAG, "Now executing : " + testClass.getName());
}
/**
* Nulls all non-static reference fields in the given test class.
* This method helps us with those test classes that don't have an
* explicit tearDown() method. Normally the garbage collector should
* take care of everything, but since JUnit keeps references to all
* test cases, a little help might be a good idea.
*/
private void cleanup(TestCase test) {
Class<?> clazz = test.getClass();
while (clazz != TestCase.class) {
Field[] fields = clazz.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field f = fields[i];
if (!f.getType().isPrimitive() &&
!Modifier.isStatic(f.getModifiers())) {
try {
f.setAccessible(true);
f.set(test, null);
} catch (Exception ignored) {
// Nothing we can do about it.
}
}
}
clazz = clazz.getSuperclass();
}
}
});
return runner;
| | java.util.List | getBuilderRequirements()
List<Predicate<TestMethod>> builderRequirements =
super.getBuilderRequirements();
Predicate<TestMethod> brokenTestPredicate =
Predicates.not(new HasAnnotation(BrokenTest.class));
builderRequirements.add(brokenTestPredicate);
if (!singleTest) {
Predicate<TestMethod> sideEffectPredicate =
Predicates.not(new HasAnnotation(SideEffect.class));
builderRequirements.add(sideEffectPredicate);
}
return builderRequirements;
| | public void | onCreate(android.os.Bundle arguments)
// We might want to move this to /sdcard, if is is mounted/writable.
File cacheDir = getTargetContext().getCacheDir();
// Set some properties that the core tests absolutely need.
System.setProperty("user.language", "en");
System.setProperty("user.region", "US");
System.setProperty("java.home", cacheDir.getAbsolutePath());
System.setProperty("user.home", cacheDir.getAbsolutePath());
System.setProperty("java.io.tmpdir", cacheDir.getAbsolutePath());
if (arguments != null) {
String classArg = arguments.getString(ARGUMENT_TEST_CLASS);
singleTest = classArg != null && classArg.contains("#");
}
super.onCreate(arguments);
|
|
