Autoformat tools/testing/dart

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.
@@ skipping 21 matching lines @@
 
 const MESSAGE_CANNOT_OPEN_DISPLAY = 'Gtk-WARNING **: cannot open display';
 const MESSAGE_FAILED_TO_RUN_COMMAND = 'Failed to run command. return code=1';
 
 typedef void TestCaseEvent(TestCase testCase);
 typedef void ExitCodeEvent(int exitCode);
 typedef void EnqueueMoreWork(ProcessQueue queue);
 
 // Some IO tests use these variables and get confused if the host environment
 // variables are inherited so they are excluded.
-const List<String> EXCLUDED_ENVIRONMENT_VARIABLES =
-    const ['http_proxy', 'https_proxy', 'no_proxy',
-           'HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY'];
-
+const List<String> EXCLUDED_ENVIRONMENT_VARIABLES = const [
+  'http_proxy',
+  'https_proxy',
+  'no_proxy',
+  'HTTP_PROXY',
+  'HTTPS_PROXY',
+  'NO_PROXY'
+];
 
 /** A command executed as a step in a test case. */
 class Command {
   /** A descriptive name for this command. */
   String displayName;
 
   /** Number of times this command *can* be retried */
   int get maxNumRetries => 2;
 
   /** Reproduction command */
   String get reproductionCommand => null;
 
   // We compute the Command.hashCode lazily and cache it here, since it might
   // be expensive to compute (and hashCode is called often).
   int _cachedHashCode;
 
   Command._(this.displayName);
 
   int get hashCode {
     if (_cachedHashCode == null) {
       var builder = new HashCodeBuilder();
       _buildHashCode(builder);
       _cachedHashCode = builder.value;
     }
     return _cachedHashCode;
   }
 
-  operator ==(other) => identical(this, other) ||
+  operator ==(other) =>
+      identical(this, other) ||
       (runtimeType == other.runtimeType && _equal(other));
 
   void _buildHashCode(HashCodeBuilder builder) {
     builder.addJson(displayName);
   }
 
   bool _equal(Command other) =>
-      hashCode == other.hashCode &&
-      displayName == other.displayName;
+      hashCode == other.hashCode && displayName == other.displayName;
 
   String toString() => reproductionCommand;
 
   Future<bool> get outputIsUpToDate => new Future.value(false);
 }
 
 class ProcessCommand extends Command {
   /** Path to the executable of this command. */
   String executable;
 
   /** Command line arguments to the executable. */
   List<String> arguments;
 
   /** Environment for the command */
   Map<String, String> environmentOverrides;
 
   /** Working directory for the command */
   final String workingDirectory;
 
-  ProcessCommand._(String displayName, this.executable,
-                   this.arguments,
-                   [this.environmentOverrides = null,
-                    this.workingDirectory = null])
+  ProcessCommand._(String displayName, this.executable, this.arguments,
+      [this.environmentOverrides = null, this.workingDirectory = null])
       : super._(displayName) {
     if (io.Platform.operatingSystem == 'windows') {
       // Windows can't handle the first command if it is a .bat file or the like
       // with the slashes going the other direction.
       // NOTE: Issue 1306
       executable = executable.replaceAll('/', '\\');
     }
   }
 
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
     builder.addJson(executable);
     builder.addJson(workingDirectory);
     builder.addJson(arguments);
     builder.addJson(environmentOverrides);
   }
 
   bool _equal(ProcessCommand other) =>
       super._equal(other) &&
       executable == other.executable &&
       deepJsonCompare(arguments, other.arguments) &&
       workingDirectory == other.workingDirectory &&
       deepJsonCompare(environmentOverrides, other.environmentOverrides);
 
   String get reproductionCommand {
     var env = new StringBuffer();
     environmentOverrides.forEach((key, value) =>
-        (io.Platform.operatingSystem == 'windows') ?
-            env.write('set $key=${escapeCommandLineArgument(value)} & ') :
-            env.write('$key=${escapeCommandLineArgument(value)} '));
+        (io.Platform.operatingSystem == 'windows')
+            ? env.write('set $key=${escapeCommandLineArgument(value)} & ')
+            : env.write('$key=${escapeCommandLineArgument(value)} '));
     var command = ([executable]..addAll(arguments))
