Initial support to test.dart for running precompiler tests on android devices

tools/testing/dart/test_runner.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * Classes and methods for executing tests.
  *
  * This module includes:
  * - Managing parallel execution of tests, including timeout checks.
  * - Evaluating the output of each test as pass/fail/crash/timeout.
  */
 library test_runner;
 
 import "dart:async";
 import "dart:collection" show Queue;
 import "dart:convert" show LineSplitter, UTF8, JSON;
 // We need to use the 'io' prefix here, otherwise io.exitCode will shadow
 // CommandOutput.exitCode in subclasses of CommandOutput.
 import "dart:io" as io;
 import "dart:math" as math;
+import 'android.dart';
 import 'dependency_graph.dart' as dgraph;
 import "browser_controller.dart";
 import "path.dart";
 import "status_file_parser.dart";
 import "test_progress.dart";
 import "test_suite.dart";
 import "utils.dart";
 import 'record_and_replay.dart';
 
 const int CRASHING_BROWSER_EXITCODE = -10;
@@ skipping 306 matching lines @@
   bool _equal(AnalysisCommand other) =>
       super._equal(other) && flavor == other.flavor;
 }
 
 class VmCommand extends ProcessCommand {
   VmCommand._(String executable, List<String> arguments,
       Map<String, String> environmentOverrides)
       : super._("vm", executable, arguments, environmentOverrides);
 }
 
+class AdbPrecompilationCommand extends Command {
+  final String precompiledRunnerFilename;
+  final String precompiledTestDirectory;
+  final bool useBlobs;
+
+  AdbPrecompilationCommand._(this.precompiledRunnerFilename,
+                             this.precompiledTestDirectory,
+                             this.useBlobs)
+      : super._("adb_precompilation");
+
+  void _buildHashCode(HashCodeBuilder builder) {
+    super._buildHashCode(builder);
+    builder.add(precompiledRunnerFilename);
+    builder.add(precompiledTestDirectory);
+    builder.add(useBlobs);
+  }
+
+  bool _equal(AdbPrecompilationCommand other) =>
+      super._equal(other) &&
+      precompiledRunnerFilename == other.precompiledRunnerFilename &&
+      useBlobs == other.useBlobs &&
+      precompiledTestDirectory == other.precompiledTestDirectory;
+
+  String toString() => 'Steps to push precompiled runner and precompiled code '
+                       'to an attached device. Uses (and requires) adb.';
+}
+
 class JSCommandlineCommand extends ProcessCommand {
   JSCommandlineCommand._(
       String displayName, String executable, List<String> arguments,
       [Map<String, String> environmentOverrides = null])
       : super._(displayName, executable, arguments, environmentOverrides);
 }
 
 class PubCommand extends ProcessCommand {
   final String command;
 
@@ skipping 246 matching lines @@
         flavor, displayName, executable, arguments, environmentOverrides);
     return _getUniqueCommand(command);
   }
 
   VmCommand getVmCommand(String executable, List<String> arguments,
       Map<String, String> environmentOverrides) {
     var command = new VmCommand._(executable, arguments, environmentOverrides);
     return _getUniqueCommand(command);
   }
 
