diff options
Diffstat (limited to 'tools/dalvik_jtreg/java/dalvik')
| -rw-r--r-- | tools/dalvik_jtreg/java/dalvik/jtreg/Adb.java | 5 | ||||
| -rw-r--r-- | tools/dalvik_jtreg/java/dalvik/jtreg/Command.java | 16 | ||||
| -rw-r--r-- | tools/dalvik_jtreg/java/dalvik/jtreg/Dx.java | 2 | ||||
| -rw-r--r-- | tools/dalvik_jtreg/java/dalvik/jtreg/ExpectedResult.java | 87 | ||||
| -rw-r--r-- | tools/dalvik_jtreg/java/dalvik/jtreg/Javac.java | 2 | ||||
| -rw-r--r-- | tools/dalvik_jtreg/java/dalvik/jtreg/JtregRunner.java | 256 | ||||
| -rw-r--r-- | tools/dalvik_jtreg/java/dalvik/jtreg/Result.java | 33 | ||||
| -rw-r--r-- | tools/dalvik_jtreg/java/dalvik/jtreg/Run.java | 62 | ||||
| -rw-r--r-- | tools/dalvik_jtreg/java/dalvik/jtreg/Strings.java | 54 | ||||
| -rw-r--r-- | tools/dalvik_jtreg/java/dalvik/jtreg/TestRun.java | 125 | ||||
| -rw-r--r-- | tools/dalvik_jtreg/java/dalvik/jtreg/TestToDex.java | 7 |
11 files changed, 510 insertions, 139 deletions
diff --git a/tools/dalvik_jtreg/java/dalvik/jtreg/Adb.java b/tools/dalvik_jtreg/java/dalvik/jtreg/Adb.java index 71ea690..b7813d8 100644 --- a/tools/dalvik_jtreg/java/dalvik/jtreg/Adb.java +++ b/tools/dalvik_jtreg/java/dalvik/jtreg/Adb.java @@ -32,4 +32,9 @@ final class Adb { new Command("adb", "push", local.toString(), remote.toString()) .execute(); } + + public void forwardTcp(int localPort, int devicePort) { + new Command("adb", "forward", "tcp:" + localPort, "tcp:" + devicePort) + .execute(); + } }
\ No newline at end of file diff --git a/tools/dalvik_jtreg/java/dalvik/jtreg/Command.java b/tools/dalvik_jtreg/java/dalvik/jtreg/Command.java index 5558ced..fb644bf 100644 --- a/tools/dalvik_jtreg/java/dalvik/jtreg/Command.java +++ b/tools/dalvik_jtreg/java/dalvik/jtreg/Command.java @@ -47,21 +47,7 @@ final class Command { } static String path(Object[] objects) { - StringBuilder result = new StringBuilder(); - result.append(objects[0]); - for (int i = 1; i < objects.length; i++) { - result.append(":").append(objects[i]); - } - return result.toString(); - } - - static String[] objectsToStrings(Object[] objects) { - String[] result = new String[objects.length]; - int i = 0; - for (Object o : objects) { - result[i++] = o.toString(); - } - return result; + return Strings.join(objects, ":"); } static class Builder { diff --git a/tools/dalvik_jtreg/java/dalvik/jtreg/Dx.java b/tools/dalvik_jtreg/java/dalvik/jtreg/Dx.java index 0e50ef6..21bcbbe 100644 --- a/tools/dalvik_jtreg/java/dalvik/jtreg/Dx.java +++ b/tools/dalvik_jtreg/java/dalvik/jtreg/Dx.java @@ -28,7 +28,7 @@ final class Dx { .args("dx") .args("--dex") .args("--output=" + output) - .args(Command.objectsToStrings(inputs)) + .args(Strings.objectsToStrings(inputs)) .execute(); } } diff --git a/tools/dalvik_jtreg/java/dalvik/jtreg/ExpectedResult.java b/tools/dalvik_jtreg/java/dalvik/jtreg/ExpectedResult.java new file mode 100644 index 0000000..79ee36c --- /dev/null +++ b/tools/dalvik_jtreg/java/dalvik/jtreg/ExpectedResult.java @@ -0,0 +1,87 @@ +/* + * 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.jtreg; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.util.Properties; +import java.util.Set; + +/** + * The expected outcome of a test execution. This is typically encoded in a + * properties file named by the test name and the {@code .expected} suffix; for + * example, {@code java.util.Arrays.CopyMethods.expected}. + */ +class ExpectedResult { + + /** + * Property identifier for the test's expected result, such as {@code + * EXEC_FAILED}. This property is required. + */ + static final String RESULT = "result"; + + /** + * Property identifier for a regular expression that is the expected output + * will match. This property is optional. + */ + static final String PATTERN = "pattern"; + + /** + * The expectation of a general successful test run. + */ + static final ExpectedResult SUCCESS = new ExpectedResult( + Result.SUCCESS, ".*"); + + private final Result result; + private final String pattern; + + private ExpectedResult(File expectationFile) throws IOException { + Properties properties = new Properties(); + FileInputStream in = new FileInputStream(expectationFile); + properties.load(in); + in.close(); + + result = Result.valueOf(properties.getProperty(RESULT)); + pattern = properties.getProperty(PATTERN); + } + + private ExpectedResult(Result result, String pattern) { + this.result = result; + this.pattern = pattern; + } + + public Result getResult() { + return result; + } + + public String getPattern() { + return pattern; + } + + public static ExpectedResult forRun(Set<File> searchDirectories, + String qualifiedName) throws IOException { + for (File expectationDir : searchDirectories) { + File expectationFile = new File(expectationDir, qualifiedName + ".expected"); + if (expectationFile.exists()) { + return new ExpectedResult(expectationFile); + } + } + + return SUCCESS; + } +} diff --git a/tools/dalvik_jtreg/java/dalvik/jtreg/Javac.java b/tools/dalvik_jtreg/java/dalvik/jtreg/Javac.java index 4a66abb..c168d5d 100644 --- a/tools/dalvik_jtreg/java/dalvik/jtreg/Javac.java +++ b/tools/dalvik_jtreg/java/dalvik/jtreg/Javac.java @@ -51,7 +51,7 @@ final class Javac { } public List<String> compile(File... files) { - return builder.args(Command.objectsToStrings(files)) + return builder.args(Strings.objectsToStrings(files)) .execute(); } } diff --git a/tools/dalvik_jtreg/java/dalvik/jtreg/JtregRunner.java b/tools/dalvik_jtreg/java/dalvik/jtreg/JtregRunner.java index 7fc23f0..0d00b7a 100644 --- a/tools/dalvik_jtreg/java/dalvik/jtreg/JtregRunner.java +++ b/tools/dalvik_jtreg/java/dalvik/jtreg/JtregRunner.java @@ -1,4 +1,18 @@ -// Copyright 2009 Google Inc. All Rights Reserved. +/* + * 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.jtreg; @@ -6,21 +20,29 @@ import com.sun.javatest.TestDescription; import java.io.File; import java.io.IOException; -import java.util.ArrayList; import java.util.Collections; +import java.util.LinkedHashSet; import java.util.List; +import java.util.Set; import java.util.UUID; -import java.util.concurrent.Callable; -import java.util.concurrent.ExecutionException; +import java.util.concurrent.ArrayBlockingQueue; +import java.util.concurrent.BlockingQueue; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; -import java.util.concurrent.Future; +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; +import java.util.regex.Pattern; /** * Runs a directory's worth of jtreg tests on a device. */ public final class JtregRunner { + private static final Logger logger = Logger.getLogger(JtregRunner.class.getName()); + private final File localTemp = new File("/tmp/" + UUID.randomUUID()); private final File deviceTemp = new File("/data/jtreg" + UUID.randomUUID()); @@ -28,6 +50,9 @@ public final class JtregRunner { private final File directoryToScan; private final TestToDex testToDex; + private Integer debugPort; + private Set<File> expectationDirs = new LinkedHashSet<File>(); + private File deviceTestRunner; public JtregRunner(File sdkJar, File directoryToScan) { @@ -35,35 +60,58 @@ public final class JtregRunner { this.testToDex = new TestToDex(sdkJar, localTemp); } + /** + * Builds and executes all tests in the test directory. + */ public void buildAndRunAllTests() throws Exception { localTemp.mkdirs(); - prepareDevice(); List<TestDescription> tests = testToDex.findTests(directoryToScan); + final BlockingQueue<TestRun> readyToRun = new ArrayBlockingQueue<TestRun>(4); - // TODO: investigate why tests don't work when run in parallel on device - ExecutorService executor = Executors.newFixedThreadPool(1); - List<Future<Run>> futures = new ArrayList<Future<Run>>(); + // build and install tests in a background thread. Using lots of + // threads helps for packages that contain many unsupported tests + ExecutorService builders = Executors.newFixedThreadPool(8); for (final TestDescription testDescription : tests) { - futures.add(executor.submit(new Callable<Run>() { - public Run call() throws Exception { - return buildAndRunTest(testDescription); + builders.submit(new Runnable() { + public void run() { + try { + String qualifiedName = TestDescriptions.qualifiedName(testDescription); + ExpectedResult expectedResult = ExpectedResult.forRun(expectationDirs, qualifiedName); + TestRun testRun = new TestRun(qualifiedName, testDescription, expectedResult); + buildAndInstall(testRun); + readyToRun.put(testRun); + } catch (Exception e) { + throw new RuntimeException(e); + } } - })); + }); } + builders.shutdown(); + + prepareDevice(); + + int unsupportedTests = 0; - for (Future<Run> future : futures) { - try { - System.out.println(future.get()); - System.out.println(); - } catch (ExecutionException e) { - throw new RuntimeException(e); - } catch (InterruptedException e) { - throw new RuntimeException(e); + while (!builders.isTerminated() || !readyToRun.isEmpty()) { + TestRun testRun = readyToRun.take(); + + if (testRun.getResult() == Result.UNSUPPORTED) { + logger.fine("skipping " + testRun.getQualifiedName()); + unsupportedTests++; + continue; } + + if (testRun.isRunnable()) { + runTest(testRun); + } + + printResult(testRun); } - executor.shutdown(); + if (unsupportedTests > 0) { + logger.info("Skipped " + unsupportedTests + " unsupported tests."); + } } /** @@ -71,21 +119,26 @@ public final class JtregRunner { * tests on a device. */ private void prepareDevice() { - System.out.print("Preparing device..."); adb.mkdir(deviceTemp); File testRunnerJar = testToDex.writeTestRunnerJar(); adb.push(testRunnerJar, deviceTemp); deviceTestRunner = new File(deviceTemp, testRunnerJar.getName()); - System.out.println("done."); + if (debugPort != null) { + adb.forwardTcp(debugPort, debugPort); + } + logger.info("Prepared device."); } /** - * Creates a dex file for the given test, pushes it out to the device, and - * runs it, returning the test's result. + * Creates a dex file for the given test and push it out to the device. + * + * @return true if building and installing completed successfully. */ - private Run buildAndRunTest(TestDescription testDescription) - throws IOException { - String qualifiedName = TestDescriptions.qualifiedName(testDescription); + private void buildAndInstall(TestRun testRun) { + TestDescription testDescription = testRun.getTestDescription(); + String qualifiedName = testRun.getQualifiedName(); + logger.fine("building " + testRun.getQualifiedName()); + File base = new File(deviceTemp, qualifiedName); adb.mkdir(base); @@ -93,49 +146,89 @@ public final class JtregRunner { try { dex = testToDex.dexify(testDescription); if (dex == null) { - return new Run(testDescription, Run.Result.SKIPPED, Collections.<String>emptyList()); + testRun.initResult(Result.UNSUPPORTED, Collections.<String>emptyList()); + return; } } catch (CommandFailedException e) { - return new Run(testDescription, Run.Result.COMPILE_FAILED, e.getOutputLines()); + testRun.initResult(Result.COMPILE_FAILED, e.getOutputLines()); + return; } catch (IOException e) { - return new Run(testDescription, Run.Result.ERROR, e); + testRun.initResult(Result.ERROR, e); + return; } + logger.fine("installing " + testRun.getQualifiedName()); adb.push(testDescription.getDir(), base); adb.push(dex, deviceTemp); - File deviceDex = new File(deviceTemp, dex.getName()); - - return runTest(testDescription, base, deviceDex); + testRun.initInstalledFiles(base, new File(deviceTemp, dex.getName())); } /** * Runs the specified test on the device. - * - * @param base the test's base directory, from which local files can be - * read by the test. - * @param dex the jar file containing the test code. - * @return the result of executing the test. */ - private Run runTest(TestDescription testDescription, File base, File dex) { - List<String> output = new Dalvikvm() - .classpath(dex, deviceTestRunner) - .args("-Duser.dir=" + base) - .exec("dalvik.jtreg.TestRunner"); + private void runTest(TestRun testRun) { + if (!testRun.isRunnable()) { + throw new IllegalArgumentException(); + } + + logger.fine("running " + testRun.getQualifiedName()); + Dalvikvm vm = new Dalvikvm() + .classpath(testRun.getDeviceDex(), deviceTestRunner) + .args("-Duser.dir=" + testRun.getBase()); + if (debugPort != null) { + vm.args("-Xrunjdwp:transport=dt_socket,address=" + + debugPort + ",server=y,suspend=y"); + } + List<String> output = vm.exec("dalvik.jtreg.TestRunner"); if (output.isEmpty()) { - return new Run(testDescription, Run.Result.ERROR, + testRun.initResult(Result.ERROR, Collections.singletonList("No output returned!")); } - Run.Result result = "SUCCESS".equals(output.get(output.size() - 1)) - ? Run.Result.SUCCESS - : Run.Result.EXEC_FAILED; - return new Run(testDescription, result, output.subList(0, output.size() - 1)); + Result result = "SUCCESS".equals(output.get(output.size() - 1)) + ? Result.SUCCESS + : Result.EXEC_FAILED; + testRun.initResult(result, output.subList(0, output.size() - 1)); + } + + private void printResult(TestRun testRun) { + ExpectedResult expected = testRun.getExpectedResult(); + boolean patternSuccess; + + if (expected.getPattern() != null) { + Pattern pattern = Pattern.compile(expected.getPattern(), + Pattern.MULTILINE | Pattern.DOTALL); + patternSuccess = pattern.matcher(Strings.join(testRun.getOutputLines(), "\n")).matches(); + } else { + patternSuccess = true; + } + + if (expected.getResult() == testRun.getResult() && patternSuccess) { + logger.info("OK " + testRun.getQualifiedName() + " (" + testRun.getResult() + ")"); + return; + } + + logger.info("FAIL " + testRun.getQualifiedName() + " (" + testRun.getResult() + ")"); + logger.info(" \"" + testRun.getTestDescription().getTitle() + "\""); + + if (expected.getResult() != Result.SUCCESS + && expected.getResult() != testRun.getResult()) { + logger.info(" Expected result: " + expected.getResult()); + } + + if (!patternSuccess) { + logger.info(" Expected output to match \"" + expected.getPattern() + "\""); + } + + for (String output : testRun.getOutputLines()) { + logger.info(" " + output); + } } public static void main(String[] args) throws Exception { - if (args.length != 2) { - System.out.println("Usage: JTRegRunner <android_jar> <directoryWithTests>"); + if (args.length < 2) { + System.out.println("Usage: JTRegRunner [options]... <android_jar> <directoryWithTests>"); System.out.println(); System.out.println(" android_jar: the API jar file to compile against. Usually"); System.out.println(" this is <SDK>/platforms/android-<X.X>/android.jar where"); @@ -146,19 +239,66 @@ public final class JtregRunner { System.out.println(" typically this is 'platform_v6/jdk/test' if 'platform_v6'"); System.out.println(" contains the sources of a platform implementation."); System.out.println(); + System.out.println("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(" --expectations <directory>: use the specified directory when"); + System.out.println(" looking for test expectations. The directory should include"); + System.out.println(" <test>.expected files describing expected results."); + System.out.println(); + System.out.println(" --verbose: turn on verbose output"); + System.out.println(); return; } - File sdkJar = new File(args[0]); + prepareLogging(); + + File sdkJar = new File(args[args.length - 2]); if (!sdkJar.exists()) { - throw new RuntimeException("No such file: " + sdkJar); + throw new RuntimeException("Could not find SDK jar: " + sdkJar); } - File directoryToScan = new File(args[1]); - if (!directoryToScan.exists()) { - throw new RuntimeException("No such directory: " + directoryToScan); + File directoryToScan = new File(args[args.length - 1]); + if (!directoryToScan.isDirectory()) { + throw new RuntimeException("Invalid test directory: " + directoryToScan); } - new JtregRunner(sdkJar, directoryToScan).buildAndRunAllTests(); + JtregRunner jtregRunner = new JtregRunner(sdkJar, directoryToScan); + + for (int i = 0; i < args.length - 2; i++) { + if ("--debug".equals(args[i])) { + jtregRunner.debugPort = Integer.valueOf(args[++i]); + + } else if ("--verbose".equals(args[i])) { + Logger.getLogger("dalvik.jtreg").setLevel(Level.FINE); + + } else if ("--expectations".equals(args[i])) { + File expectationDir = new File(args[++i]); + if (!expectationDir.isDirectory()) { + throw new RuntimeException("Invalid expectation directory: " + directoryToScan); + } + jtregRunner.expectationDirs.add(expectationDir); + + } else { + throw new RuntimeException("Unrecognized option: " + args[i]); + } + } + + jtregRunner.buildAndRunAllTests(); + } + + private static 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.addHandler(handler); + logger.setUseParentHandlers(false); } } diff --git a/tools/dalvik_jtreg/java/dalvik/jtreg/Result.java b/tools/dalvik_jtreg/java/dalvik/jtreg/Result.java new file mode 100644 index 0000000..1189e76 --- /dev/null +++ b/tools/dalvik_jtreg/java/dalvik/jtreg/Result.java @@ -0,0 +1,33 @@ +/* + * 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.jtreg; + +/** + * A test run result. + */ +public enum Result { + + /** + * A test that cannot be run by this harness, such as a shell script. + */ + UNSUPPORTED, + + COMPILE_FAILED, + EXEC_FAILED, + ERROR, + SUCCESS +} diff --git a/tools/dalvik_jtreg/java/dalvik/jtreg/Run.java b/tools/dalvik_jtreg/java/dalvik/jtreg/Run.java deleted file mode 100644 index 2755d93..0000000 --- a/tools/dalvik_jtreg/java/dalvik/jtreg/Run.java +++ /dev/null @@ -1,62 +0,0 @@ -// Copyright 2009 Google Inc. All Rights Reserved. - -package dalvik.jtreg; - -import com.sun.javatest.TestDescription; - -import java.io.PrintWriter; -import java.io.StringWriter; -import java.util.Arrays; -import java.util.List; - -/** - * The outcome of a test run. - */ -public final class Run { - - private final String qualifiedName; - private final String title; - private final Result result; - private final List<String> outputLines; - - public Run(TestDescription testDescription, Result result, List<String> outputLines) { - this.qualifiedName = TestDescriptions.qualifiedName(testDescription); - this.title = testDescription.getTitle(); - this.result = result; - this.outputLines = outputLines; - } - - public Run(TestDescription testDescription, Result result, Exception e) { - this.qualifiedName = TestDescriptions.qualifiedName(testDescription); - this.title = testDescription.getTitle(); - this.result = result; - this.outputLines = throwableToLines(e); - } - - private static List<String> throwableToLines(Throwable t) { - StringWriter writer = new StringWriter(); - PrintWriter out = new PrintWriter(writer); - t.printStackTrace(out); - return Arrays.asList(writer.toString().split("\\n")); - } - - @Override public String toString() { - StringBuilder builder = new StringBuilder() - .append(qualifiedName).append(" ").append(result) - .append("\n \"").append(title).append("\""); - - for (String output : outputLines) { - builder.append("\n ").append(output); - } - - return builder.toString(); - } - - public enum Result { - SKIPPED, - COMPILE_FAILED, - EXEC_FAILED, - ERROR, - SUCCESS - } -} diff --git a/tools/dalvik_jtreg/java/dalvik/jtreg/Strings.java b/tools/dalvik_jtreg/java/dalvik/jtreg/Strings.java new file mode 100644 index 0000000..c06c98a --- /dev/null +++ b/tools/dalvik_jtreg/java/dalvik/jtreg/Strings.java @@ -0,0 +1,54 @@ +/* + * 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.jtreg; + +import java.util.Arrays; +import java.util.Iterator; + +/** + * Utility methods for strings. + */ +public class Strings { + + static String join(Object[] objects, String delimiter) { + return join(Arrays.asList(objects), delimiter); + } + + static String join(Iterable<?> objects, String delimiter) { + Iterator<?> i = objects.iterator(); + if (!i.hasNext()) { + return ""; + } + + StringBuilder result = new StringBuilder(); + result.append(i.next()); + while(i.hasNext()) { + result.append(delimiter).append(i.next()); + } + return result.toString(); + } + + static String[] objectsToStrings(Object[] objects) { + String[] result = new String[objects.length]; + int i = 0; + for (Object o : objects) { + result[i++] = o.toString(); + } + return result; + } +} diff --git a/tools/dalvik_jtreg/java/dalvik/jtreg/TestRun.java b/tools/dalvik_jtreg/java/dalvik/jtreg/TestRun.java new file mode 100644 index 0000000..aa85528 --- /dev/null +++ b/tools/dalvik_jtreg/java/dalvik/jtreg/TestRun.java @@ -0,0 +1,125 @@ +/* + * 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.jtreg; + +import com.sun.javatest.TestDescription; + +import java.io.File; +import java.io.PrintWriter; +import java.io.StringWriter; +import java.util.Arrays; +import java.util.List; + +/** + * A test run and its outcome. + */ +public final class TestRun { + + private final TestDescription testDescription; + private final String qualifiedName; + private final ExpectedResult expectedResult; + + private File base; + private File deviceDex; + + private Result result; + private List<String> outputLines; + + + public TestRun(String qualifiedName, TestDescription testDescription, + ExpectedResult expectedResult) { + this.qualifiedName = qualifiedName; + this.testDescription = testDescription; + this.expectedResult = expectedResult; + } + + public TestDescription getTestDescription() { + return testDescription; + } + + public String getQualifiedName() { + return qualifiedName; + } + + /** + * Initializes the on-device base directory from which the test program + * shall be executed, and the dex file containing that program. + */ + public void initInstalledFiles(File base, File deviceDex) { + if (this.base != null) { + throw new IllegalStateException(); + } + + this.base = base; + this.deviceDex = deviceDex; + } + + /** + * Returns true if this test is ready for execution on a device. + */ + public boolean isRunnable() { + return base != null && deviceDex != null; + } + + /** + * Returns the test's base directory, from which local files can be read by + * the test. + */ + public File getBase() { + return base; + } + + /** + * Returns the jar file containing the test code. + */ + public File getDeviceDex() { + return deviceDex; + } + + public void initResult(Result result, Exception e) { + initResult(result, throwableToLines(e)); + } + + public void initResult(Result result, List<String> outputLines) { + if (this.result != null) { + throw new IllegalStateException(); + } + + this.result = result; + this.outputLines = outputLines; + } + + private static List<String> throwableToLines(Throwable t) { + StringWriter writer = new StringWriter(); + PrintWriter out = new PrintWriter(writer); + t.printStackTrace(out); + return Arrays.asList(writer.toString().split("\\n")); + } + + public Result getResult() { + return result; + } + + public List<String> getOutputLines() { + return outputLines; + } + + public ExpectedResult getExpectedResult() { + return expectedResult; + } + +} diff --git a/tools/dalvik_jtreg/java/dalvik/jtreg/TestToDex.java b/tools/dalvik_jtreg/java/dalvik/jtreg/TestToDex.java index 245ec75..6badf34 100644 --- a/tools/dalvik_jtreg/java/dalvik/jtreg/TestToDex.java +++ b/tools/dalvik_jtreg/java/dalvik/jtreg/TestToDex.java @@ -30,6 +30,7 @@ import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Properties; +import java.util.logging.Logger; import java.util.regex.Pattern; /** @@ -47,6 +48,8 @@ final class TestToDex { private static final File TEST_RUNNER_JAVA = new File(DALVIK_JTREG_HOME + "/java/dalvik/jtreg/TestRunner.java"); + private static final Logger logger = Logger.getLogger(TestToDex.class.getName()); + private final Pattern JAVA_TEST_PATTERN = Pattern.compile("\\/(\\w)+\\.java$"); private final File sdkJar; @@ -115,7 +118,7 @@ final class TestToDex { * behind the scenes. */ List<TestDescription> findTests(File directoryToScan) throws Exception { - System.out.print("Scanning " + directoryToScan + "..."); + logger.info("Scanning " + directoryToScan + " for tests."); File workDirectory = new File(temp, "JTwork"); workDirectory.mkdirs(); @@ -134,7 +137,7 @@ final class TestToDex { TestResult testResult = (TestResult) i.next(); result.add(testResult.getDescription()); } - System.out.println("done. Found " + result.size() + " tests."); + logger.info("Found " + result.size() + " tests."); return result; } } |