-        .map(escapeCommandLineArgument).join(' ');
+        .map(escapeCommandLineArgument)
+        .join(' ');
     if (workingDirectory != null) {
       command = "$command (working directory: $workingDirectory)";
     }
     return "$env$command";
   }
 
   Future<bool> get outputIsUpToDate => new Future.value(false);
 }
 
 class CompilationCommand extends ProcessCommand {
   final String _outputFile;
   final bool _neverSkipCompilation;
   final List<Uri> _bootstrapDependencies;
 
-  CompilationCommand._(String displayName,
-                       this._outputFile,
-                       this._neverSkipCompilation,
-                       this._bootstrapDependencies,
-                       String executable,
-                       List<String> arguments,
-                       Map<String, String> environmentOverrides)
+  CompilationCommand._(
+      String displayName,
+      this._outputFile,
+      this._neverSkipCompilation,
+      this._bootstrapDependencies,
+      String executable,
+      List<String> arguments,
+      Map<String, String> environmentOverrides)
       : super._(displayName, executable, arguments, environmentOverrides);
 
   Future<bool> get outputIsUpToDate {
     if (_neverSkipCompilation) return new Future.value(false);
 
     Future<List<Uri>> readDepsFile(String path) {
       var file = new io.File(new Path(path).toNativePath());
       if (!file.existsSync()) {
         return new Future.value(null);
       }
       return file.readAsLines().then((List<String> lines) {
         var dependencies = new List<Uri>();
         for (var line in lines) {
           line = line.trim();
           if (line.length > 0) {
             dependencies.add(Uri.parse(line));
           }
         }
         return dependencies;
       });
     }
 
     return readDepsFile("$_outputFile.deps").then((dependencies) {
       if (dependencies != null) {
         dependencies.addAll(_bootstrapDependencies);
-        var jsOutputLastModified = TestUtils.lastModifiedCache.getLastModified(
-            new Uri(scheme: 'file', path: _outputFile));
+        var jsOutputLastModified = TestUtils.lastModifiedCache
+            .getLastModified(new Uri(scheme: 'file', path: _outputFile));
         if (jsOutputLastModified != null) {
           for (var dependency in dependencies) {
             var dependencyLastModified =
                 TestUtils.lastModifiedCache.getLastModified(dependency);
             if (dependencyLastModified == null ||
                 dependencyLastModified.isAfter(jsOutputLastModified)) {
               return false;
             }
           }
           return true;
@@ skipping 17 matching lines @@
       deepJsonCompare(_bootstrapDependencies, other._bootstrapDependencies);
 }
 
 /// This is just a Pair(String, Map) class with hashCode and operator ==
 class AddFlagsKey {
   final String flags;
   final Map env;
   AddFlagsKey(this.flags, this.env);
   // Just use object identity for environment map
   bool operator ==(other) =>
-    other is AddFlagsKey && flags == other.flags && env == other.env;
+      other is AddFlagsKey && flags == other.flags && env == other.env;
   int get hashCode => flags.hashCode ^ env.hashCode;
 }
 
 class ContentShellCommand extends ProcessCommand {
-  ContentShellCommand._(String executable,
-                        String htmlFile,
-                        List<String> options,
-                        List<String> dartFlags,
-                        Map<String, String> environmentOverrides)
-      : super._("content_shell",
-               executable,
-               _getArguments(options, htmlFile),
-               _getEnvironment(environmentOverrides, dartFlags));
+  ContentShellCommand._(
+      String executable,
+      String htmlFile,
+      List<String> options,
+      List<String> dartFlags,
+      Map<String, String> environmentOverrides)
+      : super._("content_shell", executable, _getArguments(options, htmlFile),
+            _getEnvironment(environmentOverrides, dartFlags));
 
   // Cache the modified environments in a map from the old environment and
   // the string of Dart flags to the new environment.  Avoid creating new
   // environment object for each command object.
-  static Map<AddFlagsKey, Map> environments =
-      new Map<AddFlagsKey, Map>();
+  static Map<AddFlagsKey, Map> environments = new Map<AddFlagsKey, Map>();
 
   static Map _getEnvironment(Map env, List<String> dartFlags) {
     var needDartFlags = dartFlags != null && dartFlags.length > 0;
     if (needDartFlags) {
       if (env == null) {
-        env = const { };
+        env = const {};
       }
       var flags = dartFlags.join(' ');
-      return environments.putIfAbsent(new AddFlagsKey(flags, env),
+      return environments.putIfAbsent(
+          new AddFlagsKey(flags, env),
           () => new Map.from(env)
-              ..addAll({'DART_FLAGS': flags, 'DART_FORWARDING_PRINT': '1'}));
+            ..addAll({'DART_FLAGS': flags, 'DART_FORWARDING_PRINT': '1'}));
     }
     return env;
   }
 
   static List<String> _getArguments(List<String> options, String htmlFile) {
     var arguments = new List.from(options);
     arguments.add(htmlFile);
     return arguments;
   }
 
   int get maxNumRetries => 3;
 }
 
 class BrowserTestCommand extends Command {
   final String browser;
   final String url;
   final Map configuration;
   final bool retry;
 
-  BrowserTestCommand._(String _browser,
-                       this.url,
-                       this.configuration,
-                       this.retry)
-      : super._(_browser), browser = _browser;
+  BrowserTestCommand._(
+      String _browser, this.url, this.configuration, this.retry)
+      : super._(_browser),
+        browser = _browser;
 
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
     builder.addJson(browser);
     builder.addJson(url);
     builder.add(configuration);
     builder.add(retry);
   }
 
   bool _equal(BrowserTestCommand other) =>
       super._equal(other) &&
       browser == other.browser &&
       url == other.url &&
       identical(configuration, other.configuration) &&
       retry == other.retry;
 
   String get reproductionCommand {
-    var parts = [io.Platform.resolvedExecutable,
-                'tools/testing/dart/launch_browser.dart',
-                browser,
-                url];
+    var parts = [
+      io.Platform.resolvedExecutable,
+      'tools/testing/dart/launch_browser.dart',
+      browser,
+      url
+    ];
     return parts.map(escapeCommandLineArgument).join(' ');
   }
 
   int get maxNumRetries => 4;
 }
 
 class BrowserHtmlTestCommand extends BrowserTestCommand {
   List<String> expectedMessages;
-  BrowserHtmlTestCommand._(String browser,
-                           String url,
-                           Map configuration,
-                           this.expectedMessages,
-                           bool retry)
+  BrowserHtmlTestCommand._(String browser, String url, Map configuration,
+      this.expectedMessages, bool retry)
       : super._(browser, url, configuration, retry);
 
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
     builder.addJson(expectedMessages);
   }
 
   bool _equal(BrowserHtmlTestCommand other) =>
       super._equal(other) &&
       identical(expectedMessages, other.expectedMessages);
 }
 
 class AnalysisCommand extends ProcessCommand {
   final String flavor;
 
-  AnalysisCommand._(this.flavor,
-                    String displayName,
-                    String executable,
-                    List<String> arguments,
-                    Map<String, String> environmentOverrides)
+  AnalysisCommand._(this.flavor, String displayName, String executable,
+      List<String> arguments, Map<String, String> environmentOverrides)
       : super._(displayName, executable, arguments, environmentOverrides);
 
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
     builder.addJson(flavor);
   }
 
   bool _equal(AnalysisCommand other) =>
-      super._equal(other) &&
-      flavor == other.flavor;
+      super._equal(other) && flavor == other.flavor;
 }
 
 class VmCommand extends ProcessCommand {
-  VmCommand._(String executable,
-              List<String> arguments,
-              Map<String,String> environmentOverrides)
+  VmCommand._(String executable, List<String> arguments,
+      Map<String, String> environmentOverrides)
       : super._("vm", executable, arguments, environmentOverrides);
 }
 
 class JSCommandlineCommand extends ProcessCommand {
-  JSCommandlineCommand._(String displayName,
-                         String executable,
-                         List<String> arguments,
-                         [Map<String, String> environmentOverrides = null])
-      : super._(displayName,
-                executable,
-                arguments,
-                environmentOverrides);
+  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;
 
-  PubCommand._(String pubCommand,
-               String pubExecutable,
-               String pubspecYamlDirectory,
-               String pubCacheDirectory)
-      : super._('pub_$pubCommand',
-                new io.File(pubExecutable).absolute.path,
-                [pubCommand],
-                {'PUB_CACHE' : pubCacheDirectory},
-                pubspecYamlDirectory), command = pubCommand;
+  PubCommand._(String pubCommand, String pubExecutable,
+      String pubspecYamlDirectory, String pubCacheDirectory)
+      : super._(
+            'pub_$pubCommand',
+            new io.File(pubExecutable).absolute.path,
+            [pubCommand],
+            {'PUB_CACHE': pubCacheDirectory},
+            pubspecYamlDirectory),
+        command = pubCommand;
 
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
     builder.addJson(command);
   }
 
   bool _equal(PubCommand other) =>
-      super._equal(other) &&
-      command == other.command;
+      super._equal(other) && command == other.command;
 }
 
 /* [ScriptCommand]s are executed by dart code. */
 abstract class ScriptCommand extends Command {
   ScriptCommand._(String displayName) : super._(displayName);
 
   Future<ScriptCommandOutputImpl> run();
 }
 
 class CleanDirectoryCopyCommand extends ScriptCommand {
   final String _sourceDirectory;
   final String _destinationDirectory;
 
   CleanDirectoryCopyCommand._(this._sourceDirectory, this._destinationDirectory)
-    : super._('dir_copy');
+      : super._('dir_copy');
 
   String get reproductionCommand =>
       "Copying '$_sourceDirectory' to '$_destinationDirectory'.";
 
   Future<ScriptCommandOutputImpl> run() {
     var watch = new Stopwatch()..start();
 
     var destination = new io.Directory(_destinationDirectory);
 
     return destination.exists().then((bool exists) {
@@ skipping 25 matching lines @@
       super._equal(other) &&
       _sourceDirectory == other._sourceDirectory &&
       _destinationDirectory == other._destinationDirectory;
 }
 
 class ModifyPubspecYamlCommand extends ScriptCommand {
   String _pubspecYamlFile;
   String _destinationFile;
   Map<String, Map> _dependencyOverrides;
 
-  ModifyPubspecYamlCommand._(this._pubspecYamlFile,
-                             this._destinationFile,
-                             this._dependencyOverrides)
-    : super._("modify_pubspec") {
+  ModifyPubspecYamlCommand._(
+      this._pubspecYamlFile, this._destinationFile, this._dependencyOverrides)
+      : super._("modify_pubspec") {
     assert(_pubspecYamlFile.endsWith("pubspec.yaml"));
     assert(_destinationFile.endsWith("pubspec.yaml"));
   }
 
   String get reproductionCommand =>
       "Adding necessary dependency overrides to '$_pubspecYamlFile' "
       "(destination = $_destinationFile).";
 
   Future<ScriptCommandOutputImpl> run() {
     var watch = new Stopwatch()..start();
 
-    var pubspecLockFile =
-        _destinationFile.substring(0, _destinationFile.length - ".yaml".length)
-        + ".lock";
+    var pubspecLockFile = _destinationFile.substring(
+            0, _destinationFile.length - ".yaml".length) +
+        ".lock";
 
     var file = new io.File(_pubspecYamlFile);
     var destinationFile = new io.File(_destinationFile);
     var lockfile = new io.File(pubspecLockFile);
     return file.readAsString().then((String yamlString) {
       var dependencyOverrideSection = new StringBuffer();
       if (_dependencyOverrides.isNotEmpty) {
-        dependencyOverrideSection.write(
-            "\n"
+        dependencyOverrideSection.write("\n"
             "# This section was autogenerated by test.py!\n"
             "dependency_overrides:\n");
         _dependencyOverrides.forEach((String packageName, Map override) {
           dependencyOverrideSection.write("  $packageName:\n");
           override.forEach((overrideKey, overrideValue) {
-            dependencyOverrideSection.write(
-                "    $overrideKey: $overrideValue\n");
+            dependencyOverrideSection
+                .write("    $overrideKey: $overrideValue\n");
           });
         });
       }
       var modifiedYamlString = "$yamlString\n$dependencyOverrideSection";
       return destinationFile.writeAsString(modifiedYamlString).then((_) {
         lockfile.exists().then((bool lockfileExists) {
           if (lockfileExists) {
             return lockfile.delete();
           }
         });
@@ skipping 35 matching lines @@
 
   Future<ScriptCommandOutputImpl> run() {
     var watch = new Stopwatch()..start();
     var targetFile = new io.Directory(_target);
     return targetFile.exists().then((bool targetExists) {
       if (!targetExists) {
         throw new Exception("Target '$_target' does not exist");
       }
       var link = new io.Link(_link);
 
-      return link.exists()
-          .then((bool exists) { if (exists) return link.delete(); })
-          .then((_) => link.create(_target));
+      return link.exists().then((bool exists) {
+        if (exists) return link.delete();
+      }).then((_) => link.create(_target));
     }).then((_) {
       return new ScriptCommandOutputImpl(
           this, Expectation.PASS, "", watch.elapsed);
     }).catchError((error) {
       return new ScriptCommandOutputImpl(
           this, Expectation.FAIL, "An error occured: $error.", watch.elapsed);
     });
   }
 
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
     builder.addJson(_link);
     builder.addJson(_target);
   }
 
   bool _equal(MakeSymlinkCommand other) =>
-      super._equal(other) &&
-      _link == other._link &&
-      _target == other._target;
+      super._equal(other) && _link == other._link && _target == other._target;
 }
 
 class CommandBuilder {
   static final CommandBuilder instance = new CommandBuilder._();
 
   bool _cleared = false;
   final _cachedCommands = new Map<Command, Command>();
 
   CommandBuilder._();
 
   void clearCommandCache() {
     _cachedCommands.clear();
     _cleared = true;
   }
 
-  ContentShellCommand getContentShellCommand(String executable,
-                                             String htmlFile,
-                                             List<String> options,
-                                             List<String> dartFlags,
-                                             Map<String, String> environment) {
+  ContentShellCommand getContentShellCommand(
+      String executable,
+      String htmlFile,
+      List<String> options,
+      List<String> dartFlags,
+      Map<String, String> environment) {
     ContentShellCommand command = new ContentShellCommand._(
         executable, htmlFile, options, dartFlags, environment);
     return _getUniqueCommand(command);
   }
 
-  BrowserTestCommand getBrowserTestCommand(String browser,
-                                           String url,
-                                           Map configuration,
-                                           bool retry) {
+  BrowserTestCommand getBrowserTestCommand(
+      String browser, String url, Map configuration, bool retry) {
     var command = new BrowserTestCommand._(browser, url, configuration, retry);
     return _getUniqueCommand(command);
   }
 
-  BrowserHtmlTestCommand getBrowserHtmlTestCommand(String browser,
-                                               String url,
-                                               Map configuration,
-                                               List<String> expectedMessages,
-                                               bool retry) {
+  BrowserHtmlTestCommand getBrowserHtmlTestCommand(String browser, String url,
+      Map configuration, List<String> expectedMessages, bool retry) {
     var command = new BrowserHtmlTestCommand._(
         browser, url, configuration, expectedMessages, retry);
     return _getUniqueCommand(command);
   }
 
-  CompilationCommand getCompilationCommand(String displayName,
-                                           outputFile,
-                                           neverSkipCompilation,
-                                           List<Uri> bootstrapDependencies,
-                                           String executable,
-                                           List<String> arguments,
-                                           Map<String, String> environment) {
-    var command =
-        new CompilationCommand._(
-            displayName, outputFile, neverSkipCompilation,
-            bootstrapDependencies, executable, arguments, environment);
+  CompilationCommand getCompilationCommand(
+      String displayName,
+      outputFile,
+      neverSkipCompilation,
+      List<Uri> bootstrapDependencies,
+      String executable,
+      List<String> arguments,
+      Map<String, String> environment) {
+    var command = new CompilationCommand._(
+        displayName,
+        outputFile,
+        neverSkipCompilation,
+        bootstrapDependencies,
+        executable,
+        arguments,
+        environment);
     return _getUniqueCommand(command);
   }
 
   AnalysisCommand getAnalysisCommand(
       String displayName, executable, arguments, environmentOverrides,
       {String flavor: 'dart2analyzer'}) {
     var command = new AnalysisCommand._(
         flavor, displayName, executable, arguments, environmentOverrides);
     return _getUniqueCommand(command);
   }
 
-  VmCommand getVmCommand(String executable,
-                         List<String> arguments,
-                         Map<String, String> environmentOverrides) {
+  VmCommand getVmCommand(String executable, List<String> arguments,
+      Map<String, String> environmentOverrides) {
     var command = new VmCommand._(executable, arguments, environmentOverrides);
     return _getUniqueCommand(command);
   }
 
   Command getJSCommandlineCommand(String displayName, executable, arguments,
-                                  [environment = null]) {
-    var command = new JSCommandlineCommand._(displayName, executable, arguments,
-                                             environment);
+      [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._(displayName, executable, arguments,
-                                       environment, workingDirectory);
+      [environment = null, workingDirectory = null]) {
+    var command = new ProcessCommand._(
+        displayName, executable, arguments, environment, workingDirectory);
     return _getUniqueCommand(command);
   }
 
   Command getCopyCommand(String sourceDirectory, String destinationDirectory) {
-    var command = new CleanDirectoryCopyCommand._(sourceDirectory,
-                                                  destinationDirectory);
+    var command =
+        new CleanDirectoryCopyCommand._(sourceDirectory, destinationDirectory);
     return _getUniqueCommand(command);
   }
 
-  Command getPubCommand(String pubCommand,
-                        String pubExecutable,
-                        String pubspecYamlDirectory,
-                        String pubCacheDirectory) {
-    var command = new PubCommand._(pubCommand,
-                                   pubExecutable,
-                                   pubspecYamlDirectory,
-                                   pubCacheDirectory);
+  Command getPubCommand(String pubCommand, String pubExecutable,
+      String pubspecYamlDirectory, String pubCacheDirectory) {
+    var command = new PubCommand._(
+        pubCommand, pubExecutable, pubspecYamlDirectory, pubCacheDirectory);
     return _getUniqueCommand(command);
   }
 
   Command getMakeSymlinkCommand(String link, String target) {
     return _getUniqueCommand(new MakeSymlinkCommand._(link, target));
   }
 
   Command getModifyPubspecCommand(String pubspecYamlFile, Map depsOverrides,
-                                  {String destinationFile: null}) {
+      {String destinationFile: null}) {
     if (destinationFile == null) destinationFile = pubspecYamlFile;
     return _getUniqueCommand(new ModifyPubspecYamlCommand._(
         pubspecYamlFile, destinationFile, depsOverrides));
   }
 
   Command _getUniqueCommand(Command command) {
     // All Command classes implement hashCode and operator==.
     // We check if this command has already been built.
     //  If so, we return the cached one. Otherwise we
     // store the one given as [command] argument.
@@ skipping 36 matching lines @@
   static final int HAS_COMPILE_ERROR = 1 << 4;
   static final int HAS_COMPILE_ERROR_IF_CHECKED = 1 << 5;
   static final int EXPECT_COMPILE_ERROR = 1 << 6;
   /**
    * A list of commands to execute. Most test cases have a single command.
    * Dart2js tests have two commands, one to compile the source and another
    * to execute it. Some isolate tests might even have three, if they require
    * compiling multiple sources that are run in isolation.
    */
   List<Command> commands;
-  Map<Command, CommandOutput> commandOutputs = new Map<Command,CommandOutput>();
+  Map<Command, CommandOutput> commandOutputs =
+      new Map<Command, CommandOutput>();
 
   Map configuration;
   String displayName;
   int _expectations = 0;
   int hash = 0;
   Set<Expectation> expectedOutcomes;
 
-  TestCase(this.displayName,
-           this.commands,
-           this.configuration,
-           this.expectedOutcomes,
-           {isNegative: false,
-            TestInformation info: null}) {
+  TestCase(this.displayName, this.commands, this.configuration,
+      this.expectedOutcomes,
+      {isNegative: false, TestInformation info: null}) {
     if (isNegative || displayName.contains("negative_test")) {
       _expectations |= IS_NEGATIVE;
     }
     if (info != null) {
       _setExpectations(info);
-      hash = info.originTestPath.relativeTo(TestUtils.dartDir)
-          .toString().hashCode;
+      hash =
+          info.originTestPath.relativeTo(TestUtils.dartDir).toString().hashCode;
     }
   }
 
   void _setExpectations(TestInformation info) {
     // We don't want to keep the entire (large) TestInformation structure,
     // so we copy the needed bools into flags set in a single integer.
     if (info.hasRuntimeError) _expectations |= HAS_RUNTIME_ERROR;
     if (info.hasStaticWarning) _expectations |= HAS_STATIC_WARNING;
     if (info.isNegativeIfChecked) _expectations |= IS_NEGATIVE_IF_CHECKED;
     if (info.hasCompileError) _expectations |= HAS_COMPILE_ERROR;
@@ skipping 20 matching lines @@
     return !expectedOutcomes.any((expectation) {
       return outcome.canBeOutcomeOf(expectation);
     });
   }
 
   Expectation get result => lastCommandOutput.result(this);
 
   CommandOutput get lastCommandOutput {
     if (commandOutputs.length == 0) {
       throw new Exception("CommandOutputs is empty, maybe no command was run? ("
-                          "displayName: '$displayName', "
-                          "configurationString: '$configurationString')");
+          "displayName: '$displayName', "
+          "configurationString: '$configurationString')");
     }
     return commandOutputs[commands[commandOutputs.length - 1]];
   }
 
   Command get lastCommandExecuted {
     if (commandOutputs.length == 0) {
       throw new Exception("CommandOutputs is empty, maybe no command was run? ("
-                          "displayName: '$displayName', "
-                          "configurationString: '$configurationString')");
+          "displayName: '$displayName', "
+          "configurationString: '$configurationString')");
     }
     return commands[commandOutputs.length - 1];
   }
 
   int get timeout {
     if (expectedOutcomes.contains(Expectation.SLOW)) {
       return configuration['timeout'] * SLOW_TIMEOUT_MULTIPLIER;
     } else {
       return configuration['timeout'];
     }
   }
 
   String get configurationString {
     final compiler = configuration['compiler'];
     final runtime = configuration['runtime'];
     final mode = configuration['mode'];
     final arch = configuration['arch'];
     final checked = configuration['checked'] ? '-checked' : '';
     return "$compiler-$runtime$checked ${mode}_$arch";
   }
 
   List<String> get batchTestArguments {
     assert(commands.last is ProcessCommand);
     return (commands.last as ProcessCommand).arguments;
   }
 
   bool get isFlaky {
-      if (expectedOutcomes.contains(Expectation.SKIP) ||
-          expectedOutcomes.contains(Expectation.SKIP_BY_DESIGN)) {
-        return false;
-      }
+    if (expectedOutcomes.contains(Expectation.SKIP) ||
+        expectedOutcomes.contains(Expectation.SKIP_BY_DESIGN)) {
+      return false;
+    }
 
-      return expectedOutcomes
-        .where((expectation) => !expectation.isMetaExpectation).length > 1;
+    return expectedOutcomes
+            .where((expectation) => !expectation.isMetaExpectation)
+            .length >
+        1;
   }
 
   bool get isFinished {
     return commandOutputs.length > 0 &&
         (!lastCommandOutput.successful ||
-         commands.length == commandOutputs.length);
+            commands.length == commandOutputs.length);
   }
 }
 
-
 /**
  * BrowserTestCase has an extra compilation command that is run in a separate
  * process, before the regular test is run as in the base class [TestCase].
  * If the compilation command fails, then the rest of the test is not run.
  */
 class BrowserTestCase extends TestCase {
-
-  BrowserTestCase(displayName, commands, configuration,
-                  expectedOutcomes, info, isNegative, this._testingUrl)
-    : super(displayName, commands, configuration,
-            expectedOutcomes, isNegative: isNegative, info: info);
+  BrowserTestCase(displayName, commands, configuration, expectedOutcomes, info,
+      isNegative, this._testingUrl)
+      : super(displayName, commands, configuration, expectedOutcomes,
+            isNegative: isNegative, info: info);
 
   String _testingUrl;
 
   String get testingUrl => _testingUrl;
 }
 
 class UnittestSuiteMessagesMixin {
   bool _isAsyncTest(String testOutput) {
     return testOutput.contains("unittest-suite-wait-for-done");
   }
 
   bool _isAsyncTestSuccessful(String testOutput) {
     return testOutput.contains("unittest-suite-success");
   }
 
-  Expectation _negateOutcomeIfIncompleteAsyncTest(Expectation outcome,
-                                                  String testOutput) {
+  Expectation _negateOutcomeIfIncompleteAsyncTest(
+      Expectation outcome, String testOutput) {
     // If this is an asynchronous test and the asynchronous operation didn't
     // complete successfully, it's outcome is Expectation.FAIL.
     // TODO: maybe we should introduce a AsyncIncomplete marker or so
     if (outcome == Expectation.PASS) {
-      if (_isAsyncTest(testOutput) &&
-          !_isAsyncTestSuccessful(testOutput)) {
+      if (_isAsyncTest(testOutput) && !_isAsyncTestSuccessful(testOutput)) {
         return Expectation.FAIL;
       }
     }
     return outcome;
   }
 }
 
 /**
  * CommandOutput records the output of a completed command: the process's exit
  * code, the standard output and standard error, whether the process timed out,
@@ skipping 44 matching lines @@
   bool compilationSkipped;
   int pid;
 
   /**
    * A flag to indicate we have already printed a warning about ignoring the VM
    * crash, to limit the amount of output produced per test.
    */
   bool alreadyPrintedWarning = false;
 
   // TODO(kustermann): Remove testCase from this class.
-  CommandOutputImpl(Command this.command,
-                    int this.exitCode,
-                    bool this.timedOut,
-                    List<int> this.stdout,
-                    List<int> this.stderr,
-                    Duration this.time,
-                    bool this.compilationSkipped,
-                    int this.pid) {
+  CommandOutputImpl(
+      Command this.command,
+      int this.exitCode,
+      bool this.timedOut,
+      List<int> this.stdout,
+      List<int> this.stderr,
+      Duration this.time,
+      bool this.compilationSkipped,
+      int this.pid) {
     diagnostics = [];
   }
 
   Expectation result(TestCase testCase) {
     if (hasCrashed) return Expectation.CRASH;
     if (hasTimedOut) return Expectation.TIMEOUT;
     return hasFailed(testCase) ? Expectation.FAIL : Expectation.PASS;
   }
 
   bool get hasCrashed {
@@ skipping 33 matching lines @@
   bool get successful {
     // FIXME(kustermann): We may need to change this
     return !hasTimedOut && exitCode == 0;
   }
 
   // Reverse result of a negative test.
   bool hasFailed(TestCase testCase) {
     return testCase.isNegative ? !didFail(testCase) : didFail(testCase);
   }
 
-  Expectation _negateOutcomeIfNegativeTest(Expectation outcome,
-                                           bool isNegative) {
+  Expectation _negateOutcomeIfNegativeTest(
+      Expectation outcome, bool isNegative) {
     if (!isNegative) return outcome;
 
     if (outcome.canBeOutcomeOf(Expectation.FAIL)) {
       return Expectation.PASS;
     }
     return Expectation.FAIL;
   }
 }
 
 class BrowserCommandOutputImpl extends CommandOutputImpl {
   // Although tests are reported as passing, content shell sometimes exits with
   // a nonzero exitcode which makes our dartium builders extremely falky.
   // See: http://dartbug.com/15139.
   static int WHITELISTED_CONTENTSHELL_EXITCODE = -1073740022;
   static bool isWindows = io.Platform.operatingSystem == 'windows';
 
   bool _failedBecauseOfMissingXDisplay;
 
   BrowserCommandOutputImpl(
-      command,
-      exitCode,
-      timedOut,
-      stdout,
-      stderr,
-      time,
-      compilationSkipped) :
-    super(command,
-          exitCode,
-          timedOut,
-          stdout,
-          stderr,
-          time,
-          compilationSkipped,
-          0) {
+      command, exitCode, timedOut, stdout, stderr, time, compilationSkipped)
+      : super(command, exitCode, timedOut, stdout, stderr, time,
+            compilationSkipped, 0) {
     _failedBecauseOfMissingXDisplay = _didFailBecauseOfMissingXDisplay();
     if (_failedBecauseOfMissingXDisplay) {
       DebugLogger.warning("Warning: Test failure because of missing XDisplay");
       // If we get the X server error, or DRT crashes with a core dump, retry
       // the test.
     }
   }
 
   Expectation result(TestCase testCase) {
     // Handle crashes and timeouts first
@@ skipping 81 matching lines @@
           }
           break;
       }
     }
     if (hasContentType) {
       if (containsFail && containsPass) {
         DebugLogger.warning("Test had 'FAIL' and 'PASS' in stdout. ($command)");
       }
       if (!containsFail && !containsPass) {
         DebugLogger.warning("Test had neither 'FAIL' nor 'PASS' in stdout. "
-                            "($command)");
+            "($command)");
         return true;
       }
       if (containsFail) {
         return true;
       }
       assert(containsPass);
       if (exitCode != 0) {
         var message = "All tests passed, but exitCode != 0. "
-                      "Actual exitcode: $exitCode. "
-                      "($command)";
+            "Actual exitcode: $exitCode. "
+            "($command)";
         DebugLogger.warning(message);
         diagnostics.add(message);
       }
       return (!hasCrashed &&
-              exitCode != 0 &&
-              (!isWindows || exitCode != WHITELISTED_CONTENTSHELL_EXITCODE));
+          exitCode != 0 &&
+          (!isWindows || exitCode != WHITELISTED_CONTENTSHELL_EXITCODE));
     }
     DebugLogger.warning("Couldn't find 'Content-Type: text/plain' in output. "
-                        "($command).");
+        "($command).");
     return true;
   }
 }
 
 class HTMLBrowserCommandOutputImpl extends BrowserCommandOutputImpl {
- HTMLBrowserCommandOutputImpl(
-      command,
-      exitCode,
-      timedOut,
-      stdout,
-      stderr,
-      time,
-      compilationSkipped) :
-    super(command,
-          exitCode,
-          timedOut,
-          stdout,
-          stderr,
-          time,
-          compilationSkipped);
+  HTMLBrowserCommandOutputImpl(
+      command, exitCode, timedOut, stdout, stderr, time, compilationSkipped)
+      : super(command, exitCode, timedOut, stdout, stderr, time,
+            compilationSkipped);
 
   bool didFail(TestCase testCase) {
     return _getOutcome() != Expectation.PASS;
   }
 
-
   bool get _browserTestFailure {
     // We should not need to convert back and forward.
     var output = decodeUtf8(super.stdout);
     if (output.contains("FAIL")) return true;
     return !output.contains("PASS");
   }
 }
 
 class BrowserTestJsonResult {
-  static const ALLOWED_TYPES =
-      const ['sync_exception', 'window_onerror', 'script_onerror',
-             'window_compilationerror', 'print', 'message_received', 'dom',
-             'debug'];
+  static const ALLOWED_TYPES = const [
+    'sync_exception',
+    'window_onerror',
+    'script_onerror',
+    'window_compilationerror',
+    'print',
+    'message_received',
+    'dom',
+    'debug'
+  ];
 
   final Expectation outcome;
   final String htmlDom;
   final List events;
 
   BrowserTestJsonResult(this.outcome, this.htmlDom, this.events);
 
   static BrowserTestJsonResult parseFromString(String content) {
     void validate(String assertion, bool value) {
       if (!value) {
         throw "InvalidFormat sent from browser driving page: $assertion:\n\n"
-               "$content";
+            "$content";
       }
     }
 
     var events;
     try {
       events = JSON.decode(content);
       if (events != null) {
         validate("Message must be a List", events is List);
 
         Map<String, List<String>> messagesByType = {};
         ALLOWED_TYPES.forEach((type) => messagesByType[type] = <String>[]);
 
         for (var entry in events) {
           validate("An entry must be a Map", entry is Map);
 
           var type = entry['type'];
           var value = entry['value'];
           var timestamp = entry['timestamp'];
 
-          validate("'type' of an entry must be a String",
-                   type is String);
+          validate("'type' of an entry must be a String", type is String);
           validate("'type' has to be in $ALLOWED_TYPES.",
-                   ALLOWED_TYPES.contains(type));
-          validate("'timestamp' of an entry must be a number",
-                   timestamp is num);
+              ALLOWED_TYPES.contains(type));
+          validate(
+              "'timestamp' of an entry must be a number", timestamp is num);
 
           messagesByType[type].add(value);
         }
         validate("The message must have exactly one 'dom' entry.",
             messagesByType['dom'].length == 1);
 
         var dom = messagesByType['dom'][0];
         if (dom.endsWith('\n')) {
           dom = '$dom\n';
         }
 
         return new BrowserTestJsonResult(
             _getOutcome(messagesByType), dom, events);
       }
-    } catch(error) {
+    } catch (error) {
       // If something goes wrong, we know the content was not in the correct
       // JSON format. So we can't parse it.
       // The caller is responsible for falling back to the old way of
       // determining if a test failed.
     }
 
     return null;
   }
 
   static Expectation _getOutcome(Map<String, List<String>> messagesByType) {
@@ skipping 16 matching lines @@
     }
 
     if (messagesByType['dom'][0].contains('FAIL')) {
       return Expectation.RUNTIME_ERROR;
     }
 
     // We search for these messages in 'print' and 'message_received' because
     // the unittest implementation posts these messages using
     // "window.postMessage()" instead of the normal "print()" them.
 
-    var isAsyncTest = searchForMsg(['print', 'message_received'],
-                                   'unittest-suite-wait-for-done');
+    var isAsyncTest = searchForMsg(
+        ['print', 'message_received'], 'unittest-suite-wait-for-done');
     var isAsyncSuccess =
         searchForMsg(['print', 'message_received'], 'unittest-suite-success') ||
-        searchForMsg(['print', 'message_received'], 'unittest-suite-done');
+            searchForMsg(['print', 'message_received'], 'unittest-suite-done');
 
     if (isAsyncTest) {
       if (isAsyncSuccess) {
         return Expectation.PASS;
       }
       return Expectation.RUNTIME_ERROR;
     }
 
     var mainStarted =
         searchForMsg(['print', 'message_received'], 'dart-calling-main');
     var mainDone =
         searchForMsg(['print', 'message_received'], 'dart-main-done');
 
     if (mainStarted && mainDone) {
       return Expectation.PASS;
     }
     return Expectation.FAIL;
   }
 }
 
 class BrowserControllerTestOutcome extends CommandOutputImpl
-                                   with UnittestSuiteMessagesMixin {
+    with UnittestSuiteMessagesMixin {
   BrowserTestOutput _result;
   Expectation _rawOutcome;
 
-  factory BrowserControllerTestOutcome(Command command,
-                                       BrowserTestOutput result) {
+  factory BrowserControllerTestOutcome(
+      Command command, BrowserTestOutput result) {
     void validate(String assertion, bool value) {
       if (!value) {
         throw "InvalidFormat sent from browser driving page: $assertion:\n\n"
-              "${result.lastKnownMessage}";
+            "${result.lastKnownMessage}";
       }
     }
 
     String indent(String string, int numSpaces) {
       var spaces = new List.filled(numSpaces, ' ').join('');
-      return string.replaceAll('\r\n', '\n')
+      return string
+          .replaceAll('\r\n', '\n')
           .split('\n')
           .map((line) => "$spaces$line")
           .join('\n');
     }
 
     String stdout = "";
     String stderr = "";
     Expectation outcome;
 
     var parsedResult =
         BrowserTestJsonResult.parseFromString(result.lastKnownMessage);
     if (parsedResult != null) {
       outcome = parsedResult.outcome;
     } else {
       // Old way of determining whether a test failed or passed.
       if (result.lastKnownMessage.contains("FAIL")) {
         outcome = Expectation.RUNTIME_ERROR;
       } else if (result.lastKnownMessage.contains("PASS")) {
         outcome = Expectation.PASS;
       } else {
         outcome = Expectation.RUNTIME_ERROR;
       }
     }
 
     if (result.didTimeout) {
       if (result.delayUntilTestStarted != null) {
         stderr = "This test timed out. The delay until the test actually "
-                 "started was: ${result.delayUntilTestStarted}.";
+            "started was: ${result.delayUntilTestStarted}.";
       } else {
         // TODO(ricow/kustermann) as soon as we record the state periodically,
         // we will have more information and can remove this warning.
         stderr = "This test has not notified test.py that it started running. "
-                 "This could be a bug in test.py! "
-                 "Please contact ricow/whesse";
+            "This could be a bug in test.py! "
+            "Please contact ricow/whesse";
       }
     }
 
     if (parsedResult != null) {
       stdout = "events:\n${indent(prettifyJson(parsedResult.events), 2)}\n\n";
     } else {
       stdout = "message:\n${indent(result.lastKnownMessage, 2)}\n\n";
     }
 
-    stderr =
-        '$stderr\n\n'
+    stderr = '$stderr\n\n'
         'BrowserOutput while running the test (* EXPERIMENTAL *):\n'
         'BrowserOutput.stdout:\n'
         '${indent(result.browserOutput.stdout.toString(), 2)}\n'
         'BrowserOutput.stderr:\n'
         '${indent(result.browserOutput.stderr.toString(), 2)}\n'
         '\n';
     return new BrowserControllerTestOutcome._internal(
-      command, result, outcome, encodeUtf8(stdout), encodeUtf8(stderr));
+        command, result, outcome, encodeUtf8(stdout), encodeUtf8(stderr));
   }
 
   BrowserControllerTestOutcome._internal(
-      Command command, BrowserTestOutput result, this._rawOutcome,
-      List<int> stdout, List<int> stderr)
+      Command command,
+      BrowserTestOutput result,
+      this._rawOutcome,
+      List<int> stdout,
+      List<int> stderr)
       : super(command, 0, result.didTimeout, stdout, stderr, result.duration,
-              false, 0) {
+            false, 0) {
     _result = result;
   }
 
   Expectation result(TestCase testCase) {
     // Handle timeouts first
-    if (_result.didTimeout)  return Expectation.TIMEOUT;
+    if (_result.didTimeout) return Expectation.TIMEOUT;
 
     // Multitests are handled specially
     if (testCase.hasRuntimeError) {
       if (_rawOutcome == Expectation.RUNTIME_ERROR) return Expectation.PASS;
       return Expectation.MISSING_RUNTIME_ERROR;
     }
 
     return _negateOutcomeIfNegativeTest(_rawOutcome, testCase.isNegative);
   }
 }
 
-
 class AnalysisCommandOutputImpl extends CommandOutputImpl {
   // An error line has 8 fields that look like:
   // ERROR|COMPILER|MISSING_SOURCE|file:/tmp/t.dart|15|1|24|Missing source.
   final int ERROR_LEVEL = 0;
   final int ERROR_TYPE = 1;
   final int FILENAME = 3;
   final int FORMATTED_ERROR = 7;
 
-  AnalysisCommandOutputImpl(command,
-                            exitCode,
-                            timedOut,
-                            stdout,
-                            stderr,
-                            time,
-                            compilationSkipped) :
-    super(command,
-          exitCode,
-          timedOut,
-          stdout,
-          stderr,
-          time,
-          compilationSkipped,
-          0);
+  AnalysisCommandOutputImpl(
+      command, exitCode, timedOut, stdout, stderr, time, compilationSkipped)
+      : super(command, exitCode, timedOut, stdout, stderr, time,
+            compilationSkipped, 0);
 
   Expectation result(TestCase testCase) {
     // TODO(kustermann): If we run the analyzer not in batch mode, make sure
     // that command.exitCodes matches 2 (errors), 1 (warnings), 0 (no warnings,
     // no errors)
 
     // Handle crashes and timeouts first
     if (hasCrashed) return Expectation.CRASH;
     if (hasTimedOut) return Expectation.TIMEOUT;
 
@@ skipping 17 matching lines @@
     if (testCase.hasStaticWarning) {
       if (warnings.length > 0) {
         return Expectation.PASS;
       }
       return Expectation.MISSING_STATIC_WARNING;
     }
     if (warnings.length > 0) {
       return Expectation.STATIC_WARNING;
     }
 
-    assert (errors.length == 0 && warnings.length == 0);
-    assert (!testCase.hasCompileError &&
-            !testCase.hasStaticWarning);
+    assert(errors.length == 0 && warnings.length == 0);
+    assert(!testCase.hasCompileError && !testCase.hasStaticWarning);
     return Expectation.PASS;
   }
 
   void parseAnalyzerOutput(List<String> outErrors, List<String> outWarnings) {
     // Parse a line delimited by the | character using \ as an escape charager
     // like:  FOO|BAR|FOO\|BAR|FOO\\BAZ as 4 fields: FOO BAR FOO|BAR FOO\BAZ
     List<String> splitMachineError(String line) {
       StringBuffer field = new StringBuffer();
       List<String> result = [];
       bool escaped = false;
-      for (var i = 0 ; i < line.length; i++) {
+      for (var i = 0; i < line.length; i++) {
         var c = line[i];
         if (!escaped && c == '\\') {
           escaped = true;
           continue;
         }
         escaped = false;
         if (c == '|') {
           result.add(field.toString());
           field = new StringBuffer();
           continue;
@@ skipping 14 matching lines @@
         } else if (fields[ERROR_LEVEL] == 'WARNING') {
           outWarnings.add(fields[FORMATTED_ERROR]);
         }
         // OK to Skip error output that doesn't match the machine format
       }
     }
   }
 }
 
 class VmCommandOutputImpl extends CommandOutputImpl
-                          with UnittestSuiteMessagesMixin {
+    with UnittestSuiteMessagesMixin {
   static const DART_VM_EXITCODE_COMPILE_TIME_ERROR = 254;
   static const DART_VM_EXITCODE_UNCAUGHT_EXCEPTION = 255;
 
   VmCommandOutputImpl(Command command, int exitCode, bool timedOut,
-                      List<int> stdout, List<int> stderr, Duration time,
-                      int pid)
+      List<int> stdout, List<int> stderr, Duration time, int pid)
       : super(command, exitCode, timedOut, stdout, stderr, time, false, pid);
 
   Expectation result(TestCase testCase) {
     // Handle crashes and timeouts first
     if (hasCrashed) return Expectation.CRASH;
     if (hasTimedOut) return Expectation.TIMEOUT;
 
     // Multitests are handled specially
     if (testCase.expectCompileError) {
       if (exitCode == DART_VM_EXITCODE_COMPILE_TIME_ERROR) {
@@ skipping 23 matching lines @@
       outcome = Expectation.PASS;
     }
     outcome = _negateOutcomeIfIncompleteAsyncTest(outcome, decodeUtf8(stdout));
     return _negateOutcomeIfNegativeTest(outcome, testCase.isNegative);
   }
 }
 
 class CompilationCommandOutputImpl extends CommandOutputImpl {
   static const DART2JS_EXITCODE_CRASH = 253;
 
-  CompilationCommandOutputImpl(Command command, int exitCode, bool timedOut,
-      List<int> stdout, List<int> stderr, Duration time,
+  CompilationCommandOutputImpl(
+      Command command,
+      int exitCode,
+      bool timedOut,
+      List<int> stdout,
+      List<int> stderr,
+      Duration time,
       bool compilationSkipped)
       : super(command, exitCode, timedOut, stdout, stderr, time,
-              compilationSkipped, 0);
+            compilationSkipped, 0);
 
   Expectation result(TestCase testCase) {
     // Handle general crash/timeout detection.
     if (hasCrashed) return Expectation.CRASH;
     if (hasTimedOut) return Expectation.TIMEOUT;
 
     // Handle dart2js specific crash detection
     if (exitCode == DART2JS_EXITCODE_CRASH ||
         exitCode == VmCommandOutputImpl.DART_VM_EXITCODE_COMPILE_TIME_ERROR ||
         exitCode == VmCommandOutputImpl.DART_VM_EXITCODE_UNCAUGHT_EXCEPTION) {
@@ skipping 18 matching lines @@
       return Expectation.COMPILETIME_ERROR;
     }
 
     Expectation outcome =
         exitCode == 0 ? Expectation.PASS : Expectation.COMPILETIME_ERROR;
     return _negateOutcomeIfNegativeTest(outcome, testCase.isNegative);
   }
 }
 
 class JsCommandlineOutputImpl extends CommandOutputImpl
-                              with UnittestSuiteMessagesMixin {
+    with UnittestSuiteMessagesMixin {
   JsCommandlineOutputImpl(Command command, int exitCode, bool timedOut,
       List<int> stdout, List<int> stderr, Duration time)
       : super(command, exitCode, timedOut, stdout, stderr, time, false, 0);
 
   Expectation result(TestCase testCase) {
     // Handle crashes and timeouts first
     if (hasCrashed) return Expectation.CRASH;
     if (hasTimedOut) return Expectation.TIMEOUT;
 
     if (testCase.hasRuntimeError) {
       if (exitCode != 0) return Expectation.PASS;
       return Expectation.MISSING_RUNTIME_ERROR;
     }
 
     var outcome = exitCode == 0 ? Expectation.PASS : Expectation.RUNTIME_ERROR;
     outcome = _negateOutcomeIfIncompleteAsyncTest(outcome, decodeUtf8(stdout));
     return _negateOutcomeIfNegativeTest(outcome, testCase.isNegative);
   }
 }
 
 class PubCommandOutputImpl extends CommandOutputImpl {
   PubCommandOutputImpl(PubCommand command, int exitCode, bool timedOut,
       List<int> stdout, List<int> stderr, Duration time)
-  : super(command, exitCode, timedOut, stdout, stderr, time, false, 0);
+      : super(command, exitCode, timedOut, stdout, stderr, time, false, 0);
 
   Expectation result(TestCase testCase) {
     // Handle crashes and timeouts first
     if (hasCrashed) return Expectation.CRASH;
     if (hasTimedOut) return Expectation.TIMEOUT;
 
     if (exitCode == 0) {
       return Expectation.PASS;
     } else if ((command as PubCommand).command == 'get') {
       return Expectation.PUB_GET_ERROR;
     } else {
       return Expectation.FAIL;
     }
   }
 }
 
 class ScriptCommandOutputImpl extends CommandOutputImpl {
   final Expectation _result;
 
   ScriptCommandOutputImpl(ScriptCommand command, this._result,
-                          String scriptExecutionInformation, Duration time)
-  : super(command, 0, false, [], [], time, false, 0) {
+      String scriptExecutionInformation, Duration time)
+      : super(command, 0, false, [], [], time, false, 0) {
     var lines = scriptExecutionInformation.split("\n");
     diagnostics.addAll(lines);
   }
 
   Expectation result(TestCase testCase) => _result;
 
   bool get canRunDependendCommands => _result == Expectation.PASS;
 
   bool get successful => _result == Expectation.PASS;
-
 }
 
-CommandOutput createCommandOutput(Command command,
-                                  int exitCode,
-                                  bool timedOut,
-                                  List<int> stdout,
-                                  List<int> stderr,
-                                  Duration time,
-                                  bool compilationSkipped,
-                                  [int pid = 0]) {
+CommandOutput createCommandOutput(Command command, int exitCode, bool timedOut,
+    List<int> stdout, List<int> stderr, Duration time, bool compilationSkipped,
+    [int pid = 0]) {
   if (command is ContentShellCommand) {
     return new BrowserCommandOutputImpl(
-        command, exitCode, timedOut, stdout, stderr,
-        time, compilationSkipped);
+        command, exitCode, timedOut, stdout, stderr, time, compilationSkipped);
   } else if (command is BrowserTestCommand) {
     return new HTMLBrowserCommandOutputImpl(
-        command, exitCode, timedOut, stdout, stderr,
-        time, compilationSkipped);
+        command, exitCode, timedOut, stdout, stderr, time, compilationSkipped);
   } else if (command is AnalysisCommand) {
     return new AnalysisCommandOutputImpl(
-        command, exitCode, timedOut, stdout, stderr,
-        time, compilationSkipped);
+        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 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(
         command, exitCode, timedOut, stdout, stderr, time);
   } else if (command is PubCommand) {
     return new PubCommandOutputImpl(
         command, exitCode, timedOut, stdout, stderr, time);
   }
 
-  return new CommandOutputImpl(
-      command, exitCode, timedOut, stdout, stderr,
+  return new CommandOutputImpl(command, exitCode, timedOut, stdout, stderr,
       time, compilationSkipped, pid);
 }
 
-
 /**
  * An OutputLog records the output from a test, but truncates it if
  * it is longer than MAX_HEAD characters, and just keeps the head and
  * the last TAIL_LENGTH characters of the output.
  */
 class OutputLog {
   static const int MAX_HEAD = 100 * 1024;
   static const int TAIL_LENGTH = 10 * 1024;
   List<int> head = <int>[];
   List<int> tail;
@@ skipping 14 matching lines @@
       }
     } else {
       tail.addAll(data);
     }
     if (tail != null && tail.length > 2 * TAIL_LENGTH) {
       tail = _truncatedTail();
       dataDropped = true;
     }
   }
 
-  List<int> _truncatedTail() =>
-    tail.length > TAIL_LENGTH ?
-        tail.sublist(tail.length - TAIL_LENGTH) :
-        tail;
+  List<int> _truncatedTail() => tail.length > TAIL_LENGTH
+      ? tail.sublist(tail.length - TAIL_LENGTH)
+      : tail;
 
   List<int> toList() {
     if (complete == null) {
       complete = head;
       if (dataDropped) {
         complete.addAll("""
 
 *****************************************************************************
 
 Data removed due to excessive length
 
 *****************************************************************************
 
-""".codeUnits);
+"""
+            .codeUnits);
         complete.addAll(_truncatedTail());
       } else if (tail != null) {
         complete.addAll(tail);
       }
       head = null;
       tail = null;
     }
     return complete;
   }
 }
@@ skipping 29 matching lines @@
     return completer.future;
   }
 
   void _runCommand() {
     command.outputIsUpToDate.then((bool isUpToDate) {
       if (isUpToDate) {
         compilationSkipped = true;
         _commandComplete(0);
       } else {
         var processEnvironment = _createProcessEnvironment();
-        Future processFuture =
-            io.Process.start(command.executable,
-                             command.arguments,
-                             environment: processEnvironment,
-                             workingDirectory: command.workingDirectory);
+        Future processFuture = io.Process.start(
+            command.executable, command.arguments,
+            environment: processEnvironment,
+            workingDirectory: command.workingDirectory);
         processFuture.then((io.Process process) {
           StreamSubscription stdoutSubscription =
               _drainStream(process.stdout, stdout);
           StreamSubscription stderrSubscription =
               _drainStream(process.stderr, stderr);
 
           var stdoutCompleter = new Completer();
           var stderrCompleter = new Completer();
 
           bool stdoutDone = false;
@@ skipping 45 matching lines @@
                 DebugLogger.warning(
                     "$MAX_STDIO_DELAY_PASSED_MESSAGE (command: $command)");
                 watchdogTimer = null;
                 stdoutSubscription.cancel();
                 stderrSubscription.cancel();
                 closeStdout();
                 closeStderr();
               });
             }
 
-            Future.wait([stdoutCompleter.future,
-                         stderrCompleter.future]).then((_) {
+            Future.wait([stdoutCompleter.future, stderrCompleter.future]).then(
+                (_) {
               _commandComplete(exitCode);
             });
           });
 
-          timeoutTimer = new Timer(new Duration(seconds: timeout),
-                                   timeoutHandler);
+          timeoutTimer =
+              new Timer(new Duration(seconds: timeout), timeoutHandler);
         }).catchError((e) {
           // TODO(floitsch): should we try to report the stacktrace?
           print("Process error:");
           print("  Command: $command");
           print("  Error: $e");
           _commandComplete(-1);
           return true;
         });
       }
     });
@@ skipping 13 matching lines @@
         exitCode,
         timedOut,
         stdout.toList(),
         stderr.toList(),
         new DateTime.now().difference(startTime),
         compilationSkipped,
         pid);
     return commandOutput;
   }
 
-  StreamSubscription _drainStream(Stream<List<int>> source,
-                                  OutputLog destination) {
+  StreamSubscription _drainStream(
+      Stream<List<int>> source, OutputLog destination) {
     return source.listen(destination.add);
   }
 
   Map<String, String> _createProcessEnvironment() {
     var environment = new Map.from(io.Platform.environment);
 
     if (command.environmentOverrides != null) {
       for (var key in command.environmentOverrides.keys) {
         environment[key] = command.environmentOverrides[key];
       }
@@ skipping 23 matching lines @@
   bool _currentlyRunning = false;
   OutputLog _testStdout;
   OutputLog _testStderr;
   String _status;
   DateTime _startTime;
   Timer _timer;
 
   BatchRunnerProcess();
 
   Future<CommandOutput> runCommand(String runnerType, ProcessCommand command,
-                                   int timeout, List<String> arguments) {
+      int timeout, List<String> arguments) {
     assert(_completer == null);
     assert(!_currentlyRunning);
 
     _completer = new Completer<CommandOutput>();
     bool sameRunnerType = _runnerType == runnerType &&
         _dictEquals(_processEnvironmentOverrides, command.environmentOverrides);
     _runnerType = runnerType;
     _currentlyRunning = true;
     _command = command;
     _arguments = arguments;
@@ skipping 33 matching lines @@
     return terminateCompleter.future;
   }
 
   void doStartTest(Command command, int timeout) {
     _startTime = new DateTime.now();
     _testStdout = new OutputLog();
     _testStderr = new OutputLog();
     _status = null;
     _stdoutCompleter = new Completer();
     _stderrCompleter = new Completer();
-    _timer = new Timer(new Duration(seconds: timeout),
-                       _timeoutHandler);
+    _timer = new Timer(new Duration(seconds: timeout), _timeoutHandler);
 
     var line = _createArgumentsLine(_arguments, timeout);
     _process.stdin.write(line);
     _stdoutSubscription.resume();
     _stderrSubscription.resume();
-    Future.wait([_stdoutCompleter.future,
-                 _stderrCompleter.future]).then((_) => _reportResult());
+    Future.wait([_stdoutCompleter.future, _stderrCompleter.future]).then(
+        (_) => _reportResult());
   }
 
   String _createArgumentsLine(List<String> arguments, int timeout) {
     return arguments.join(' ') + '\n';
   }
 
   void _reportResult() {
     if (!_currentlyRunning) return;
     // _status == '>>> TEST {PASS, FAIL, OK, CRASH, FAIL, TIMEOUT}'
 
     var outcome = _status.split(" ")[2];
     var exitCode = 0;
     if (outcome == "CRASH") exitCode = CRASHING_BROWSER_EXITCODE;
     if (outcome == "FAIL" || outcome == "TIMEOUT") exitCode = 1;
-    var output = createCommandOutput(_command,
-                        exitCode,
-                        (outcome == "TIMEOUT"),
-                        _testStdout.toList(),
-                        _testStderr.toList(),
-                        new DateTime.now().difference(_startTime),
-                        false);
+    var output = createCommandOutput(
+        _command,
+        exitCode,
+        (outcome == "TIMEOUT"),
+        _testStdout.toList(),
+        _testStderr.toList(),
+        new DateTime.now().difference(_startTime),
+        false);
     assert(_completer != null);
     _completer.complete(output);
     _completer = null;
     _currentlyRunning = false;
   }
 
   ExitCodeEvent makeExitHandler(String status) {
     void handler(int exitCode) {
       if (_currentlyRunning) {
         if (_timer != null) _timer.cancel();
         _status = status;
         _stdoutSubscription.cancel();
         _stderrSubscription.cancel();
         _startProcess(_reportResult);
-      } else {  // No active test case running.
+      } else {
+        // No active test case running.
         _process = null;
       }
     }
     return handler;
   }
 
   void _timeoutHandler() {
     _processExitHandler = makeExitHandler(">>> TEST TIMEOUT");
     _process.kill();
   }
 
   _startProcess(callback) {
     assert(_command is ProcessCommand);
     var executable = _command.executable;
     var arguments = ['--batch'];
     var environment = new Map.from(io.Platform.environment);
     if (_processEnvironmentOverrides != null) {
       for (var key in _processEnvironmentOverrides.keys) {
         environment[key] = _processEnvironmentOverrides[key];
       }
     }
-    Future processFuture = io.Process.start(executable,
-                                            arguments,
-                                            environment: environment);
+    Future processFuture =
+        io.Process.start(executable, arguments, environment: environment);
     processFuture.then((io.Process p) {
       _process = p;
 
       var _stdoutStream =
-          _process.stdout
-              .transform(UTF8.decoder)
-              .transform(new LineSplitter());
+          _process.stdout.transform(UTF8.decoder).transform(new LineSplitter());
       _stdoutSubscription = _stdoutStream.listen((String line) {
         if (line.startsWith('>>> TEST')) {
           _status = line;
         } else if (line.startsWith('>>> BATCH')) {
           // ignore
         } else if (line.startsWith('>>> ')) {
           throw new Exception("Unexpected command from batch runner: '$line'.");
         } else {
           _testStdout.add(encodeUtf8(line));
           _testStdout.add("\n".codeUnits);
         }
         if (_status != null) {
           _stdoutSubscription.pause();
           _timer.cancel();
           _stdoutCompleter.complete(null);
         }
       });
       _stdoutSubscription.pause();
 
       var _stderrStream =
-          _process.stderr
-              .transform(UTF8.decoder)
-              .transform(new LineSplitter());
+          _process.stderr.transform(UTF8.decoder).transform(new LineSplitter());
       _stderrSubscription = _stderrStream.listen((String line) {
         if (line.startsWith('>>> EOF STDERR')) {
           _stderrSubscription.pause();
           _stderrCompleter.complete(null);
         } else {
           _testStderr.add(encodeUtf8(line));
           _testStderr.add("\n".codeUnits);
         }
       });
       _stderrSubscription.pause();
@@ skipping 26 matching lines @@
   bool _dictEquals(Map a, Map b) {
     if (a == null) return b == null;
     if (b == null) return false;
     for (var key in a.keys) {
       if (a[key] != b[key]) return false;
     }
     return true;
   }
 }
 
-
 /**
  * [TestCaseEnqueuer] takes a list of TestSuites, generates TestCases and
  * builds a dependency graph of all commands in every TestSuite.
  *
  * It will maintain three helper data structures
  *  - command2node: A mapping from a [Command] to a node in the dependency graph
  *  - command2testCases: A mapping from [Command] to all TestCases that it is
  *    part of.
  *  - remainingTestCases: A set of TestCases that were enqueued but are not
  *    finished
@@ skipping 46 matching lines @@
         // We're finished with building the dependency graph.
         graph.sealGraph();
       } else {
         iterator.current.forEachTest(newTest, testCache, enqueueNextSuite);
       }
     }
     enqueueNextSuite();
   }
 }
 
-
 /*
  * [CommandEnqueuer] will
  *  - change node.state to NodeState.Enqueuing as soon as all dependencies have
  *    a state of NodeState.Successful
  *  - change node.state to NodeState.UnableToRun if one or more dependencies
  *    have a state of NodeState.Failed/NodeState.UnableToRun.
  */
 class CommandEnqueuer {
-  static final INIT_STATES = [dgraph.NodeState.Initialized,
-                              dgraph.NodeState.Waiting];
-  static final FINISHED_STATES = [dgraph.NodeState.Successful,
-                                  dgraph.NodeState.Failed,
-                                  dgraph.NodeState.UnableToRun];
+  static final INIT_STATES = [
+    dgraph.NodeState.Initialized,
+    dgraph.NodeState.Waiting
+  ];
+  static final FINISHED_STATES = [
+    dgraph.NodeState.Successful,
+    dgraph.NodeState.Failed,
+    dgraph.NodeState.UnableToRun
+  ];
   final dgraph.Graph _graph;
 
   CommandEnqueuer(this._graph) {
     var eventCondition = _graph.events.where;
 
     eventCondition((e) => e is dgraph.NodeAddedEvent).listen((event) {
       dgraph.Node node = event.node;
       _changeNodeStateIfNecessary(node);
     });
 
     eventCondition((e) => e is dgraph.StateChangedEvent).listen((event) {
-      if ([dgraph.NodeState.Waiting,
-           dgraph.NodeState.Processing].contains(event.from)) {
-        if (FINISHED_STATES.contains(event.to)){
+      if ([dgraph.NodeState.Waiting, dgraph.NodeState.Processing]
+          .contains(event.from)) {
+        if (FINISHED_STATES.contains(event.to)) {
           for (var dependendNode in event.node.neededFor) {
             _changeNodeStateIfNecessary(dependendNode);
           }
         }
       }
     });
   }
 
   // Called when either a new node was added or if one of it's dependencies
   // changed it's state.
   void _changeNodeStateIfNecessary(dgraph.Node node) {
     if (INIT_STATES.contains(node.state)) {
-      bool anyDependenciesUnsuccessful = node.dependencies.any(
-          (dep) => [dgraph.NodeState.Failed,
-                    dgraph.NodeState.UnableToRun].contains(dep.state));
+      bool anyDependenciesUnsuccessful = node.dependencies.any((dep) => [
+            dgraph.NodeState.Failed,
+            dgraph.NodeState.UnableToRun
+          ].contains(dep.state));
 
       var newState = dgraph.NodeState.Waiting;
       if (anyDependenciesUnsuccessful) {
         newState = dgraph.NodeState.UnableToRun;
       } else {
-        bool allDependenciesSuccessful = node.dependencies.every(
-            (dep) => dep.state == dgraph.NodeState.Successful);
+        bool allDependenciesSuccessful = node.dependencies
+            .every((dep) => dep.state == dgraph.NodeState.Successful);
 
         if (allDependenciesSuccessful) {
           newState = dgraph.NodeState.Enqueuing;
         }
       }
       if (node.state != newState) {
         _graph.changeState(node, newState);
       }
     }
   }
@@ skipping 11 matching lines @@
  * It provides a [done] future, which will complete once there are no more
  * nodes left in the states Initialized/Waiting/Enqueing/Processing
  * and the [executor] has cleaned up it's resources.
  */
 class CommandQueue {
   final dgraph.Graph graph;
   final CommandExecutor executor;
   final TestCaseEnqueuer enqueuer;
 
   final Queue<Command> _runQueue = new Queue<Command>();
-  final _commandOutputStream =  new StreamController<CommandOutput>(sync: true);
-  final _completer =  new Completer();
+  final _commandOutputStream = new StreamController<CommandOutput>(sync: true);
+  final _completer = new Completer();
 
   int _numProcesses = 0;
   int _maxProcesses;
   int _numBrowserProcesses = 0;
   int _maxBrowserProcesses;
   bool _finishing = false;
   bool _verbose = false;
 
-  CommandQueue(this.graph, this.enqueuer, this.executor,
-               this._maxProcesses, this._maxBrowserProcesses, this._verbose) {
+  CommandQueue(this.graph, this.enqueuer, this.executor, this._maxProcesses,
+      this._maxBrowserProcesses, this._verbose) {
     var eventCondition = graph.events.where;
     eventCondition((event) => event is dgraph.StateChangedEvent)
         .listen((event) {
-          if (event.to == dgraph.NodeState.Enqueuing) {
-            assert(event.from == dgraph.NodeState.Initialized ||
-                   event.from == dgraph.NodeState.Waiting);
-            graph.changeState(event.node, dgraph.NodeState.Processing);
-            var command = event.node.userData;
-            if (event.node.dependencies.length > 0) {
-              _runQueue.addFirst(command);
-            } else {
-              _runQueue.add(command);
-            }
-            Timer.run(() => _tryRunNextCommand());
-          }
+      if (event.to == dgraph.NodeState.Enqueuing) {
+        assert(event.from == dgraph.NodeState.Initialized ||
+            event.from == dgraph.NodeState.Waiting);
+        graph.changeState(event.node, dgraph.NodeState.Processing);
+        var command = event.node.userData;
+        if (event.node.dependencies.length > 0) {
+          _runQueue.addFirst(command);
+        } else {
+          _runQueue.add(command);
+        }
+        Timer.run(() => _tryRunNextCommand());
+      }
     });
     // We're finished if the graph is sealed and all nodes are in a finished
     // state (Successful, Failed or UnableToRun).
     // So we're calling '_checkDone()' to check whether that condition is met
     // and we can cleanup.
     graph.events.listen((dgraph.GraphEvent event) {
       if (event is dgraph.GraphSealedEvent) {
         _checkDone();
       } else if (event is dgraph.StateChangedEvent) {
         if (event.to == dgraph.NodeState.UnableToRun) {
@@ skipping 23 matching lines @@
       }
 
       _numProcesses++;
       if (isBrowserCommand) _numBrowserProcesses++;
 
       var node = enqueuer.command2node[command];
       Iterable<TestCase> testCases = enqueuer.command2testCases[command];
       // If a command is part of many TestCases we set the timeout to be
       // the maximum over all [TestCase.timeout]s. At some point, we might
       // eliminate [TestCase.timeout] completely and move it to [Command].
-      int timeout = testCases.map((TestCase test) => test.timeout)
-          .fold(0, math.max);
+      int timeout =
+          testCases.map((TestCase test) => test.timeout).fold(0, math.max);
 
       if (_verbose) {
         print('Running "${command.displayName}" command: $command');
       }
 
       executor.runCommand(node, command, timeout).then((CommandOutput output) {
         assert(command == output.command);
 
         _commandOutputStream.add(output);
         if (output.canRunDependendCommands) {
@@ skipping 26 matching lines @@
         _commandOutputStream.close();
       });
     }
   }
 
   void dumpState() {
     print("");
     print("CommandQueue state:");
     print("  Processes: used: $_numProcesses max: $_maxProcesses");
     print("  BrowserProcesses: used: $_numBrowserProcesses "
-          "max: $_maxBrowserProcesses");
+        "max: $_maxBrowserProcesses");
     print("  Finishing: $_finishing");
     print("  Queue (length = ${_runQueue.length}):");
     for (var command in _runQueue) {
       print("      $command");
     }
   }
 }
 
-
 /*
  * [CommandExecutor] is responsible for executing commands. It will make sure
  * that the the following two constraints are satisfied
  *  - [:numberOfProcessesUsed <= maxProcesses:]
  *  - [:numberOfBrowserProcessesUsed <= maxBrowserProcesses:]
  *
  * It provides a [runCommand] method which will complete with a
  * [CommandOutput] object.
  *
  * It provides a [cleanup] method to free all the allocated resources.
@@ skipping 42 matching lines @@
     return Future.wait([_terminateBatchRunners(), _terminateBrowserRunners()]);
   }
 
   Future<CommandOutput> runCommand(node, Command command, int timeout) {
     assert(!_finishing);
 
     Future<CommandOutput> runCommand(int retriesLeft) {
       return _runCommand(command, timeout).then((CommandOutput output) {
         if (retriesLeft > 0 && shouldRetryCommand(output)) {
           DebugLogger.warning("Rerunning Command: ($retriesLeft "
-                              "attempt(s) remains) [cmd: $command]");
+              "attempt(s) remains) [cmd: $command]");
           return runCommand(retriesLeft - 1);
         } else {
           return new Future.value(output);
         }
       });
     }
     return runCommand(command.maxNumRetries);
   }
 
   Future<CommandOutput> _runCommand(Command command, int timeout) {
@@ skipping 30 matching lines @@
       if (!runner._currentlyRunning) return runner;
     }
     throw new Exception('Unable to find inactive batch runner.');
   }
 
   Future<CommandOutput> _startBrowserControllerTest(
       BrowserTestCommand browserCommand, int timeout) {
     var completer = new Completer<CommandOutput>();
 
     var callback = (BrowserTestOutput output) {
-      completer.complete(
-          new BrowserControllerTestOutcome(browserCommand, output));
+      completer
+          .complete(new BrowserControllerTestOutcome(browserCommand, output));
     };
 
     BrowserTest browserTest;
     if (browserCommand is BrowserHtmlTestCommand) {
       browserTest = new HtmlTest(browserCommand.url, callback, timeout,
           browserCommand.expectedMessages);
     } else {
       browserTest = new BrowserTest(browserCommand.url, callback, timeout);
     }
     _getBrowserTestRunner(browserCommand.browser, browserCommand.configuration)
         .then((testRunner) {
       testRunner.enqueueTest(browserTest);
     });
 
     return completer.future;
   }
 
-  Future<BrowserTestRunner> _getBrowserTestRunner(String browser,
-                                                  Map configuration) async {
+  Future<BrowserTestRunner> _getBrowserTestRunner(
+      String browser, Map configuration) async {
     var localIp = globalConfiguration['local_ip'];
     if (_browserTestRunners[configuration] == null) {
       var testRunner = new BrowserTestRunner(
-            configuration, localIp, browser, maxBrowserProcesses);
+          configuration, localIp, browser, maxBrowserProcesses);
       if (globalConfiguration['verbose']) {
         testRunner.logger = DebugLogger.info;
       }
       _browserTestRunners[configuration] = testRunner;
       await testRunner.start();
     }
     return _browserTestRunners[configuration];
   }
 }
 
 class RecordingCommandExecutor implements CommandExecutor {
   TestCaseRecorder _recorder;
 
-  RecordingCommandExecutor(Path path)
-      : _recorder = new TestCaseRecorder(path);
+  RecordingCommandExecutor(Path path) : _recorder = new TestCaseRecorder(path);
 
   Future<CommandOutput> runCommand(node, ProcessCommand command, int timeout) {
     assert(node.dependencies.length == 0);
     assert(_cleanEnvironmentOverrides(command.environmentOverrides));
     _recorder.nextCommand(command, timeout);
     // Return dummy CommandOutput
     var output =
         createCommandOutput(command, 0, false, [], [], const Duration(), false);
     return new Future.value(output);
   }
 
   Future cleanup() {
     _recorder.finish();
     return new Future.value();
   }
 
   // Returns [:true:] if the environment contains only 'DART_CONFIGURATION'
   bool _cleanEnvironmentOverrides(Map environment) {
     if (environment == null) return true;
     return environment.length == 0 ||
         (environment.length == 1 &&
-         environment.containsKey("DART_CONFIGURATION"));
-
+            environment.containsKey("DART_CONFIGURATION"));
   }
 }
 
 class ReplayingCommandExecutor implements CommandExecutor {
   TestCaseOutputArchive _archive = new TestCaseOutputArchive();
 
   ReplayingCommandExecutor(Path path) {
     _archive.loadFromPath(path);
   }
 
@@ skipping 15 matching lines @@
         stderr = decodeUtf8(output.stderr).split("\n");
       }
     }
 
     if (io.Platform.operatingSystem == 'linux') {
       decodeOutput();
       // No matter which command we ran: If we get failures due to the
       // "xvfb-run" issue 7564, try re-running the test.
       bool containsFailureMsg(String line) {
         return line.contains(MESSAGE_CANNOT_OPEN_DISPLAY) ||
-               line.contains(MESSAGE_FAILED_TO_RUN_COMMAND);
+            line.contains(MESSAGE_FAILED_TO_RUN_COMMAND);
       }
       if (stdout.any(containsFailureMsg) || stderr.any(containsFailureMsg)) {
         return true;
       }
     }
 
     // We currently rerun dartium tests, see issue 14074.
     final command = output.command;
     if (command is BrowserTestCommand &&
         command.retry &&
         command.browser == 'dartium') {
       return true;
     }
   }
   return false;
 }
 
 /*
  * [TestCaseCompleter] will listen for
  * NodeState.Processing -> NodeState.{Successful,Failed} state changes and
  * will complete a TestCase if it is finished.
  *
  * It provides a stream [finishedTestCases], which will stream all TestCases
  * once they're finished. After all TestCases are done, the stream will be
  * closed.
  */
 class TestCaseCompleter {
-  static final COMPLETED_STATES = [dgraph.NodeState.Failed,
-                                   dgraph.NodeState.Successful];
+  static final COMPLETED_STATES = [
+    dgraph.NodeState.Failed,
+    dgraph.NodeState.Successful
+  ];
   final dgraph.Graph graph;
   final TestCaseEnqueuer enqueuer;
   final CommandQueue commandQueue;
 
   Map<Command, CommandOutput> _outputs = new Map<Command, CommandOutput>();
   bool _closed = false;
   StreamController<TestCase> _controller = new StreamController<TestCase>();
 
   TestCaseCompleter(this.graph, this.enqueuer, this.commandQueue) {
     var eventCondition = graph.events.where;
     bool finishedRemainingTestCases = false;
 
     // Store all the command outputs -- they will be delivered synchronously
     // (i.e. before state changes in the graph)
     commandQueue.completedCommands.listen((CommandOutput output) {
       _outputs[output.command] = output;
     }, onDone: () {
       _completeTestCasesIfPossible(new List.from(enqueuer.remainingTestCases));
       finishedRemainingTestCases = true;
       assert(enqueuer.remainingTestCases.isEmpty);
       _checkDone();
     });
 
     // Listen for NodeState.Processing -> NodeState.{Successful,Failed}
     // changes.
     eventCondition((event) => event is dgraph.StateChangedEvent)
         .listen((dgraph.StateChangedEvent event) {
-          if (event.from == dgraph.NodeState.Processing &&
-              !finishedRemainingTestCases ) {
-            var command = event.node.userData;
+      if (event.from == dgraph.NodeState.Processing &&
+          !finishedRemainingTestCases) {
+        var command = event.node.userData;
 
-            assert(COMPLETED_STATES.contains(event.to));
-            assert(_outputs[command] != null);
+        assert(COMPLETED_STATES.contains(event.to));
+        assert(_outputs[command] != null);
 
-            _completeTestCasesIfPossible(enqueuer.command2testCases[command]);
-            _checkDone();
-          }
+        _completeTestCasesIfPossible(enqueuer.command2testCases[command]);
+        _checkDone();
+      }
     });
 
     // Listen also for GraphSealedEvent's. If there is not a single node in the
     // graph, we still want to finish after the graph was sealed.
     eventCondition((event) => event is dgraph.GraphSealedEvent)
         .listen((dgraph.GraphSealedEvent event) {
-          if (!_closed && enqueuer.remainingTestCases.isEmpty) {
-            _controller.close();
-            _closed = true;
-          }
+      if (!_closed && enqueuer.remainingTestCases.isEmpty) {
+        _controller.close();
+        _closed = true;
+      }
     });
   }
 
   Stream<TestCase> get finishedTestCases => _controller.stream;
 
   void _checkDone() {
     if (!_closed && graph.isSealed && enqueuer.remainingTestCases.isEmpty) {
       _controller.close();
       _closed = true;
     }
@@ skipping 23 matching lines @@
       // Ask the [testCase] if it's done. Note that we assume, that
       // [TestCase.isFinished] will return true if all commands were executed
       // or if a previous one failed.
       if (testCase.isFinished) {
         completeTestCase(testCase);
       }
     }
   }
 }
 
-
 class ProcessQueue {
   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]) {
+  ProcessQueue(this._globalConfiguration, maxProcesses, maxBrowserProcesses,
+      DateTime startTime, testSuites, this._eventListener, this._allDone,
+      [bool verbose = false,
+      String recordingOutputFile,
+      String recordedInputFile]) {
     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));
+      _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");
+        print("\nGenerating all matching test cases ....\n");
 
-          for (TestCase testCase in testCases) {
-            eventFinishedTestCase(testCase);
-            print("${testCase.displayName}   "
-                  "Expectations: ${testCase.expectedOutcomes.join(', ')}   "
-                  "Configuration: '${testCase.configurationString}'");
-          }
-          eventAllTestsKnown();
-        });
+        for (TestCase testCase in testCases) {
+          eventFinishedTestCase(testCase);
+          print("${testCase.displayName}   "
+              "Expectations: ${testCase.expectedOutcomes.join(', ')}   "
+              "Configuration: '${testCase.configurationString}'");
+        }
+        eventAllTestsKnown();
+      });
     }
 
     var testCaseEnqueuer;
     CommandQueue commandQueue;
 
     void setupForRunning(TestCaseEnqueuer testCaseEnqueuer) {
       Timer _debugTimer;
       // If we haven't seen a single test finishing during a 10 minute period
       // something is definitly wrong, so we dump the debugging information.
       final debugTimerDuration = const Duration(minutes: 10);
 
       void cancelDebugTimer() {
         if (_debugTimer != null) {
           _debugTimer.cancel();
         }
       }
 
       void resetDebugTimer() {
         cancelDebugTimer();
         _debugTimer = new Timer(debugTimerDuration, () {
           print("The debug timer of test.dart expired. Please report this issue"
-                " to ricow/whesse and provide the following information:");
+              " to ricow/whesse and provide the following information:");
           print("");
           print("Graph is sealed: ${_graph.isSealed}");
           print("");
           _graph.DumpCounts();
           print("");
           var unfinishedNodeStates = [
-              dgraph.NodeState.Initialized,
-              dgraph.NodeState.Waiting,
-              dgraph.NodeState.Enqueuing,
-              dgraph.NodeState.Processing];
+            dgraph.NodeState.Initialized,
+            dgraph.NodeState.Waiting,
+            dgraph.NodeState.Enqueuing,
+            dgraph.NodeState.Processing
+          ];
 
           for (var nodeState in unfinishedNodeStates) {
             if (_graph.stateCount(nodeState) > 0) {
               print("Commands in state '$nodeState':");
               print("=================================");
               print("");
               for (var node in _graph.nodes) {
                 if (node.state == nodeState) {
                   var command = node.userData;
                   var testCases = testCaseEnqueuer.command2testCases[command];
                   print("  Command: $command");
                   for (var testCase in testCases) {
                     print("    Enqueued by: ${testCase.configurationString} "
-                          "-- ${testCase.displayName}");
+                        "-- ${testCase.displayName}");
                   }
                   print("");
                 }
               }
               print("");
               print("");
             }
           }
 
           if (commandQueue != null) {
             commandQueue.dumpState();
           }
         });
       }
 
       bool recording = recordingOutputFile != null;
       bool replaying = recordedInputFile != null;
 
       // When the graph building is finished, notify event listeners.
       _graph.events
-        .where((event) => event is dgraph.GraphSealedEvent).listen((event) {
-          eventAllTestsKnown();
-        });
+          .where((event) => event is dgraph.GraphSealedEvent)
+          .listen((event) {
+        eventAllTestsKnown();
+      });
 
       // Queue commands as they become "runnable"
       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);
       }
 
       // Run "runnable commands" using [executor] subject to
       // maxProcesses/maxBrowserProcesses constraint
-      commandQueue = new CommandQueue(
-          _graph, testCaseEnqueuer, executor, maxProcesses, maxBrowserProcesses,
-          verbose);
+      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);
-      testCaseCompleter.finishedTestCases.listen(
-          (TestCase finishedTestCase) {
-            resetDebugTimer();
+      testCaseCompleter.finishedTestCases.listen((TestCase finishedTestCase) {
+        resetDebugTimer();
 
-            // If we're recording, we don't report any TestCases to listeners.
-            if (!recording) {
-              eventFinishedTestCase(finishedTestCase);
-            }
-          },
-          onDone: () {
-            // Wait until the commandQueue/execturo is done (it may need to stop
-            // batch runners, browser controllers, ....)
-            commandQueue.done.then((_) {
-              cancelDebugTimer();
-              eventAllTestsDone();
-            });
-          });
+        // If we're recording, we don't report any TestCases to listeners.
+        if (!recording) {
+          eventFinishedTestCase(finishedTestCase);
+        }
+      }, onDone: () {
+        // Wait until the commandQueue/execturo is done (it may need to stop
+        // batch runners, browser controllers, ....)
+        commandQueue.done.then((_) {
+          cancelDebugTimer();
+          eventAllTestsDone();
+        });
+      });
 
       resetDebugTimer();
     }
 
     // Build up the dependency graph
     testCaseEnqueuer = new TestCaseEnqueuer(_graph, (TestCase newTestCase) {
       eventTestAdded(newTestCase);
     });
 
     // Either list or run the tests
@@ skipping 30 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
     _allDone();
   }
 }