libcore/tools/runner/java/dalvik/runner/Mode.java - platform/dalvik - Git at Google

 /*
  * 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;

 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.FilenameFilter;
 import java.io.IOException;
 import java.io.PrintStream;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Properties;
 import java.util.Set;
 import java.util.concurrent.TimeoutException;
 import java.util.logging.Logger;
 import java.util.regex.Pattern;

 /**
  * A Mode for running tests. Examples including running in a virtual
  * machine either on the host or a device or within a specific context
  * such as within an Activity.
  */
 abstract class Mode {

     private static final Pattern JAVA_TEST_PATTERN = Pattern.compile("\\/(\\w)+\\.java$");

     private static final Logger logger = Logger.getLogger(Mode.class.getName());

     protected final Environment environment;
     protected final long timeoutSeconds;
     protected final File sdkJar;
     protected final PrintStream tee;

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

     // TODO: this should be an immutable collection.
     protected final Classpath testClasspath = Classpath.of(
             new File("dalvik/libcore/tools/runner/lib/jsr305.jar"),
             new File("dalvik/libcore/tools/runner/lib/guava.jar"),
             new File("dalvik/libcore/tools/runner/lib/caliper.jar"),
             // TODO: we should be able to work with a shipping SDK, not depend on out/...
             // dalvik/libcore/**/test/ for junit
             // TODO: jar up just the junit classes and drop the jar in our lib/ directory.
             new File("out/target/common/obj/JAVA_LIBRARIES/core-tests_intermediates/classes.jar").getAbsoluteFile());

     Mode(Environment environment, long timeoutSeconds, File sdkJar, PrintStream tee) {
         this.environment = environment;
         this.timeoutSeconds = timeoutSeconds;
         this.sdkJar = sdkJar;
         this.tee = tee;
     }

     /**
      * Initializes the temporary directories and test harness necessary to run
      * tests.
      */
     protected void prepare(Set<File> testRunnerJava, Classpath testRunnerClasspath) {
         this.testRunnerJava.add(new File(DalvikRunner.HOME_JAVA, "dalvik/runner/TestRunner.java"));
         this.testRunnerJava.addAll(dalvikAnnotationSourceFiles());
         this.testRunnerJava.addAll(testRunnerJava);
         this.testRunnerClasspath.addAll(testRunnerClasspath);
         environment.prepare();
         compileTestRunner();
     }

     private List<File> dalvikAnnotationSourceFiles() {
         // Hopefully one day we'll strip the dalvik annotations out, but until then we need to make
         // them available to javac(1).
         File sourceDir = new File("dalvik/libcore/dalvik/src/main/java/dalvik/annotation");
         File[] javaSourceFiles = sourceDir.listFiles(new FilenameFilter() {
             public boolean accept(File dir, String filename) {
                 return filename.endsWith(".java");
             }
         });
         return Arrays.asList(javaSourceFiles);
     }

     private void compileTestRunner() {
         logger.fine("build testrunner");

         Classpath classpath = new Classpath();
         classpath.addAll(testClasspath);
         classpath.addAll(testRunnerClasspath);

         File base = environment.testRunnerClassesDir();
         new Mkdir().mkdirs(base);
         new Javac()
                 .bootClasspath(sdkJar)
                 .classpath(classpath)
                 .sourcepath(DalvikRunner.HOME_JAVA)
                 .destination(base)
                 .compile(testRunnerJava);
         postCompileTestRunner();
     }

     /**
      * Hook method called after TestRunner compilation.
      */
     abstract protected void postCompileTestRunner();

     /**
      * Compiles classes for the given test and makes them ready for execution.
      * If the test could not be compiled successfully, it will be updated with
      * the appropriate test result.
      */
     public void buildAndInstall(TestRun testRun) {
         logger.fine("build " + testRun.getQualifiedName());

         boolean testCompiled;
         try {
             testCompiled = compileTest(testRun);
             if (!testCompiled) {
                 testRun.setResult(Result.UNSUPPORTED, Collections.<String>emptyList());
                 return;
             }
         } catch (CommandFailedException e) {
             testRun.setResult(Result.COMPILE_FAILED, e.getOutputLines());
             return;
         } catch (IOException e) {
             testRun.setResult(Result.ERROR, e);
             return;
         }
         testRun.setTestCompiled(testCompiled);
         environment.prepareUserDir(testRun);
     }

     /**
      * Compiles the classes for the described test.
      *
      * @return the path to the compiled classes (directory or jar), or {@code
      *      null} if the test could not be compiled.
      * @throws CommandFailedException if javac fails
      */
     private boolean compileTest(TestRun testRun) throws IOException {
         if (!JAVA_TEST_PATTERN.matcher(testRun.getTestJava().toString()).find()) {
             return false;
         }

         String qualifiedName = testRun.getQualifiedName();
         File testClassesDir = environment.testClassesDir(testRun);
         new Mkdir().mkdirs(testClassesDir);
         FileOutputStream propertiesOut = new FileOutputStream(
                 new File(testClassesDir, TestProperties.FILE));
         Properties properties = new Properties();
         fillInProperties(properties, testRun);
         properties.store(propertiesOut, "generated by " + Mode.class.getName());
         propertiesOut.close();

         Classpath classpath = new Classpath();
         classpath.addAll(testClasspath);
         classpath.addAll(testRun.getRunnerClasspath());

         Set<File> sourceFiles = new HashSet<File>();
         sourceFiles.add(testRun.getTestJava());
         sourceFiles.addAll(dalvikAnnotationSourceFiles());

         // compile the test case
         new Javac()
                 .bootClasspath(sdkJar)
                 .classpath(classpath)
                 .sourcepath(testRun.getTestDirectory())
                 .destination(testClassesDir)
                 .compile(sourceFiles);
         postCompileTest(testRun);
         return true;
     }

     /**
      * Hook method called after test compilation.
      *
      * @param testRun The test being compiled
      */
     abstract protected void postCompileTest(TestRun testRun);


     /**
      * Fill in properties for running in this 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());
     }

     /**
      * Runs the test, and updates its test result.
      */
     void runTest(TestRun testRun) {
         if (!testRun.isRunnable()) {
             throw new IllegalArgumentException();
         }

         List<String> output;
         try {
             output = runTestCommand(testRun);
         } catch (TimeoutException e) {
             testRun.setResult(Result.EXEC_TIMEOUT,
                 Collections.singletonList("Exceeded timeout! (" + timeoutSeconds + "s)"));
             return;
         } catch (Exception e) {
             testRun.setResult(Result.ERROR, e);
             return;
         }
         // we only look at the output of the last command
         if (output.isEmpty()) {
             testRun.setResult(Result.ERROR,
                     Collections.singletonList("No output returned!"));
             return;
         }

         Result result = TestProperties.RESULT_SUCCESS.equals(output.get(output.size() - 1))
                 ? Result.SUCCESS
                 : Result.EXEC_FAILED;
         testRun.setResult(result, output.subList(0, output.size() - 1));
     }

     /**
      * Run the actual test to gather output
      */
     protected abstract List<String> runTestCommand(TestRun testRun)
         throws TimeoutException;

     /**
      * Deletes files and releases any resources required for the execution of
      * the given test.
      */
     void cleanup(TestRun testRun) {
         environment.cleanup(testRun);
     }

     /**
      * Cleans up after all test runs have completed.
      */
     void shutdown() {
         environment.shutdown();
     }
 }
	/*
	* 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;

	import java.io.File;
	import java.io.FileOutputStream;
	import java.io.FilenameFilter;
	import java.io.IOException;
	import java.io.PrintStream;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Properties;
	import java.util.Set;
	import java.util.concurrent.TimeoutException;
	import java.util.logging.Logger;
	import java.util.regex.Pattern;

	/**
	* A Mode for running tests. Examples including running in a virtual
	* machine either on the host or a device or within a specific context
	* such as within an Activity.
	*/
	abstract class Mode {

	private static final Pattern JAVA_TEST_PATTERN = Pattern.compile("\\/(\\w)+\\.java$");

	private static final Logger logger = Logger.getLogger(Mode.class.getName());

	protected final Environment environment;
	protected final long timeoutSeconds;
	protected final File sdkJar;
	protected final PrintStream tee;

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

	// TODO: this should be an immutable collection.
	protected final Classpath testClasspath = Classpath.of(
	new File("dalvik/libcore/tools/runner/lib/jsr305.jar"),
	new File("dalvik/libcore/tools/runner/lib/guava.jar"),
	new File("dalvik/libcore/tools/runner/lib/caliper.jar"),
	// TODO: we should be able to work with a shipping SDK, not depend on out/...
	// dalvik/libcore/**/test/ for junit
	// TODO: jar up just the junit classes and drop the jar in our lib/ directory.
	new File("out/target/common/obj/JAVA_LIBRARIES/core-tests_intermediates/classes.jar").getAbsoluteFile());

	Mode(Environment environment, long timeoutSeconds, File sdkJar, PrintStream tee) {
	this.environment = environment;
	this.timeoutSeconds = timeoutSeconds;
	this.sdkJar = sdkJar;
	this.tee = tee;
	}

	/**
	* Initializes the temporary directories and test harness necessary to run
	* tests.
	*/
	protected void prepare(Set<File> testRunnerJava, Classpath testRunnerClasspath) {
	this.testRunnerJava.add(new File(DalvikRunner.HOME_JAVA, "dalvik/runner/TestRunner.java"));
	this.testRunnerJava.addAll(dalvikAnnotationSourceFiles());
	this.testRunnerJava.addAll(testRunnerJava);
	this.testRunnerClasspath.addAll(testRunnerClasspath);
	environment.prepare();
	compileTestRunner();
	}

	private List<File> dalvikAnnotationSourceFiles() {
	// Hopefully one day we'll strip the dalvik annotations out, but until then we need to make
	// them available to javac(1).
	File sourceDir = new File("dalvik/libcore/dalvik/src/main/java/dalvik/annotation");
	File[] javaSourceFiles = sourceDir.listFiles(new FilenameFilter() {
	public boolean accept(File dir, String filename) {
	return filename.endsWith(".java");
	}
	});
	return Arrays.asList(javaSourceFiles);
	}

	private void compileTestRunner() {
	logger.fine("build testrunner");

	Classpath classpath = new Classpath();
	classpath.addAll(testClasspath);
	classpath.addAll(testRunnerClasspath);

	File base = environment.testRunnerClassesDir();
	new Mkdir().mkdirs(base);
	new Javac()
	.bootClasspath(sdkJar)
	.classpath(classpath)
	.sourcepath(DalvikRunner.HOME_JAVA)
	.destination(base)
	.compile(testRunnerJava);
	postCompileTestRunner();
	}

	/**
	* Hook method called after TestRunner compilation.
	*/
	abstract protected void postCompileTestRunner();

	/**
	* Compiles classes for the given test and makes them ready for execution.
	* If the test could not be compiled successfully, it will be updated with
	* the appropriate test result.
	*/
	public void buildAndInstall(TestRun testRun) {
	logger.fine("build " + testRun.getQualifiedName());

	boolean testCompiled;
	try {
	testCompiled = compileTest(testRun);
	if (!testCompiled) {
	testRun.setResult(Result.UNSUPPORTED, Collections.<String>emptyList());
	return;
	}
	} catch (CommandFailedException e) {
	testRun.setResult(Result.COMPILE_FAILED, e.getOutputLines());
	return;
	} catch (IOException e) {
	testRun.setResult(Result.ERROR, e);
	return;
	}
	testRun.setTestCompiled(testCompiled);
	environment.prepareUserDir(testRun);
	}

	/**
	* Compiles the classes for the described test.
	*
	* @return the path to the compiled classes (directory or jar), or {@code
	* null} if the test could not be compiled.
	* @throws CommandFailedException if javac fails
	*/
	private boolean compileTest(TestRun testRun) throws IOException {
	if (!JAVA_TEST_PATTERN.matcher(testRun.getTestJava().toString()).find()) {
	return false;
	}

	String qualifiedName = testRun.getQualifiedName();
	File testClassesDir = environment.testClassesDir(testRun);
	new Mkdir().mkdirs(testClassesDir);
	FileOutputStream propertiesOut = new FileOutputStream(
	new File(testClassesDir, TestProperties.FILE));
	Properties properties = new Properties();
	fillInProperties(properties, testRun);
	properties.store(propertiesOut, "generated by " + Mode.class.getName());
	propertiesOut.close();

	Classpath classpath = new Classpath();
	classpath.addAll(testClasspath);
	classpath.addAll(testRun.getRunnerClasspath());

	Set<File> sourceFiles = new HashSet<File>();
	sourceFiles.add(testRun.getTestJava());
	sourceFiles.addAll(dalvikAnnotationSourceFiles());

	// compile the test case
	new Javac()
	.bootClasspath(sdkJar)
	.classpath(classpath)
	.sourcepath(testRun.getTestDirectory())
	.destination(testClassesDir)
	.compile(sourceFiles);
	postCompileTest(testRun);
	return true;
	}

	/**
	* Hook method called after test compilation.
	*
	* @param testRun The test being compiled
	*/
	abstract protected void postCompileTest(TestRun testRun);


	/**
	* Fill in properties for running in this 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());
	}

	/**
	* Runs the test, and updates its test result.
	*/
	void runTest(TestRun testRun) {
	if (!testRun.isRunnable()) {
	throw new IllegalArgumentException();
	}

	List<String> output;
	try {
	output = runTestCommand(testRun);
	} catch (TimeoutException e) {
	testRun.setResult(Result.EXEC_TIMEOUT,
	Collections.singletonList("Exceeded timeout! (" + timeoutSeconds + "s)"));
	return;
	} catch (Exception e) {
	testRun.setResult(Result.ERROR, e);
	return;
	}
	// we only look at the output of the last command
	if (output.isEmpty()) {
	testRun.setResult(Result.ERROR,
	Collections.singletonList("No output returned!"));
	return;
	}

	Result result = TestProperties.RESULT_SUCCESS.equals(output.get(output.size() - 1))
	? Result.SUCCESS
	: Result.EXEC_FAILED;
	testRun.setResult(result, output.subList(0, output.size() - 1));
	}

	/**
	* Run the actual test to gather output
	*/
	protected abstract List<String> runTestCommand(TestRun testRun)
	throws TimeoutException;

	/**
	* Deletes files and releases any resources required for the execution of
	* the given test.
	*/
	void cleanup(TestRun testRun) {
	environment.cleanup(testRun);
	}

	/**
	* Cleans up after all test runs have completed.
	*/
	void shutdown() {
	environment.shutdown();
	}
	}