tools/runner/java/dalvik/runner/DalvikRunner.java

/*
 * Copyright (C) 2009 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;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import java.util.logging.ConsoleHandler;
import java.util.logging.Formatter;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

/**
 * Command line interface for running benchmarks and tests on dalvik.
 */
public final class DalvikRunner {

    static final File HOME = new File("dalvik/libcore/tools/runner");
    static final File HOME_JAVA = new File(HOME, "java");

    private static class Options {

        private final List<File> testFiles = new ArrayList<File>();

        @Option(names = { "--expectations" })
        private Set<File> expectationFiles = new LinkedHashSet<File>();
        {
            expectationFiles.add(new File("dalvik/libcore/tools/runner/expectations.txt"));
        }

        private static String MODE_DEVICE = "device";
        private static String MODE_HOST = "host";
        private static String MODE_ACTIVITY = "activity";
        @Option(names = { "--mode" })
        private String mode = MODE_DEVICE;

        @Option(names = { "--timeout" })
        private long timeoutSeconds = 10 * 60; // default is ten minutes;

        @Option(names = { "--clean-before" })
        private boolean cleanBefore = true;

        @Option(names = { "--clean-after" })
        private boolean cleanAfter = true;

        @Option(names = { "--clean" })
        private boolean clean = true;

        @Option(names = { "--xml-reports-directory" })
        private File xmlReportsDirectory;

        @Option(names = { "--verbose" })
        private boolean verbose;

        @Option(names = { "--tee" })
        private String teeName;
        private PrintStream tee;

        @Option(names = { "--debug" })
        private Integer debugPort;

        @Option(names = { "--device-runner-dir" })
        private File deviceRunnerDir = new File("/sdcard/dalvikrunner");

        @Option(names = { "--vm-arg" })
        private List<String> vmArgs = new ArrayList<String>();

        @Option(names = { "--java-home" })
        private File javaHome;

        @Option(names = { "--sdk" })
        private File sdkJar = new File("/home/dalvik-prebuild/android-sdk-linux/platforms/android-2.0/android.jar");

        private void printUsage() {
            System.out.println("Usage: DalvikRunner [options]... <tests>...");
            System.out.println();
            System.out.println("  <tests>: a .java file containing a jtreg test, JUnit test,");
            System.out.println("      Caliper benchmark, or a directory of such tests.");
            System.out.println();
            System.out.println("GENERAL OPTIONS");
            System.out.println();
            System.out.println("  --expectations <file>: include the specified file when looking for");
            System.out.println("      test expectations. The file should include qualified test names");
            System.out.println("      and the corresponding expected output.");
            System.out.println("      Default is: " + expectationFiles);
            System.out.println();
            System.out.println("  --mode <device|host|activity>: specify which environment to run the");
            System.out.println("      tests in. Options are on the device VM, on the host VM, and on");
            System.out.println("      device within an android.app.Activity.");
            System.out.println("      Default is: " + mode);
            System.out.println();
            System.out.println("  --clean-before: remove working directories before building and");
            System.out.println("      running (default). Disable with --no-clean-before if you are");
            System.out.println("      using interactively with your own temporary input files.");
            System.out.println();
            System.out.println("  --clean-after: remove temporary files after running (default).");
            System.out.println("      Disable with --no-clean-after and use with --verbose if");
            System.out.println("      you'd like to manually re-run commands afterwards.");
            System.out.println();
            System.out.println("  --clean: synonym for --clean-before and --clean-after (default).");
            System.out.println("      Disable with --no-clean if you want no files removed.");
            System.out.println();
            System.out.println("  --tee <file>: emit test output to file during execution.");
            System.out.println("      Specify '-' for stdout.");
            System.out.println();
            System.out.println("  --timeout-seconds <seconds>: maximum execution time of each");
            System.out.println("      test before the runner aborts it.");
            System.out.println("      Default is: " + timeoutSeconds);
            System.out.println();
            System.out.println("  --xml-reports-directory <path>: directory to emit JUnit-style");
            System.out.println("      XML test results.");
            System.out.println();
            System.out.println("  --verbose: turn on verbose output");
            System.out.println();
            System.out.println("DEVICE OPTIONS");
            System.out.println();
            System.out.println("  --debug <port>: enable Java debugging on the specified port.");
            System.out.println("      This port must be free both on the device and on the local");
            System.out.println("      system.");
            System.out.println();
            System.out.println("  --device-runner-dir <directory>: use the specified directory for");
            System.out.println("      on-device temporary files and code.");
            System.out.println("      Default is: " + deviceRunnerDir);
            System.out.println();
            System.out.println("GENERAL VM OPTIONS");
            System.out.println();
            System.out.println("  --vm-arg <argument>: include the specified argument when spawning a");
            System.out.println("      virtual machine. Examples: -Xint:fast, -ea, -Xmx16M");
            System.out.println();
            System.out.println("HOST VM OPTIONS");
            System.out.println();
            System.out.println("  --java-home <java_home>: execute the tests on the local workstation");
            System.out.println("      using the specified java home directory. This does not impact");
            System.out.println("      which javac gets used. When unset, java is used from the PATH.");
            System.out.println();
            System.out.println("COMPILE OPTIONS");
            System.out.println();
            System.out.println("  --sdk <android jar>: the API jar file to compile against.");
            System.out.println("      Usually this is <SDK>/platforms/android-<X.X>/android.jar");
            System.out.println("      where <SDK> is the path to an Android SDK path and <X.X> is");
            System.out.println("      a release version like 1.5.");
            System.out.println("      Default is: " + sdkJar);
            System.out.println();
        }

