/*
* Copyright (C) 2012 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 com.android.commands.uiautomator;
import android.os.Bundle;
import android.util.Log;
import com.android.commands.uiautomator.Launcher.Command;
import com.android.uiautomator.testrunner.UiAutomatorTestRunner;
import dalvik.system.DexFile;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
/**
* Implementation of the runtest sub command
*
*/
public class RunTestCommand extends Command {
private static final String LOGTAG = RunTestCommand.class.getSimpleName();
private static final String OUTPUT_SIMPLE = "simple";
private static final String OUTPUT_FORMAT_KEY = "outputFormat";
private static final String CLASS_PARAM = "class";
private static final String JARS_PARAM = "jars";
private static final String DEBUG_PARAM = "debug";
private static final String RUNNER_PARAM = "runner";
private static final String CLASS_SEPARATOR = ",";
private static final String JARS_SEPARATOR = ":";
private static final int ARG_OK = 0;
private static final int ARG_FAIL_INCOMPLETE_E = -1;
private static final int ARG_FAIL_INCOMPLETE_C = -2;
private static final int ARG_FAIL_NO_CLASS = -3;
private static final int ARG_FAIL_RUNNER = -4;
private static final int ARG_FAIL_UNSUPPORTED = -99;
private final Bundle mParams = new Bundle();
private final List<String> mTestClasses = new ArrayList<String>();
private boolean mDebug;
private boolean mMonkey = false;
private String mRunnerClassName;
private UiAutomatorTestRunner mRunner;
public RunTestCommand() {
super("runtest");
}
@Override
public void run(String[] args) {
int ret = parseArgs(args);
switch (ret) {
case ARG_FAIL_INCOMPLETE_C:
System.err.println("Incomplete '-c' parameter.");
System.exit(ARG_FAIL_INCOMPLETE_C);
break;
case ARG_FAIL_INCOMPLETE_E:
System.err.println("Incomplete '-e' parameter.");
System.exit(ARG_FAIL_INCOMPLETE_E);
break;
case ARG_FAIL_UNSUPPORTED:
System.err.println("Unsupported standalone parameter.");
System.exit(ARG_FAIL_UNSUPPORTED);
break;
default:
break;
}
if (mTestClasses.isEmpty()) {
addTestClassesFromJars();
if (mTestClasses.isEmpty()) {
System.err.println("No test classes found.");
System.exit(ARG_FAIL_NO_CLASS);
}
}
getRunner().run(mTestClasses, mParams, mDebug, mMonkey);
}
private int parseArgs(String[] args) {
// we are parsing for these parameters:
// -e <key> <value>
// key-value pairs
// special ones are:
// key is "class", parameter is passed onto JUnit as class name to run
// key is "debug", parameter will determine whether to wait for debugger
// to attach
// -c <class name>
// -s turns on the simple output format
// equivalent to -e class <class name>, i.e. passed onto JUnit
for (int i = 0; i < args.length; i++) {
if (args[i].equals("-e")) {
if (i + 2 < args.length) {
String key = args[++i];
String value = args[++i];
if (CLASS_PARAM.equals(key)) {
addTestClasses(value);
} else if (DEBUG_PARAM.equals(key)) {
mDebug = "true".equals(value) || "1".equals(value);
} else if (RUNNER_PARAM.equals(key)) {
mRunnerClassName = value;
} else {
mParams.putString(key, value);
}
} else {
return ARG_FAIL_INCOMPLETE_E;
}
} else if (args[i].equals("-c")) {
if (i + 1 < args.length) {
addTestClasses(args[++i]);
} else {
return ARG_FAIL_INCOMPLETE_C;
}
} else if (args[i].equals("--monkey")) {
mMonkey = true;
} else if (args[i].equals("-s")) {
mParams.putString(OUTPUT_FORMAT_KEY, OUTPUT_SIMPLE);
} else {
return ARG_FAIL_UNSUPPORTED;
}
}
return ARG_OK;
}
protected UiAutomatorTestRunner getRunner() {
if (mRunner != null) {
return mRunner;
}
if (mRunnerClassName == null) {
mRunner = new UiAutomatorTestRunner();
return mRunner;
}
// use reflection to get the runner
Object o = null;
try {
Class<?> clazz = Class.forName(mRunnerClassName);
o = clazz.newInstance();
} catch (ClassNotFoundException cnfe) {
System.err.println("Cannot find runner: " + mRunnerClassName);
System.exit(ARG_FAIL_RUNNER);
} catch (InstantiationException ie) {
System.err.println("Cannot instantiate runner: " + mRunnerClassName);
System.exit(ARG_FAIL_RUNNER);
} catch (IllegalAccessException iae) {
System.err.println("Constructor of runner " + mRunnerClassName + " is not accessibile");
System.exit(ARG_FAIL_RUNNER);
}
try {
UiAutomatorTestRunner runner = (UiAutomatorTestRunner)o;
mRunner = runner;
return runner;
} catch (ClassCastException cce) {
System.err.println("Specified runner is not subclass of "
+ UiAutomatorTestRunner.class.getSimpleName());
System.exit(ARG_FAIL_RUNNER);
}
// won't reach here
return null;
}
/**
* Add test classes from a potentially comma separated list
* @param classes
*/
private void addTestClasses(String classes) {
String[] classArray = classes.split(CLASS_SEPARATOR);
for (String clazz : classArray) {
mTestClasses.add(clazz);
}
}
/**
* Add test classes from jars passed on the command line. Use this if nothing was explicitly
* specified on the command line.
*/
private void addTestClassesFromJars() {
String jars = mParams.getString(JARS_PARAM);
if (jars == null) return;
String[] jarFileNames = jars.split(JARS_SEPARATOR);
for (String fileName : jarFileNames) {
fileName = fileName.trim();
if (fileName.isEmpty()) continue;
try {
DexFile dexFile = new DexFile(fileName);
for(Enumeration<String> e = dexFile.entries(); e.hasMoreElements();) {
String className = e.nextElement();
if (isTestClass(className)) {
mTestClasses.add(className);
}
}
dexFile.close();
} catch (IOException e) {
Log.w(LOGTAG, String.format("Could not read %s: %s", fileName, e.getMessage()));
}
}
}
/**
* Tries to determine if a given class is a test class. A test class has to inherit from
* UiAutomator test case and it must be a top-level class.
* @param className
* @return
*/
private boolean isTestClass(String className) {
try {
Class<?> clazz = this.getClass().getClassLoader().loadClass(className);
if (clazz.getEnclosingClass() != null) return false;
return getRunner().getTestCaseFilter().accept(clazz);
} catch (ClassNotFoundException e) {
return false;
}
}
@Override
public String detailedOptions() {
return " runtest <class spec> [options]\n"
+ " <class spec>: <JARS> < -c <CLASSES> | -e class <CLASSES> >\n"
+ " <JARS>: a list of jar files containing test classes and dependencies. If\n"
+ " the path is relative, it's assumed to be under /data/local/tmp. Use\n"
+ " absolute path if the file is elsewhere. Multiple files can be\n"
+ " specified, separated by space.\n"
+ " <CLASSES>: a list of test class names to run, separated by comma. To\n"
+ " a single method, use TestClass#testMethod format. The -e or -c option\n"
+ " may be repeated. This option is not required and if not provided then\n"
+ " all the tests in provided jars will be run automatically.\n"
+ " options:\n"
+ " --nohup: trap SIG_HUP, so test won't terminate even if parent process\n"
+ " is terminated, e.g. USB is disconnected.\n"
+ " -e debug [true|false]: wait for debugger to connect before starting.\n"
+ " -e runner [CLASS]: use specified test runner class instead. If\n"
+ " unspecified, framework default runner will be used.\n"
+ " -e <NAME> <VALUE>: other name-value pairs to be passed to test classes.\n"
+ " May be repeated.\n"
+ " -e outputFormat simple | -s: enabled less verbose JUnit style output.\n";
}
@Override
public String shortHelp() {
return "executes UI automation tests";
}
}
|