+  AdbPrecompilationCommand getAdbPrecompiledCommand(String precompiledRunner,
+                                                    String testDirectory,
+                                                    bool useBlobs) {
+    var command = new AdbPrecompilationCommand._(
+        precompiledRunner, testDirectory, useBlobs);
+    return _getUniqueCommand(command);
+  }
+
   Command getJSCommandlineCommand(String displayName, executable, arguments,
       [environment = null]) {
     var command = new JSCommandlineCommand._(
         displayName, executable, arguments, environment);
     return _getUniqueCommand(command);
   }
 
   Command getProcessCommand(String displayName, executable, arguments,
       [environment = null, workingDirectory = null]) {
     var command = new ProcessCommand._(
@@ skipping 995 matching lines @@
         command, exitCode, timedOut, stdout, stderr, time, compilationSkipped);
   } else if (command is BrowserTestCommand) {
     return new HTMLBrowserCommandOutputImpl(
         command, exitCode, timedOut, stdout, stderr, time, compilationSkipped);
   } else if (command is AnalysisCommand) {
     return new AnalysisCommandOutputImpl(
         command, exitCode, timedOut, stdout, stderr, time, compilationSkipped);
   } else if (command is VmCommand) {
     return new VmCommandOutputImpl(
         command, exitCode, timedOut, stdout, stderr, time, pid);
+  } else if (command is AdbPrecompilationCommand) {
+    return new VmCommandOutputImpl(
+        command, exitCode, timedOut, stdout, stderr, time, pid);
   } else if (command is CompilationCommand) {
     if (command.displayName == 'precompiler' ||
         command.displayName == 'dart2snapshot') {
       return new VmCommandOutputImpl(
           command, exitCode, timedOut, stdout, stderr, time, pid);
     }
     return new CompilationCommandOutputImpl(
         command, exitCode, timedOut, stdout, stderr, time, compilationSkipped);
   } else if (command is JSCommandlineCommand) {
     return new JsCommandlineOutputImpl(
@@ skipping 751 matching lines @@
   Future cleanup();
   // TODO(kustermann): The [timeout] parameter should be a property of Command
   Future<CommandOutput> runCommand(
       dgraph.Node node, Command command, int timeout);
 }
 
 class CommandExecutorImpl implements CommandExecutor {
   final Map globalConfiguration;
   final int maxProcesses;
   final int maxBrowserProcesses;
+  AdbDevicePool adbDevicePool;
 
   // For dart2js and analyzer batch processing,
   // we keep a list of batch processes.
   final _batchProcesses = new Map<String, List<BatchRunnerProcess>>();
   // We keep a BrowserTestRunner for every configuration.
   final _browserTestRunners = new Map<Map, BrowserTestRunner>();
 
   bool _finishing = false;
 
   CommandExecutorImpl(
-      this.globalConfiguration, this.maxProcesses, this.maxBrowserProcesses);
+      this.globalConfiguration, this.maxProcesses, this.maxBrowserProcesses,
+      {this.adbDevicePool});
 
   Future cleanup() {
     assert(!_finishing);
     _finishing = true;
 
     Future _terminateBatchRunners() {
       var futures = [];
       for (var runners in _batchProcesses.values) {
         futures.addAll(runners.map((runner) => runner.terminate()));
       }
@@ skipping 33 matching lines @@
     if (command is BrowserTestCommand) {
       return _startBrowserControllerTest(command, timeout);
     } else if (command is CompilationCommand && dart2jsBatchMode) {
       return _getBatchRunner("dart2js")
           .runCommand("dart2js", command, timeout, command.arguments);
     } else if (command is AnalysisCommand && batchMode) {
       return _getBatchRunner(command.flavor)
           .runCommand(command.flavor, command, timeout, command.arguments);
     } else if (command is ScriptCommand) {
       return command.run();
+    } else if (command is AdbPrecompilationCommand) {
+      assert(adbDevicePool != null);
+      return adbDevicePool.aquireDevice().then((AdbDevice device) {
+        return _runAdbPrecompilationCommand(device, command).whenComplete(() {
+          adbDevicePool.releaseDevice(device);
+        });
+      });
     } else {
       return new RunningProcess(command, timeout).run();
     }
   }
 
+  Future<CommandOutput> _runAdbPrecompilationCommand(
+      AdbDevice device, AdbPrecompilationCommand command) async {
+    var runner = command.precompiledRunnerFilename;
+    var testdir = command.precompiledTestDirectory;
+    var devicedir = '/data/local/tmp/precompilation-testing';
+
+    // We copy all the files which the vm precompiler puts into the test
+    // directory.
+    List<String> files = new io.Directory(testdir)
+        .listSync()
+        .where((fse) => fse is io.File)
+        .map((file) => file.path)
+        .map((path) => path.substring(path.lastIndexOf('/') + 1))
+        .toList();
+
+    // All closures are of type "Future<AdbCommandResult> run()"
+    List<Function> steps = [];
+
+    steps.add(() => device.runAdbShellCommand(
+          ['rm', '-Rf', devicedir]));
+    steps.add(() => device.runAdbShellCommand(
+          ['mkdir', devicedir]));
+    steps.add(() => device.runAdbCommand(
+          ['push', runner, '$devicedir/runner']));
+    steps.add(() => device.runAdbShellCommand(
+          ['chmod', '777', '$devicedir/runner']));
+
+    for (var file in files) {
+      steps.add(() => device.runAdbCommand(
+            ['push', '$testdir/$file', '$devicedir/$file']));
+    }
+
+    if (command.useBlobs) {
+      steps.add(() => device.runAdbShellCommand(
+            ['$devicedir/runner', '--run-precompiled-snapshot=$devicedir',
+             '--use_blobs', 'ignored.dart']));
+    } else {
+      steps.add(() => device.runAdbShellCommand(
+            ['$devicedir/runner', '--run-precompiled-snapshot=$devicedir',
+             'ignored.dart']));
+    }
+
+    var stopwatch = new Stopwatch()..start();
+    var writer = new StringBuffer();
+
+    await device.waitForBootCompleted();
+    await device.waitForDevice();
+
+    AdbCommandResult result;
+    for (var i = 0; i < steps.length; i++) {
+      var fun = steps[i];
+      var commandStopwatch = new Stopwatch()..start();
+      result = await fun();
+
+      writer.writeln("Executing ${result.command}");
+      if (result.stdout.length > 0) {
+        writer.writeln("Stdout:\n${result.stdout.trim()}");
+      }
+      if (result.stderr.length > 0) {
+        writer.writeln("Stderr:\n${result.stderr.trim()}");
+      }
+      writer.writeln("ExitCode: ${result.exitCode}");
+      writer.writeln("Time: ${commandStopwatch.elapsed}");
+      writer.writeln("");
+
+      // If one command fails, we stop processing the others and return
+      // immediately.
+      if (result.exitCode != 0) break;
+    }
+    return createCommandOutput(
+        command, result.exitCode, false, UTF8.encode('$writer'),
+        [], stopwatch.elapsed, false);
+  }
+
   BatchRunnerProcess _getBatchRunner(String identifier) {
     // Start batch processes if needed
     var runners = _batchProcesses[identifier];
     if (runners == null) {
       runners = new List<BatchRunnerProcess>(maxProcesses);
       for (int i = 0; i < maxProcesses; i++) {
         runners[i] = new BatchRunnerProcess();
       }
       _batchProcesses[identifier] = runners;
     }
@@ skipping 231 matching lines @@
   Map _globalConfiguration;
 
   Function _allDone;
   final dgraph.Graph _graph = new dgraph.Graph();
   List<EventListener> _eventListener;
 
   ProcessQueue(this._globalConfiguration, maxProcesses, maxBrowserProcesses,
       DateTime startTime, testSuites, this._eventListener, this._allDone,
       [bool verbose = false,
       String recordingOutputFile,
-      String recordedInputFile]) {
+      String recordedInputFile,
+      AdbDevicePool adbDevicePool]) {
     void setupForListing(TestCaseEnqueuer testCaseEnqueuer) {
       _graph.events
           .where((event) => event is dgraph.GraphSealedEvent)
           .listen((dgraph.GraphSealedEvent event) {
         var testCases = new List.from(testCaseEnqueuer.remainingTestCases);
         testCases.sort((a, b) => a.displayName.compareTo(b.displayName));
 
         print("\nGenerating all matching test cases ....\n");
 
         for (TestCase testCase in testCases) {
@@ skipping 80 matching lines @@
       var commandEnqueuer = new CommandEnqueuer(_graph);
 
       // CommandExecutor will execute commands
       var executor;
       if (recording) {
         executor = new RecordingCommandExecutor(new Path(recordingOutputFile));
       } else if (replaying) {
         executor = new ReplayingCommandExecutor(new Path(recordedInputFile));
       } else {
         executor = new CommandExecutorImpl(
-            _globalConfiguration, maxProcesses, maxBrowserProcesses);
+            _globalConfiguration, maxProcesses,
+            maxBrowserProcesses, adbDevicePool: adbDevicePool);
       }
 
       // Run "runnable commands" using [executor] subject to
       // maxProcesses/maxBrowserProcesses constraint
       commandQueue = new CommandQueue(_graph, testCaseEnqueuer, executor,
           maxProcesses, maxBrowserProcesses, verbose);
 
       // Finish test cases when all commands were run (or some failed)
       var testCaseCompleter =
           new TestCaseCompleter(_graph, testCaseEnqueuer, commandQueue);
@@ skipping 55 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
     _allDone();
   }
 }