From 7d41b8c26a2e255978393e9447d5c4a6f240e67e Mon Sep 17 00:00:00 2001 From: Urs Grob <> Date: Sat, 18 Apr 2009 22:47:14 -0700 Subject: AI 146828: am: CL 146743 am: CL 146711 Enhancing the test runner. Now it filters BrokenTests and only executes tests annotated with SideEffect if the host is running in single test mode. Also adding some cleanup mechanism and some logcat logging about memory consumption Original author: ursg Merged from: //branches/cupcake/... Original author: android-build Automated import of CL 146828 --- .../test/InstrumentationCoreTestRunner.java | 137 ++++++++++++++++++++- .../android/test/InstrumentationTestRunner.java | 8 ++ 2 files changed, 142 insertions(+), 3 deletions(-) (limited to 'test-runner') diff --git a/test-runner/android/test/InstrumentationCoreTestRunner.java b/test-runner/android/test/InstrumentationCoreTestRunner.java index 6b1a4e4..3f77a60 100644 --- a/test-runner/android/test/InstrumentationCoreTestRunner.java +++ b/test-runner/android/test/InstrumentationCoreTestRunner.java @@ -17,27 +17,158 @@ package android.test; import java.io.File; +import java.lang.reflect.Field; +import java.lang.reflect.Modifier; +import java.util.List; +import com.android.internal.util.Predicate; +import com.android.internal.util.Predicates; + +import dalvik.annotation.BrokenTest; +import dalvik.annotation.SideEffect; + +import junit.framework.AssertionFailedError; +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestListener; import android.os.Bundle; +import android.test.suitebuilder.TestMethod; +import android.test.suitebuilder.annotation.HasAnnotation; +import android.util.Log; /** * 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 filesystem. + * 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. * * @hide */ public class InstrumentationCoreTestRunner extends InstrumentationTestRunner { + private static final String TAG = "InstrumentationCoreTestRunner"; + private boolean singleTest = false; + @Override public void onCreate(Bundle arguments) { - super.onCreate(arguments); - + // We might want to move this to /sdcard, if is is mounted/writable. File cacheDir = getTargetContext().getCacheDir(); 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()); + System.setProperty("javax.net.ssl.trustStore", + "/etc/security/cacerts.bks"); + + if (arguments != null) { + String classArg = arguments.getString(ARGUMENT_TEST_CLASS); + singleTest = classArg != null && classArg.contains("#"); + } + + super.onCreate(arguments); + } + + protected AndroidTestRunner getAndroidTestRunner() { + AndroidTestRunner runner = super.getAndroidTestRunner(); + + runner.addTestListener(new TestListener() { + private Class lastClass; + + public void startTest(Test test) { + if (test.getClass() != lastClass) { + printMemory(test.getClass()); + } + + Thread.currentThread().setContextClassLoader( + test.getClass().getClassLoader()); + } + + public void endTest(Test test) { + if (test instanceof TestCase) { + if (lastClass == null) { + lastClass = test.getClass(); + } else { + if (test.getClass() != lastClass) { + cleanup(lastClass); + lastClass = test.getClass(); + } + } + } + } + + public void addError(Test test, Throwable t) { + } + + public void addFailure(Test test, AssertionFailedError t) { + } + + /** + * Dumps some memory info. + */ + private void printMemory(Class 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 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(Class clazz) { + if (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(null, null); + } catch (Exception ignored) { + // Nothing we can do about it. + } + } + } + + // don't cleanup the superclass for now + //cleanup(clazz.getSuperclass()); + } + } + + }); + + return runner; + } + + @Override + List> getBuilderRequirements() { + List> builderRequirements = + super.getBuilderRequirements(); + Predicate brokenTestPredicate = + Predicates.not(new HasAnnotation(BrokenTest.class)); + builderRequirements.add(brokenTestPredicate); + if (!singleTest) { + Predicate sideEffectPredicate = + Predicates.not(new HasAnnotation(SideEffect.class)); + builderRequirements.add(sideEffectPredicate); + } + return builderRequirements; } } diff --git a/test-runner/android/test/InstrumentationTestRunner.java b/test-runner/android/test/InstrumentationTestRunner.java index 044f555..d5e6459 100644 --- a/test-runner/android/test/InstrumentationTestRunner.java +++ b/test-runner/android/test/InstrumentationTestRunner.java @@ -43,6 +43,8 @@ import java.io.File; import java.io.PrintStream; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.List; /** @@ -315,6 +317,8 @@ public class InstrumentationTestRunner extends Instrumentation implements TestSu } else { parseTestClasses(testClassesArg, testSuiteBuilder); } + + testSuiteBuilder.addRequirements(getBuilderRequirements()); mTestRunner = getAndroidTestRunner(); mTestRunner.setContext(getTargetContext()); @@ -331,6 +335,10 @@ public class InstrumentationTestRunner extends Instrumentation implements TestSu start(); } + List> getBuilderRequirements() { + return new ArrayList>(); + } + /** * Parses and loads the specified set of test classes * @param testClassArg - comma-separated list of test classes and methods -- cgit v1.1