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

tools/testing/dart/android.dart

 // Copyright (c) 2013, 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.
 
 library android;
 
 import "dart:async";
 import "dart:convert" show LineSplitter, UTF8;
 import "dart:core";
+import "dart:collection";
 import "dart:io";
 
 import "path.dart";
 import "utils.dart";
 
-Future _executeCommand(String executable, List<String> args,
-    [String stdin = ""]) {
-  return _executeCommandRaw(executable, args, stdin).then((results) => null);
-}
+class AdbCommandResult {
+  final String command;
+  final String stdout;
+  final String stderr;
+  final int exitCode;
 
-Future _executeCommandGetOutput(String executable, List<String> args,
-    [String stdin = ""]) {
-  return _executeCommandRaw(executable, args, stdin).then((output) => output);
+  AdbCommandResult(this.command, this.stdout, this.stderr, this.exitCode);
+
+  void throwIfFailed() {
+    if (exitCode != 0) {
+      var error = "Running: $command failed:"
+                  "stdout: \n $stdout"
+                  "stderr: \n $stderr"
+                  "exitCode: \n $exitCode";
+      throw new Exception(error);
+    }
+  }
 }
 
 /**
- * [_executeCommandRaw] will write [stdin] to the standard input of the created
+ * [_executeCommand] will write [stdin] to the standard input of the created
  * process and will return a tuple (stdout, stderr).
  *
  * If the exit code of the process was nonzero it will complete with an error.
  * If starting the process failed, it will complete with an error as well.
  */
-Future _executeCommandRaw(String executable, List<String> args,
-    [String stdin = ""]) {
+Future<AdbCommandResult> _executeCommand(
+    String executable, List<String> args, [String stdin = ""]) {
   Future<String> getOutput(Stream<List<int>> stream) {
     return stream
         .transform(UTF8.decoder)
         .toList()
         .then((data) => data.join(""));
   }
 
-  DebugLogger.info("Running: '\$ $executable ${args.join(' ')}'");
-  return Process.start(executable, args).then((Process process) {
+  return Process.start(executable, args).then((Process process) async {
     if (stdin != null && stdin != '') {
       process.stdin.write(stdin);
     }
     process.stdin.close();
 
-    var futures = [
-      getOutput(process.stdout),
-      getOutput(process.stderr),
-      process.exitCode
-    ];
-    return Future.wait(futures).then((results) {
-      bool success = results[2] == 0;
-      if (!success) {
-        var error = "Running: '\$ $executable ${args.join(' ')}' failed:"
-            "stdout: \n ${results[0]}"
-            "stderr: \n ${results[1]}"
-            "exitCode: \n ${results[2]}";
-        throw new Exception(error);
-      } else {
-        DebugLogger.info("Success: $executable finished");
-      }
-      return results[0];
-    });
+    var results = await Future.wait([
+        getOutput(process.stdout),
+        getOutput(process.stderr),
+        process.exitCode
+    ]);
+    String command = '$executable ${args.join(' ')}';

[Bill Hesse, 2016/04/27 13:54:40]

It may be legal to have ' inside ' because it is inside ${}, but I prefer to use
" here for one of the pairs of quotes.

[kustermann, 2016/05/02 10:40:23]

Done.

+    return new AdbCommandResult(command, results[0], results[1], results[2]);
   });
 }
 
 /**
  * Helper class to loop through all adb ports.
  *
  * The ports come in pairs:
  *  - even number: console connection
  *  - odd number: adb connection
  * Note that this code doesn't check if the ports are used.
@@ skipping 69 matching lines @@
 
   void log(String msg) {
     DebugLogger.info("AndroidEmulator(${_adbDevice.deviceId}): $msg");
   }
 }
 
 /**
  * Helper class to create avd device configurations.
  */
 class AndroidHelper {
-  static Future createAvd(String name, String target) {
+  static Future createAvd(String name, String target) async {
     var args = [
       '--silent',
       'create',
       'avd',
       '--name',
       '$name',
       '--target',
       '$target',
       '--force',
       '--abi',
       'armeabi-v7a'
     ];
     // We're adding newlines to stdin to simulate <enter>.
-    return _executeCommand("android", args, "\n\n\n\n");
+    var result = await _executeCommand("android", args, "\n\n\n\n");
+    result.throwIfFailed();
   }
 }
 
 /**
  * Used for communicating with an emulator or with a real device.
  */
 class AdbDevice {
   static const _adbServerStartupTime = const Duration(seconds: 3);
   String _deviceId;
 
   String get deviceId => _deviceId;
 
   AdbDevice(this._deviceId);
 
   /**
    * Blocks execution until the device is online
    */
   Future waitForDevice() {
     return _adbCommand(['wait-for-device']);
   }
 
   /**
    * Polls the 'sys.boot_completed' property. Returns as soon as the property is
    * 1.
    */
-  Future waitForBootCompleted() {
-    var timeout = const Duration(seconds: 2);
-    var completer = new Completer();
-
-    checkUntilBooted() {
-      _adbCommandGetOutput(['shell', 'getprop', 'sys.boot_completed'])
-          .then((String stdout) {
-        stdout = stdout.trim();
-        if (stdout == '1') {
-          completer.complete();
-        } else {
-          new Timer(timeout, checkUntilBooted);
-        }
-      }).catchError((error) {
-        new Timer(timeout, checkUntilBooted);
-      });
+  Future waitForBootCompleted() async {
+    while (true) {
+      try {
+        AdbCommandResult result =
+            await _adbCommand(['shell', 'getprop', 'sys.boot_completed']);
+        if (result.stdout.trim() == '1') return;
+      } catch (_) { }
+      await new Future.delayed(const Duration(seconds: 2));
     }
-    checkUntilBooted();
-    return completer.future;
   }
 
   /**
    * Put adb in root mode.
    */
   Future adbRoot() {
     var adbRootCompleter = new Completer();
     _adbCommand(['root']).then((_) {
       // TODO: Figure out a way to wait until the adb daemon was restarted in
       // 'root mode' on the device.
@@ skipping 68 matching lines @@
   }
 
   /**
    * Kill all background processes.
    */
   Future killAll() {
     var arguments = ['shell', 'am', 'kill-all'];
     return _adbCommand(arguments);
   }
 
-  Future _adbCommand(List<String> adbArgs) {
+  Future<AdbCommandResult> runAdbCommand(List<String> adbArgs) {
+    return _executeCommand("adb", _deviceSpecificArgs(adbArgs));
+  }
+
+  Future<AdbCommandResult> runAdbShellCommand(List<String> shellArgs) async {
+    const MARKER = 'AdbShellExitCode: ';
+
+    // The exitcode of 'adb shell ...' can be 0 even though the command failed
+    // with a non-zero exit code. We therefore explicitly print it to stdout and
+    // search for it.
+
+    var args = ['shell',
+                "${shellArgs.join(' ')} ; echo $MARKER \$?"];
+    AdbCommandResult result = await _executeCommand(
+        "adb", _deviceSpecificArgs(args));
+    int exitCode = result.exitCode;
+    var lines = result
+        .stdout.split('\n')
+        .where((line) => line.trim().length > 0)
+        .toList();
+    if (lines.length > 0) {
+      int index = lines.last.indexOf(MARKER);
+      assert(index >= 0);
+      exitCode = int.parse(lines.last.substring(index + MARKER.length).trim());
+    }
+    return new AdbCommandResult(
+        result.command, result.stdout, result.stderr, exitCode);
+  }
+
+  Future<AdbCommandResult> _adbCommand(List<String> adbArgs) async {
+    var result = await _executeCommand("adb", _deviceSpecificArgs(adbArgs));
+    result.throwIfFailed();
+    return result;
+  }
+
+  List<String> _deviceSpecificArgs(List<String> adbArgs) {
     if (_deviceId != null) {
       var extendedAdbArgs = ['-s', _deviceId];
       extendedAdbArgs.addAll(adbArgs);
       adbArgs = extendedAdbArgs;
     }
-    return _executeCommand("adb", adbArgs);
-  }
-
-  Future<String> _adbCommandGetOutput(List<String> adbArgs) {
-    if (_deviceId != null) {
-      var extendedAdbArgs = ['-s', _deviceId];
-      extendedAdbArgs.addAll(adbArgs);
-      adbArgs = extendedAdbArgs;
-    }
-    return _executeCommandGetOutput("adb", adbArgs);
+    return adbArgs;
   }
 }
 
 /**
  * Helper to list all adb devices available.
  */
 class AdbHelper {
   static RegExp _deviceLineRegexp =
       new RegExp(r'^([a-zA-Z0-9_-]+)[ \t]+device$', multiLine: true);
 
@@ skipping 15 matching lines @@
  * Represents an android intent.
  */
 class Intent {
   String action;
   String package;
   String activity;
   String dataUri;
 
   Intent(this.action, this.package, this.activity, [this.dataUri]);
 }
+
+/**
+ * Discovers all available devices and supports acquire/release.
+ */
+class AdbDevicePool {
+  final Queue<AdbDevice> _idleDevices = new Queue<AdbDevice>();
+  final Queue<Completer> _waiter = new Queue<Completer>();
+
+  AdbDevicePool(List<AdbDevice> idleDevices) {
+    _idleDevices.addAll(idleDevices);
+  }
+
+  static Future<AdbDevicePool> create() async {
+    var names = await AdbHelper.listDevices();
+    var devices = names.map((id) => new AdbDevice(id)).toList();
+    if (devices.length == 0) {
+      throw new Exception(
+          'No android devices found. '
+          'Please make sure "adb devices" shows your device!');
+    }
+    return new AdbDevicePool(devices);
+  }
+
+  Future<AdbDevice> acquireDevice() async {
+    if (_idleDevices.length > 0) {
+      return _idleDevices.removeFirst();
+    } else {
+      var completer = new Completer();
+      _waiter.add(completer);
+      return completer.future;
+    }
+  }
+
+  void releaseDevice(AdbDevice device) {
+    if (_waiter.length > 0) {
+      Completer completer = _waiter.removeFirst();
+      completer.complete(device);
+    } else {
+      _idleDevices.add(device);
+    }
+  }
+}