Remove TestRunner.success field / Make postCompileTest return void

SUMMARY:
- Change TestRunner subclasses to instead implement a Runner interface
- Cleanup runtime classpath generation
- Misc improvements

DETAILS:

Change TestRunner subclasses to instead implement a Runner interface

    *Runner classes now implement the new Runner interface instead of
    extending TestRunner. prepareTest/test now take a "Class
    testClass" instead of accessing a "String testClass" from the
    superclass. This also means that all their "static void main"
    methods are removed and replaced with a single main method in
    TestRunner. TestActivity can now instantiate a TestRunner and call
    its "boolean run()" method to execute tests and retrieve their
    SUCCESS/FAILURE status via the return value, allowing the removeal
    of TestRunner.success. Mode now needs to explicitly include
    TestRunner.java in the list of code to compile because it no
    longer is implicitly found by compiling its former subclasses.

	java/dalvik/runner/TestRunner.java
	java/dalvik/runner/Runner.java
	java/dalvik/runner/CaliperRunner.java
	java/dalvik/runner/JUnitRunner.java
	java/dalvik/runner/JtregRunner.java
	java/dalvik/runner/MainRunner.java
	java/dalvik/runner/Mode.java

    CodeFinder.getRunnerClass now returns a Runner, not a TestRunner

	java/dalvik/runner/CodeFinder.java
	java/dalvik/runner/JUnitFinder.java
	java/dalvik/runner/CaliperFinder.java
	java/dalvik/runner/JtregFinder.java
	java/dalvik/runner/MainFinder.java

    Similarly, TestRun.runnerClass is now a Runner, not a TestRunner

	java/dalvik/runner/TestRun.java

    Move logic to run a test based on TestProperties.RUNNER_CLASS from
    TestActivity to TestRunner since its now used in all cases, not
    just the Activity case. TestActivity.ActivityRunner remains the
    one subclass of TestRunner, accessing the TestRunner.run(...)
    logic via super.run(...), allowing it to maintain its special
    result file writing logic.

	java/dalvik/runner/TestActivity.java
	java/dalvik/runner/TestRunner.java

    Moved writing of TestProperties.RUNNER_CLASS from ActivityMode now
    that it is used for all Modes.

	java/dalvik/runner/ActivityMode.java
	java/dalvik/runner/Mode.java

    Since CaliperRunner now has a "Class testClass", it uses the more
    strongly typed Runner.main(Class<? extends Benchmark>, ...)  API.

	java/dalvik/runner/CaliperRunner.java

    Fixing javadoc TestRunner->Runner
	java/dalvik/runner/TestProperties.java

    Adding new Runner class to the build.

	Android.mk

Cleanup runtime classpath generation

    Changed Mode.postCompileTest to return void instead of Classpath
    to match Most.postCompileTestRunner. Removed passing test
    classpath from compile to run via TestRun.testClasspath. Instead,
    Vm.getRuntimeSupportClasspath now is used to compute full
    classpath, instead of using the old TestRun.getTestClasspath in
    Mode. Mode.compileTest now uses a boolean to indicate compilation
    success, instead of null/non-null Classpath. TestRun.testClasspath
    is now replaced with TestRun.testCompiled which is used to track
    compilation success. In retrospect, it seems like using the
    absense of a Classpath as an indication of compilation
    success/failure seems like somewhat of a hack.

	java/dalvik/runner/Mode.java
	java/dalvik/runner/ActivityMode.java
	java/dalvik/runner/DeviceDalvikVm.java
	java/dalvik/runner/JavaVm.java
	java/dalvik/runner/TestRun.java

    New deviceDexFile to make sure dex file name generation stays
    consistent between build time and compile time.

	java/dalvik/runner/DeviceDalvikVm.java

    Changed MainRunner implementation to more closely match JtregRunner
	java/dalvik/runner/MainRunner.java

Misc improvements

    Changed TestActivity to use a shutdown hook to catch when a test
    calls System.exit so we can be sure to write a result file and not
    simply wait for the timeout to catch our failure to return.

	java/dalvik/runner/TestActivity.java

    Changed Mkdir.mkdirs to use new Command().execute to get automatic
    logging of command execution with --verbose

	java/dalvik/runner/Mkdir.java

    Improved javadoc

	java/dalvik/runner/Mode.java

    Fixed apparently misplaced @SuppressWarnings("unchecked")
	java/dalvik/runner/OptionParser.java

    Enabling warnings as errors and turning on unchecked warnings.

	Android.mk

    Made sure test script works with fresh device and improved logging

	test-dalvik-runner.sh

24 files changed, 198 insertions, 126 deletions