        private boolean parseArgs(String[] args) {
            final List<String> testFilenames;
            try {
                testFilenames = new OptionParser(this).parse(args);
            } catch (RuntimeException e) {
                System.out.println(e.getMessage());
                return false;
            }

            //
            // Semantic error validation
            //

            boolean device;
            boolean vm;
            if (mode.equals(MODE_DEVICE)) {
                device = true;
                vm = true;
            } else if (mode.equals(MODE_HOST)) {
                device = false;
                vm = true;
            } else if (mode.equals(MODE_ACTIVITY)) {
                device = true;
                vm = false;
            } else {
                System.out.println("Unknown mode: " + mode);
                return false;
            }


            if (device) { // check device option consistency
                if (javaHome != null) {
                    System.out.println("java home " + javaHome + " should not be specified for mode " + mode);
                    return false;
                }

            } else { // check host (!device) option consistency
                if (javaHome != null && !new File(javaHome, "/bin/java").exists()) {
                    System.out.println("Invalid java home: " + javaHome);
                    return false;
                }
            }

            // check vm option consistency
            if (!vm) {
                if (!vmArgs.isEmpty()) {
                    System.out.println("vm args " + vmArgs + " should not be specified for mode " + mode);
                    return false;
                }
            }

            if (!sdkJar.exists()) {
                System.out.println("Could not find SDK jar: " + sdkJar);
                return false;
            }

            if (xmlReportsDirectory != null && !xmlReportsDirectory.isDirectory()) {
                System.out.println("Invalid XML reports directory: " + xmlReportsDirectory);
                return false;
            }

            if (testFilenames.isEmpty()) {
                System.out.println("No tests provided.");
                return false;
            }

            if (!clean) {
                cleanBefore = false;
                cleanAfter = false;
            }

            //
            // Post-processing arguments
            //

            for (String testFilename : testFilenames) {
                testFiles.add(new File(testFilename));
            }

            if (teeName != null) {
                if (teeName.equals("-")) {
                    tee = System.out;
                } else {
                    try {
                        tee = new PrintStream(new BufferedOutputStream(new FileOutputStream(teeName)));
                    } catch (FileNotFoundException e) {
                        System.out.println("Could not open file teeName: " + e);
                        return false;
                    }
                }
            }

            if (verbose) {
                Logger.getLogger("dalvik.runner").setLevel(Level.FINE);
            }

            return true;
        }

    }

    private final Options options = new Options();
    private final File localTemp = new File("/tmp/dalvikrunner/" + UUID.randomUUID());

    private DalvikRunner() {}

    private void prepareLogging() {
        ConsoleHandler handler = new ConsoleHandler();
        handler.setLevel(Level.ALL);
        handler.setFormatter(new Formatter() {
            @Override public String format(LogRecord r) {
                return r.getMessage() + "\n";
            }
        });
        Logger logger = Logger.getLogger("dalvik.runner");
        logger.addHandler(handler);
        logger.setUseParentHandlers(false);
    }

    private void run() {
        Mode mode;
        if (options.mode.equals(Options.MODE_DEVICE)) {
            mode = new DeviceDalvikVm(
                    options.debugPort,
                    options.timeoutSeconds,
                    options.sdkJar,
                    options.tee,
                    localTemp,
                    options.vmArgs,
                    options.cleanBefore,
                    options.cleanAfter,
                    options.deviceRunnerDir);
        } else if (options.mode.equals(Options.MODE_HOST)) {
            mode = new JavaVm(
                    options.debugPort,
                    options.timeoutSeconds,
                    options.sdkJar,
                    options.tee,
                    localTemp,
                    options.javaHome,
                    options.vmArgs,
                    options.cleanBefore,
                    options.cleanAfter);
        } else if (options.mode.equals(Options.MODE_ACTIVITY)) {
            mode = new ActivityMode(
                    options.debugPort,
                    options.timeoutSeconds,
                    options.sdkJar,
                    options.tee,
                    localTemp,
                    options.cleanBefore,
                    options.cleanAfter,
                    options.deviceRunnerDir);
        } else {
            System.out.println("Unknown mode mode " + options.mode + ".");
            return;
        }

        List<CodeFinder> codeFinders = Arrays.asList(
                new JtregFinder(localTemp),
                new JUnitFinder(),
                new CaliperFinder(),
                new MainFinder());
        Driver driver = new Driver(
                localTemp,
                mode,
                options.expectationFiles,
                options.xmlReportsDirectory,
                codeFinders);
        try {
            driver.loadExpectations();
        } catch (IOException e) {
            System.out.println("Problem loading expectations: " + e);
            return;
        }

        driver.buildAndRunAllTests(options.testFiles);
        mode.shutdown();
    }

    public static void main(String[] args) {
        DalvikRunner dalvikRunner = new DalvikRunner();
        if (!dalvikRunner.options.parseArgs(args)) {
            dalvikRunner.options.printUsage();
            return;
        }
        dalvikRunner.prepareLogging();
        dalvikRunner.run();
    }
}