diff --git a/tools/runner/Android.mk b/tools/runner/Android.mk
index 4100ea0..bc7c5b7 100644
--- a/tools/runner/Android.mk
+++ b/tools/runner/Android.mk
@@ -43,6 +43,7 @@ LOCAL_SRC_FILES := \
         java/dalvik/runner/OptionParser.java \
         java/dalvik/runner/Result.java \
         java/dalvik/runner/Rm.java \
+        java/dalvik/runner/Runner.java \
         java/dalvik/runner/Strings.java \
         java/dalvik/runner/TestProperties.java \
         java/dalvik/runner/TestRun.java \
@@ -57,6 +58,8 @@ LOCAL_STATIC_JAVA_LIBRARIES := javatest jh jtreg kxml2-2.3.0
 # TODO this only works when junit is already built...
 LOCAL_JAVA_LIBRARIES := junit
 
+LOCAL_JAVACFLAGS := -Werror -Xlint:unchecked
+
 include $(BUILD_HOST_JAVA_LIBRARY)
 
 include $(call all-subdir-makefiles)
diff --git a/tools/runner/java/dalvik/runner/ActivityMode.java b/tools/runner/java/dalvik/runner/ActivityMode.java
index b1ff48c..dd7c420 100644
--- a/tools/runner/java/dalvik/runner/ActivityMode.java
+++ b/tools/runner/java/dalvik/runner/ActivityMode.java
@@ -48,14 +48,14 @@ final class ActivityMode extends Mode {
     }
 
     @Override protected void prepare(Set<File> testRunnerJava, Classpath testRunnerClasspath) {
-        super.prepare(testRunnerJava, testRunnerClasspath);
         testRunnerJava.add(new File(DalvikRunner.HOME_JAVA, "dalvik/runner/TestActivity.java"));
+        super.prepare(testRunnerJava, testRunnerClasspath);
     }
 
     @Override protected void postCompileTestRunner() {
     }
 
-    @Override protected Classpath postCompileTest(TestRun testRun) {
+    @Override protected void postCompileTest(TestRun testRun) {
         logger.fine("aapt and push " + testRun.getQualifiedName());
 
         // Some things of note:
@@ -88,7 +88,6 @@ final class ActivityMode extends Mode {
         File apkUnsigned = createApk(testRun, dex);
         File apkSigned = signApk(testRun, apkUnsigned);
         installApk(testRun, apkSigned);
-        return Classpath.of(apkSigned);
     }
 
     private File makePackagingDirectory(TestRun testRun) {
@@ -209,7 +208,6 @@ final class ActivityMode extends Mode {
 
     @Override protected void fillInProperties(Properties properties, TestRun testRun) {
         super.fillInProperties(properties, testRun);
-        properties.setProperty(TestProperties.RUNNER_CLASS, testRun.getRunnerClass().getName());
         properties.setProperty(TestProperties.DEVICE_RUNNER_DIR, getEnvironmentDevice().runnerDir.getPath());
     }
 
diff --git a/tools/runner/java/dalvik/runner/CaliperFinder.java b/tools/runner/java/dalvik/runner/CaliperFinder.java
index d8d5f0d..094609a 100644
--- a/tools/runner/java/dalvik/runner/CaliperFinder.java
+++ b/tools/runner/java/dalvik/runner/CaliperFinder.java
@@ -32,7 +32,7 @@ class CaliperFinder extends NamingPatternCodeFinder {
         return "caliper";
     }
 
-    public Class<? extends TestRunner> getRunnerClass() {
+    public Class<? extends Runner> getRunnerClass() {
         return CaliperRunner.class;
     }
 
diff --git a/tools/runner/java/dalvik/runner/CaliperRunner.java b/tools/runner/java/dalvik/runner/CaliperRunner.java
index 0fb95c4..b30644b 100644
--- a/tools/runner/java/dalvik/runner/CaliperRunner.java
+++ b/tools/runner/java/dalvik/runner/CaliperRunner.java
@@ -16,23 +16,22 @@
 
 package dalvik.runner;
 
+import com.google.caliper.Benchmark;
 import com.google.caliper.Runner;
 
 /**
  * Runs a <a href="http://code.google.com/p/caliper/">Caliper</a> benchmark.
  */
-public final class CaliperRunner extends TestRunner {
+public final class CaliperRunner implements dalvik.runner.Runner {
 
-    @Override public boolean test() {
+    public void prepareTest(Class<?> testClass) {}
+
+    public boolean test(Class<?> testClass) {
         try {
-            Runner.main(testClass);
+            Runner.main(testClass.asSubclass(Benchmark.class), new String[0]);
         } catch (Exception ex) {
             ex.printStackTrace();
         }
         return false; // always print benchmarking results
     }
-
-    public static void main(String[] args) throws Exception {
-        new CaliperRunner().run();
-    }
 }
diff --git a/tools/runner/java/dalvik/runner/CodeFinder.java b/tools/runner/java/dalvik/runner/CodeFinder.java
index dc583b9..f770fa4 100644
--- a/tools/runner/java/dalvik/runner/CodeFinder.java
+++ b/tools/runner/java/dalvik/runner/CodeFinder.java
@@ -33,7 +33,7 @@ public interface CodeFinder {
     /**
      * Return the class for the TestRunner
      */
-    public Class<? extends TestRunner> getRunnerClass();
+    public Class<? extends Runner> getRunnerClass();
 
     /**
      * Return the Java file for the TestRunner
diff --git a/tools/runner/java/dalvik/runner/DeviceDalvikVm.java b/tools/runner/java/dalvik/runner/DeviceDalvikVm.java
index a9af062..fec3463 100644
--- a/tools/runner/java/dalvik/runner/DeviceDalvikVm.java
+++ b/tools/runner/java/dalvik/runner/DeviceDalvikVm.java
@@ -50,11 +50,11 @@ final class DeviceDalvikVm extends Vm {
         postCompile("testrunner", environment.testRunnerClassesDir());
     }
 
-    @Override protected Classpath postCompileTest(TestRun testRun) {
-        return postCompile(testRun.getQualifiedName(), environment.testClassesDir(testRun));
+    @Override protected void postCompileTest(TestRun testRun) {
+        postCompile(testRun.getQualifiedName(), environment.testClassesDir(testRun));
     }
 
-    private Classpath postCompile(String name, File dir) {
+    private void postCompile(String name, File dir) {
         logger.fine("dex and push " + name);
 
         // make the local dex (inside a jar)
@@ -62,10 +62,12 @@ final class DeviceDalvikVm extends Vm {
         new Dx().dex(localDex, Classpath.of(dir));
 
         // post the local dex to the device
-        File deviceDex = new File(getEnvironmentDevice().runnerDir, name + ".jar");
+        File deviceDex = deviceDexFile(name);
         getEnvironmentDevice().adb.push(localDex, deviceDex);
+    }
 
-        return Classpath.of(deviceDex);
+    private File deviceDexFile(String name) {
+        return new File(getEnvironmentDevice().runnerDir, name + ".jar");
     }
 
     @Override protected VmCommandBuilder newVmCommandBuilder(
@@ -81,7 +83,11 @@ final class DeviceDalvikVm extends Vm {
                 .temp(getEnvironmentDevice().testTemp);
     }
 
-    @Override protected Classpath getRuntimeSupportClasspath() {
-        return RUNTIME_SUPPORT_CLASSPATH;
+    @Override protected Classpath getRuntimeSupportClasspath(TestRun testRun) {
+        Classpath classpath = new Classpath();
+        classpath.addAll(deviceDexFile(testRun.getQualifiedName()));
+        classpath.addAll(deviceDexFile("testrunner"));
+        classpath.addAll(RUNTIME_SUPPORT_CLASSPATH);
+        return classpath;
     }
 }
diff --git a/tools/runner/java/dalvik/runner/Driver.java b/tools/runner/java/dalvik/runner/Driver.java
index caf523d..a868925 100644
--- a/tools/runner/java/dalvik/runner/Driver.java
+++ b/tools/runner/java/dalvik/runner/Driver.java
@@ -156,6 +156,9 @@ final class Driver {
             TestRun testRun;
             try {
                 Future<TestRun> future = builders.poll(5 * 60, TimeUnit.SECONDS);
+                if (future == null) {
+                    throw new RuntimeException("Timeout for build and install");
+                }
                 testRun = future.get();
             } catch (ExecutionException e) {
                 throw new RuntimeException("Unexpected exception building test", e);
diff --git a/tools/runner/java/dalvik/runner/JUnitFinder.java b/tools/runner/java/dalvik/runner/JUnitFinder.java
index 5c0cff2..131a8cf 100644
--- a/tools/runner/java/dalvik/runner/JUnitFinder.java
+++ b/tools/runner/java/dalvik/runner/JUnitFinder.java
@@ -32,7 +32,7 @@ class JUnitFinder extends NamingPatternCodeFinder {
         return "junit";
     }
 
-    public Class<? extends TestRunner> getRunnerClass() {
+    public Class<? extends Runner> getRunnerClass() {
         return JUnitRunner.class;
     }
 
diff --git a/tools/runner/java/dalvik/runner/JUnitRunner.java b/tools/runner/java/dalvik/runner/JUnitRunner.java
index 7c70365..4891448 100644
--- a/tools/runner/java/dalvik/runner/JUnitRunner.java
+++ b/tools/runner/java/dalvik/runner/JUnitRunner.java
@@ -23,7 +23,7 @@ import junit.runner.TestSuiteLoader;
 /**
  * Runs a JUnit test.
  */
-public final class JUnitRunner extends TestRunner {
+public final class JUnitRunner implements Runner {
 
     private final junit.textui.TestRunner testRunner;
     private Test junitTest;
@@ -46,16 +46,12 @@ public final class JUnitRunner extends TestRunner {
         };
     }
 
-    @Override public void prepareTest() {
-        junitTest = testRunner.getTest(testClass);
+    public void prepareTest(Class<?> testClass) {
+        junitTest = testRunner.getTest(testClass.getName());
     }
 
-    @Override public boolean test() {
+    public boolean test(Class<?> testClass) {
         TestResult result = testRunner.doRun(junitTest);
         return result.wasSuccessful();
     }
-
-    public static void main(String[] args) throws Exception {
-        new JUnitRunner().run();
-    }
 }
diff --git a/tools/runner/java/dalvik/runner/JavaVm.java b/tools/runner/java/dalvik/runner/JavaVm.java
index 02a3410..561b0ce 100644
--- a/tools/runner/java/dalvik/runner/JavaVm.java
+++ b/tools/runner/java/dalvik/runner/JavaVm.java
@@ -36,8 +36,7 @@ final class JavaVm extends Vm {
 
     @Override protected void postCompileTestRunner() {}
 
-    @Override protected Classpath postCompileTest(TestRun testRun) {
-        return Classpath.of(environment.testClassesDir(testRun));
+    @Override protected void postCompileTest(TestRun testRun) {
     }
 
     @Override protected VmCommandBuilder newVmCommandBuilder(
@@ -47,7 +46,12 @@ final class JavaVm extends Vm {
                 .vmCommand(java)
                 .workingDir(workingDirectory);
     }
-    protected Classpath getRuntimeSupportClasspath() {
-        return testClasspath;
+    @Override protected Classpath getRuntimeSupportClasspath(TestRun testRun) {
+        Classpath classpath = new Classpath();
+        classpath.addAll(environment.testClassesDir(testRun));
+        classpath.addAll(testClasspath);
+        classpath.addAll(environment.testRunnerClassesDir());
+        classpath.addAll(testRunnerClasspath);
+        return classpath;
     }
 }
diff --git a/tools/runner/java/dalvik/runner/JtregFinder.java b/tools/runner/java/dalvik/runner/JtregFinder.java
index 3b52ffa..d846ae2 100644
--- a/tools/runner/java/dalvik/runner/JtregFinder.java
+++ b/tools/runner/java/dalvik/runner/JtregFinder.java
@@ -125,7 +125,7 @@ class JtregFinder implements CodeFinder {
         return s.replace('/', '.');
     }
 
-    public Class<? extends TestRunner> getRunnerClass() {
+    public Class<? extends Runner> getRunnerClass() {
         return JtregRunner.class;
     }
 
diff --git a/tools/runner/java/dalvik/runner/JtregRunner.java b/tools/runner/java/dalvik/runner/JtregRunner.java
index 6dcf885..633a529 100644
--- a/tools/runner/java/dalvik/runner/JtregRunner.java
+++ b/tools/runner/java/dalvik/runner/JtregRunner.java
@@ -21,20 +21,19 @@ import java.lang.reflect.Method;
 /**
  * Runs a jtreg test.
  */
-public final class JtregRunner extends TestRunner {
+public final class JtregRunner implements Runner {
 
     private Method main;
 
-    @Override public void prepareTest() {
+    public void prepareTest(Class<?> testClass) {
         try {
-            Class<?> test = Class.forName(testClass);
-            main = test.getMethod("main", String[].class);
+            main = testClass.getMethod("main", String[].class);
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }
 
-    @Override public boolean test() {
+    public boolean test(Class<?> testClass) {
         try {
             main.invoke(null, new Object[] { new String[0] });
             return true;
@@ -43,8 +42,4 @@ public final class JtregRunner extends TestRunner {
             return false;
         }
     }
-
-    public static void main(String[] args) {
-        new JtregRunner().run();
-    }
 }
diff --git a/tools/runner/java/dalvik/runner/MainFinder.java b/tools/runner/java/dalvik/runner/MainFinder.java
index ebd3b84..282969f 100644
--- a/tools/runner/java/dalvik/runner/MainFinder.java
+++ b/tools/runner/java/dalvik/runner/MainFinder.java
@@ -31,7 +31,7 @@ class MainFinder extends NamingPatternCodeFinder {
         return "main";
     }
 
-    public Class<? extends TestRunner> getRunnerClass() {
+    public Class<? extends Runner> getRunnerClass() {
         return MainRunner.class;
     }
 
diff --git a/tools/runner/java/dalvik/runner/MainRunner.java b/tools/runner/java/dalvik/runner/MainRunner.java
index db0c37f..34a4a47 100644
--- a/tools/runner/java/dalvik/runner/MainRunner.java
+++ b/tools/runner/java/dalvik/runner/MainRunner.java
@@ -21,20 +21,24 @@ import java.lang.reflect.Method;
 /**
  * Runs a Java class with a main method.
  */
-public final class MainRunner extends TestRunner {
+public final class MainRunner implements Runner {
 
-    @Override public boolean test() {
+    private Method main;
+
+    public void prepareTest(Class<?> testClass) {
         try {
-            Method mainMethod = Class.forName(testClass)
-                    .getDeclaredMethod("main", String[].class);
-            mainMethod.invoke(null, new Object[] { new String[0] });
+            main = testClass.getMethod("main", String[].class);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public boolean test(Class<?> testClass) {
+        try {
+            main.invoke(null, new Object[] { new String[0] });
         } catch (Throwable ex) {
             ex.printStackTrace();
         }
         return false; // always print main method output
     }
-
-    public static void main(String[] args) throws Exception {
-        new MainRunner().run();
-    }
 }
diff --git a/tools/runner/java/dalvik/runner/Mkdir.java b/tools/runner/java/dalvik/runner/Mkdir.java
index c3cc93f..46dcf08 100644
--- a/tools/runner/java/dalvik/runner/Mkdir.java
+++ b/tools/runner/java/dalvik/runner/Mkdir.java
@@ -24,8 +24,6 @@ import java.io.File;
 final class Mkdir {
 
     public void mkdirs(File directory) {
-        if (!directory.mkdirs()) {
-            throw new RuntimeException("Could not create directory " + directory);
-        }
+        new Command("mkdir", "-p", directory.getPath()).execute();
     }
 }
diff --git a/tools/runner/java/dalvik/runner/Mode.java b/tools/runner/java/dalvik/runner/Mode.java
index a9e98c0..0f0163f 100644
--- a/tools/runner/java/dalvik/runner/Mode.java
+++ b/tools/runner/java/dalvik/runner/Mode.java
@@ -48,7 +48,21 @@ abstract class Mode {
     protected final long timeoutSeconds;
     protected final File sdkJar;
 
+    /**
+     * Set of Java files needed to built to tun the currently selected
+     * set of tests. We build a subset rather than all the files all
+     * the time to reduce dex packaging costs in the activity mode
+     * case.
+     */
     protected final Set<File> testRunnerJava = new HashSet<File>();
+
+    /**
+     * Classpath of testRunner on the host side including any
+     * supporting libraries for testRunnerJava. Useful for compiling
+     * testRunnerJava as well as executing it on the host. Execution
+     * on the device requires further packaging typically done by
+     * postCompileTestRunner.
+     */
     protected final Classpath testRunnerClasspath = new Classpath();
 
     protected final Classpath testClasspath = Classpath.of(
@@ -73,6 +87,7 @@ abstract class Mode {
      * tests.
      */
     protected void prepare(Set<File> testRunnerJava, Classpath testRunnerClasspath) {
+        this.testRunnerJava.add(new File(DalvikRunner.HOME_JAVA, "dalvik/runner/TestRunner.java"));
         this.testRunnerJava.addAll(testRunnerJava);
         this.testRunnerClasspath.addAll(testRunnerClasspath);
         environment.prepare();
@@ -106,10 +121,10 @@ abstract class Mode {
     public void buildAndInstall(TestRun testRun) {
         logger.fine("build " + testRun.getQualifiedName());
 
-        Classpath testClasses;
+        boolean testCompiled;
         try {
-            testClasses = compileTest(testRun);
-            if (testClasses == null) {
+            testCompiled = compileTest(testRun);
+            if (!testCompiled) {
                 testRun.setResult(Result.UNSUPPORTED, Collections.<String>emptyList());
                 return;
             }
@@ -120,7 +135,7 @@ abstract class Mode {
             testRun.setResult(Result.ERROR, e);
             return;
         }
-        testRun.setTestClasspath(testClasses);
+        testRun.setTestCompiled(testCompiled);
         environment.prepareUserDir(testRun);
     }
 
@@ -131,9 +146,9 @@ abstract class Mode {
      *      null} if the test could not be compiled.
      * @throws CommandFailedException if javac fails
      */
-    private Classpath compileTest(TestRun testRun) throws IOException {
+    private boolean compileTest(TestRun testRun) throws IOException {
         if (!JAVA_TEST_PATTERN.matcher(testRun.getTestJava().toString()).find()) {
-            return null;
+            return false;
         }
 
         String qualifiedName = testRun.getQualifiedName();
@@ -157,16 +172,16 @@ abstract class Mode {
                 .sourcepath(testRun.getTestDirectory())
                 .destination(testClassesDir)
                 .compile(testRun.getTestJava());
-        return postCompileTest(testRun);
+        postCompileTest(testRun);
+        return true;
     }
 
     /**
      * Hook method called after test compilation.
      *
      * @param testRun The test being compiled
-     * @return the new result file.
      */
-    abstract protected Classpath postCompileTest(TestRun testRun);
+    abstract protected void postCompileTest(TestRun testRun);
 
 
     /**
@@ -175,6 +190,7 @@ abstract class Mode {
     protected void fillInProperties(Properties properties, TestRun testRun) {
         properties.setProperty(TestProperties.TEST_CLASS, testRun.getTestClass());
         properties.setProperty(TestProperties.QUALIFIED_NAME, testRun.getQualifiedName());
+        properties.setProperty(TestProperties.RUNNER_CLASS, testRun.getRunnerClass().getName());
     }
 
     /**
diff --git a/tools/runner/java/dalvik/runner/OptionParser.java b/tools/runner/java/dalvik/runner/OptionParser.java
index b64692a..3516264 100644
--- a/tools/runner/java/dalvik/runner/OptionParser.java
+++ b/tools/runner/java/dalvik/runner/OptionParser.java
@@ -288,6 +288,7 @@ public class OptionParser {
         }
     }
 
+    @SuppressWarnings("unchecked")
     private static void setValue(Object object, Field field, String arg, Handler handler, String valueText) {
 
         Object value = handler.translate(valueText);
@@ -298,7 +299,6 @@ public class OptionParser {
         try {
             field.setAccessible(true);
             if (Collection.class.isAssignableFrom(field.getType())) {
-                @SuppressWarnings("unchecked")
                 Collection collection = (Collection) field.get(object);
                 collection.add(value);
             } else {
diff --git a/tools/runner/java/dalvik/runner/Runner.java b/tools/runner/java/dalvik/runner/Runner.java
new file mode 100644
index 0000000..7d7b0ee
--- /dev/null
+++ b/tools/runner/java/dalvik/runner/Runner.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dalvik.runner;
+
+/**
+ * Interface between the generic TestRunner and the more specific
+ * backend implementations that know about specific types of tests.
+ */
+public interface Runner {
+
+    public void prepareTest(Class<?> testClass);
+
+    public boolean test(Class<?> testClass);
+}
diff --git a/tools/runner/java/dalvik/runner/TestActivity.java b/tools/runner/java/dalvik/runner/TestActivity.java
index 9f5f4c9..15206f8 100644
--- a/tools/runner/java/dalvik/runner/TestActivity.java
+++ b/tools/runner/java/dalvik/runner/TestActivity.java
@@ -58,29 +58,23 @@ public class TestActivity extends Activity {
 
     class ActivityRunner extends TestRunner {
 
-        private final String runnerClass;
         private final File runnerDir;
+        private final Thread shutdownHook = new Thread(new ShutdownHook());
 
         ActivityRunner() {
-            runnerClass = properties.getProperty(TestProperties.RUNNER_CLASS);
             runnerDir = new File(properties.getProperty(TestProperties.DEVICE_RUNNER_DIR));
         }
 
-        @Override public boolean test() {
+        @Override public boolean run() {
             log("Using " + runnerClass + " to run " + qualifiedName);
+            Runtime.getRuntime().addShutdownHook(shutdownHook);
+            boolean success = super.run();
+            Runtime.getRuntime().removeShutdownHook(shutdownHook);
+            writeResultFile(success);
+            return success;
+        }
 
-            boolean success;
-            try {
-                Method mainMethod = Class.forName(runnerClass)
-                        .getDeclaredMethod("main", String[].class);
-                mainMethod.invoke(null, new Object[] { new String[0] });
-                Field successField = TestRunner.class.getDeclaredField("success");
-                success = successField.getBoolean(null);
-            } catch (Throwable ex) {
-                log("Exception using " + runnerClass + " to run " + qualifiedName, ex);
-                success = false;
-            }
-
+        private void writeResultFile (boolean success) {
             String result = TestProperties.result(success);
             File resultDir = new File(runnerDir, qualifiedName);
             File resultTemp = new File(resultDir, TestProperties.RESULT_FILE + ".temp");
@@ -95,7 +89,17 @@ public class TestActivity extends Activity {
             } catch (IOException e) {
                 log("TestActivity could not create result file", e);
             }
-            return success;
+        }
+
+        /**
+         * Used to trap tests that try to exit on the their own. We
+         * treat this as a failure since they usually are calling
+         * System.exit with a non-zero value.
+         */
+        class ShutdownHook implements Runnable {
+            public void run() {
+                writeResultFile(false);
+            }
         }
     }
 }
diff --git a/tools/runner/java/dalvik/runner/TestProperties.java b/tools/runner/java/dalvik/runner/TestProperties.java
index 202d72d..1e90799 100644
--- a/tools/runner/java/dalvik/runner/TestProperties.java
+++ b/tools/runner/java/dalvik/runner/TestProperties.java
@@ -41,9 +41,9 @@ final public class TestProperties {
     public static final String QUALIFIED_NAME = "qualifiedName";
 
     /**
-     * Name of the property used by TestActivity to determine which
-     * class to use as the TestRunner name. This class should be a
-     * subclass of TestRunner.
+     * Name of the property used by TestRunner to determine which
+     * class to use as the Runner name. This class should implement
+     * Runner.
      */
     public static final String RUNNER_CLASS = "runnerClass";
 
diff --git a/tools/runner/java/dalvik/runner/TestRun.java b/tools/runner/java/dalvik/runner/TestRun.java
index 57233d5..c610b25 100644
--- a/tools/runner/java/dalvik/runner/TestRun.java
+++ b/tools/runner/java/dalvik/runner/TestRun.java
@@ -37,7 +37,7 @@ public final class TestRun {
     private final File testDirectory;
     private final File testJava;
     private final String testClass;
-    private final Class<? extends TestRunner> runnerClass;
+    private final Class<? extends Runner> runnerClass;
     private final File runnerJava;
     private final Classpath runnerClasspath;
 
@@ -46,7 +46,7 @@ public final class TestRun {
     private final String qualifiedName;
     private final String description;
 
-    private Classpath testClasspath;
+    private boolean testCompiled;
     private File userDir = new File(System.getProperty("user.dir"));
 
     private ExpectedResult expectedResult = ExpectedResult.SUCCESS;
@@ -55,7 +55,7 @@ public final class TestRun {
 
     public TestRun(File testDirectory, File testJava, String testClass,
             String suiteName, String testName, String qualifiedName,
-            String description, Class<? extends TestRunner> runnerClass,
+            String description, Class<? extends Runner> runnerClass,
             File runnerJava, Classpath runnerClasspath) {
         this.qualifiedName = qualifiedName;
         this.suiteName = suiteName;
@@ -123,15 +123,14 @@ public final class TestRun {
     }
 
     /**
-     * Initializes the path to the jar file or directory containing test
-     * classes.
+     * Set when the test is successfully compiled.
      */
-    public void setTestClasspath(Classpath classpath) {
-        this.testClasspath = classpath;
+    public void setTestCompiled(boolean testCompiled) {
+        this.testCompiled = testCompiled;
     }
 
-    public Classpath getTestClasspath() {
-        return testClasspath;
+    public boolean getTestCompiled() {
+        return testCompiled;
     }
 
     /**
@@ -150,7 +149,7 @@ public final class TestRun {
      * classpath prepared and have not yet been assigned a result.
      */
     public boolean isRunnable() {
-        return testClasspath != null && result == null;
+        return testCompiled && result == null;
     }
 
     public void setResult(Result result, Throwable e) {
@@ -181,7 +180,7 @@ public final class TestRun {
         return outputLines;
     }
 
-    public Class<? extends TestRunner> getRunnerClass() {
+    public Class<? extends Runner> getRunnerClass() {
         return runnerClass;
     }
 
diff --git a/tools/runner/java/dalvik/runner/TestRunner.java b/tools/runner/java/dalvik/runner/TestRunner.java
index 8ed5ed6..a706d40 100644
--- a/tools/runner/java/dalvik/runner/TestRunner.java
+++ b/tools/runner/java/dalvik/runner/TestRunner.java
@@ -23,26 +23,19 @@ import java.util.Properties;
 /**
  * Runs a test.
  */
-public abstract class TestRunner {
-
-    /**
-     * A static field that allows TestActivity to access the
-     * underlying test result without depending on reading
-     * System.out. This is necessary because TestRunner subclasses are
-     * invoked via a tradtional static main method with a void return
-     * type.
-     */
-    public static boolean success;
+public class TestRunner {
 
     protected final Properties properties;
 
-    protected final String testClass;
     protected final String qualifiedName;
+    protected final Class<?> testClass;
+    protected final Class<?> runnerClass;
 
     protected TestRunner () {
         properties = loadProperties();
-        testClass = properties.getProperty(TestProperties.TEST_CLASS);
         qualifiedName = properties.getProperty(TestProperties.QUALIFIED_NAME);
+        testClass = classProperty(TestProperties.TEST_CLASS, Object.class);
+        runnerClass = classProperty(TestProperties.RUNNER_CLASS, Runner.class);
     }
 
     protected static Properties loadProperties() {
@@ -60,15 +53,38 @@ public abstract class TestRunner {
         }
     }
 
-    public void prepareTest() {}
-
-    public abstract boolean test();
+    private Class<?> classProperty(String propertyName, Class<?> superClass) {
+        String className = properties.getProperty(propertyName);
+        if (className == null) {
+            throw new IllegalArgumentException("Could not find property for " +
+                                               propertyName);
+        }
+        try {
+            Class<?> klass = Class.forName(className);
+            if (!superClass.isAssignableFrom(klass)) {
+                throw new IllegalArgumentException(
+                        className + " can not be assigned to " + Runner.class);
+            }
+            return klass;
+        } catch (ClassNotFoundException e) {
+            throw new RuntimeException(e);
+        }
+    }
 
-    public void run() {
-        prepareTest();
+    public boolean run() {
+        Runner runner;
+        try {
+            runner = (Runner) runnerClass.newInstance();
+        } catch (InstantiationException e) {
+            throw new RuntimeException(e);
+        } catch (IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+        runner.prepareTest(testClass);
+        return runner.test(testClass);
+    }
 
-        System.out.println("Executing " + qualifiedName);
-        success = test();
-        System.out.println(TestProperties.result(success));
+    public static void main(String[] args) {
+        System.out.println(TestProperties.result(new TestRunner().run()));
     }
 }
diff --git a/tools/runner/java/dalvik/runner/Vm.java b/tools/runner/java/dalvik/runner/Vm.java
index d0e621a..9f96ec5 100644
--- a/tools/runner/java/dalvik/runner/Vm.java
+++ b/tools/runner/java/dalvik/runner/Vm.java
@@ -49,14 +49,11 @@ public abstract class Vm extends Mode {
      */
     @Override protected List<Command> buildCommands(TestRun testRun) {
         return Collections.singletonList(newVmCommandBuilder(testRun.getUserDir())
-                .classpath(testRun.getTestClasspath())
-                .classpath(testRun.getRunnerClasspath())
-                .classpath(testRunnerClasspath)
-                .classpath(getRuntimeSupportClasspath())
+                .classpath(getRuntimeSupportClasspath(testRun))
                 .userDir(testRun.getUserDir())
                 .debugPort(environment.debugPort)
                 .vmArgs(additionalVmArgs)
-                .mainClass(testRun.getRunnerClass().getName())
+                .mainClass(TestRunner.class.getName())
                 .build());
     }
 
@@ -69,7 +66,7 @@ public abstract class Vm extends Mode {
      * Returns the classpath containing JUnit and the dalvik annotations
      * required for test execution.
      */
-    protected abstract Classpath getRuntimeSupportClasspath();
+    protected abstract Classpath getRuntimeSupportClasspath(TestRun testRun);
 
     /**
      * Builds a virtual machine command.
diff --git a/tools/runner/test-dalvik-runner.sh b/tools/runner/test-dalvik-runner.sh
index 21b4924..1b9c35d 100755
--- a/tools/runner/test-dalvik-runner.sh
+++ b/tools/runner/test-dalvik-runner.sh
@@ -33,15 +33,21 @@ tests="$test_jtreg $test_junit $test_caliper $test_main"
 
 cd $ANDROID_BUILD_TOP
 . ./build/envsetup.sh
-m core-tests junit caliper snod
+m core-tests junit caliper snod && adb reboot bootloader && fastboot flashall && adb wait-for-device
+# when the device first comes up /sdcard is not mounted
+while [ -z "`adb shell ls /sdcard | tr -d '\r\n'`" ] ; do sleep 1; done
 mmm dalvik/libcore/tools/runner
 
 #verbose=--verbose
-#clean=--no-clean
+#clean=--no-clean-after
+extras="$verbose $clean"
+
+dalvik_runner="java -cp out/host/linux-x86/framework/dalvik_runner.jar dalvik.runner.DalvikRunner"
 
 for mode in $modes; do
     for test in $tests; do
-        echo RUNNING $mode $test 
-        java -cp out/host/linux-x86/framework/dalvik_runner.jar dalvik.runner.DalvikRunner --mode $mode $verbose $clean $test
+        command="$dalvik_runner --mode $mode $extras $test"
+        echo RUNNING $command
+        $command
     done
 done