Format all files under tools and utils directory.

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 218 matching lines @@
 class KernelCompilationCommand extends CompilationCommand {
   KernelCompilationCommand._(
       String displayName,
       String outputFile,
       bool neverSkipCompilation,
       List<Uri> bootstrapDependencies,
       String executable,
       List<String> arguments,
       Map<String, String> environmentOverrides)
       : super._(displayName, outputFile, neverSkipCompilation,
-                bootstrapDependencies, executable, arguments,
-                environmentOverrides);
+            bootstrapDependencies, executable, arguments, environmentOverrides);
 
   int get maxNumRetries => 1;
 }
 
 /// 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
@@ skipping 116 matching lines @@
   VmCommand._(String executable, List<String> arguments,
       Map<String, String> environmentOverrides)
       : super._("vm", executable, arguments, environmentOverrides);
 }
 
 class VmBatchCommand extends ProcessCommand implements VmCommand {
   final String dartFile;
   final bool checked;
 
   VmBatchCommand._(String executable, String dartFile, List<String> arguments,
-      Map<String, String> environmentOverrides, {this.checked: true})
+      Map<String, String> environmentOverrides,
+      {this.checked: true})
       : this.dartFile = dartFile,
         super._('vm-batch', executable, arguments, environmentOverrides);
 
   @override
-  List<String> get batchArguments => checked
-      ? ['--checked', dartFile]
-      : [dartFile];
+  List<String> get batchArguments =>
+      checked ? ['--checked', dartFile] : [dartFile];
 
   @override
   bool _equal(VmBatchCommand other) {
     return super._equal(other) &&
         dartFile == other.dartFile &&
         checked == other.checked;
   }
 
   @override
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
     builder.addJson(dartFile);
     builder.addJson(checked);
   }
 }
 
 class AdbPrecompilationCommand extends Command {
   final String precompiledRunnerFilename;
   final String processTestFilename;
   final String precompiledTestDirectory;
   final List<String> arguments;
   final bool useBlobs;
 
-  AdbPrecompilationCommand._(this.precompiledRunnerFilename,
-                             this.processTestFilename,
-                             this.precompiledTestDirectory,
-                             this.arguments,
-                             this.useBlobs)
+  AdbPrecompilationCommand._(
+      this.precompiledRunnerFilename,
+      this.processTestFilename,
+      this.precompiledTestDirectory,
+      this.arguments,
+      this.useBlobs)
       : super._("adb_precompilation");
 
   void _buildHashCode(HashCodeBuilder builder) {
     super._buildHashCode(builder);
     builder.add(precompiledRunnerFilename);
     builder.add(precompiledTestDirectory);
     builder.add(arguments);
     builder.add(useBlobs);
   }
 
@@ skipping 218 matching lines @@
 
   VmCommand getVmCommand(String executable, List<String> arguments,
       Map<String, String> environmentOverrides) {
     var command = new VmCommand._(executable, arguments, environmentOverrides);
     return _getUniqueCommand(command);
   }
 
   VmBatchCommand getVmBatchCommand(String executable, String tester,
       List<String> arguments, Map<String, String> environmentOverrides,
       {bool checked: true}) {
-    var command =
-        new VmBatchCommand._(executable, tester, arguments, environmentOverrides,
-            checked: checked);
+    var command = new VmBatchCommand._(
+        executable, tester, arguments, environmentOverrides,
+        checked: checked);
     return _getUniqueCommand(command);
   }
 
-  AdbPrecompilationCommand getAdbPrecompiledCommand(String precompiledRunner,
-                                                    String processTest,
-                                                    String testDirectory,
-                                                    List<String> arguments,
-                                                    bool useBlobs) {
+  AdbPrecompilationCommand getAdbPrecompiledCommand(
+      String precompiledRunner,
+      String processTest,
+      String testDirectory,
+      List<String> arguments,
+      bool useBlobs) {
     var command = new AdbPrecompilationCommand._(
         precompiledRunner, processTest, testDirectory, arguments, useBlobs);
     return _getUniqueCommand(command);
   }
 
   Command getJSCommandlineCommand(String displayName, executable, arguments,
       [environment = null]) {
     var command = new JSCommandlineCommand._(
         displayName, executable, arguments, environment);
     return _getUniqueCommand(command);
   }
 
   Command getProcessCommand(String displayName, executable, arguments,
       [environment = null, workingDirectory = null]) {
     var command = new ProcessCommand._(
         displayName, executable, arguments, environment, workingDirectory);
     return _getUniqueCommand(command);
   }
 
   Command getCopyCommand(String sourceDirectory, String destinationDirectory) {
     var command =
         new CleanDirectoryCopyCommand._(sourceDirectory, destinationDirectory);
     return _getUniqueCommand(command);
   }
 
   Command getPubCommand(String pubCommand, String pubExecutable,
       String pubspecYamlDirectory, String pubCacheDirectory,
       {List<String> arguments: const <String>[]}) {
-    var command = new PubCommand._(
-        pubCommand, pubExecutable, pubspecYamlDirectory, pubCacheDirectory,
-        arguments);
+    var command = new PubCommand._(pubCommand, pubExecutable,
+        pubspecYamlDirectory, pubCacheDirectory, arguments);
     return _getUniqueCommand(command);
   }
 
   Command getMakeSymlinkCommand(String link, String target) {
     return _getUniqueCommand(new MakeSymlinkCommand._(link, target));
   }
 
   Command _getUniqueCommand(Command command) {
     // All Command classes implement hashCode and operator==.
     // We check if this command has already been built.
@@ skipping 900 matching lines @@
     }
 
     Expectation outcome =
         exitCode == 0 ? Expectation.PASS : Expectation.COMPILETIME_ERROR;
     return _negateOutcomeIfNegativeTest(outcome, testCase.isNegative);
   }
 }
 
 class KernelCompilationCommandOutputImpl extends CompilationCommandOutputImpl {
   KernelCompilationCommandOutputImpl(
-      Command command, int exitCode, bool timedOut,
-      List<int> stdout, List<int> stderr,
-      Duration time, bool compilationSkipped)
+      Command command,
+      int exitCode,
+      bool timedOut,
+      List<int> stdout,
+      List<int> stderr,
+      Duration time,
+      bool compilationSkipped)
       : super(command, exitCode, timedOut, stdout, stderr, time,
-              compilationSkipped);
+            compilationSkipped);
 
   bool get canRunDependendCommands {
     // See [BatchRunnerProcess]: 0 means success, 1 means compile-time error.
     // TODO(asgerf): When the frontend supports it, continue running even if
     //   there were compile-time errors. See kernel_sdk issue #18.
     return !hasCrashed && !timedOut && exitCode == 0;
   }
 
   Expectation result(TestCase testCase) {
     Expectation result = super.result(testCase);
@@ skipping 149 matching lines @@
     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;
 
-
   void _checkUtf8(List<int> data) {
     try {
       UTF8.decode(data, allowMalformed: false);
     } on FormatException catch (e) {
       hasNonUtf8 = true;
       String malformed = UTF8.decode(data, allowMalformed: true);
-      data..clear()
-          ..addAll(UTF8.encode(malformed))
-          ..addAll("""
+      data
+        ..clear()
+        ..addAll(UTF8.encode(malformed))
+        ..addAll("""
 
   *****************************************************************************
 
   test.dart: The output of this test contained non-UTF8 formatted data.
 
   *****************************************************************************
 
   """
-          .codeUnits);
+            .codeUnits);
     }
   }
 
-
   List<int> toList() {
     if (complete == null) {
       complete = head;
       if (dataDropped) {
         complete.addAll("""
 
 *****************************************************************************
 
 test.dart: Data was removed due to excessive length
 
@@ skipping 13 matching lines @@
   }
 }
 
 // Helper to get a list of all child pids for a parent process.
 // The first element of the list is the parent pid.
 Future<List<int>> _getPidList(pid, diagnostics) async {
   var pid_list = [pid];
   var lines;
   var start_line = 0;
   if (io.Platform.isLinux || io.Platform.isMacOS) {
-    var result = await io.Process.run("pgrep",
-        ["-P", "${pid_list[0]}"],
-        runInShell: true);
+    var result = await io.Process
+        .run("pgrep", ["-P", "${pid_list[0]}"], runInShell: true);
     lines = result.stdout.split('\n');
   } else if (io.Platform.isWindows) {
-    var result = await io.Process.run("wmic",
-        ["process", "where" , "(ParentProcessId=${pid_list[0]})",
-         "get", "ProcessId"],
+    var result = await io.Process.run(
+        "wmic",
+        [
+          "process",
+          "where",
+          "(ParentProcessId=${pid_list[0]})",
+          "get",
+          "ProcessId"
+        ],
         runInShell: true);
     lines = result.stdout.split('\n');
     // Skip first line containing header "ProcessId".
     start_line = 1;
   } else {
     assert(false);
   }
   if (lines.length > start_line) {
     for (int i = start_line; i < lines.length; ++i) {
       var pid = int.parse(lines[i], onError: (source) => null);
@@ skipping 23 matching lines @@
   DateTime startTime;
   Timer timeoutTimer;
   int pid;
   OutputLog stdout = new OutputLog();
   OutputLog stderr = new OutputLog();
   List<String> diagnostics = <String>[];
   bool compilationSkipped = false;
   Completer<CommandOutput> completer;
   Map configuration;
 
-  RunningProcess(this.command,
-                 this.timeout,
-                 {this.configuration});
+  RunningProcess(this.command, this.timeout, {this.configuration});
 
   Future<CommandOutput> run() {
     completer = new Completer<CommandOutput>();
     startTime = new DateTime.now();
     _runCommand();
     return completer.future;
   }
 
   void _runCommand() {
     command.outputIsUpToDate.then((bool isUpToDate) {
       if (isUpToDate) {
         compilationSkipped = true;
         _commandComplete(0);
       } else {
         var processEnvironment = _createProcessEnvironment();
         var args = command.arguments;
-        Future processFuture = io.Process.start(
-            command.executable, args,
+        Future processFuture = io.Process.start(command.executable, args,
             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;
           bool stderrDone = false;
           pid = process.pid;
 
           // This timer is used to close stdio to the subprocess once we got
           // the exitCode. Sometimes descendants of the subprocess keep stdio
           // handles alive even though the direct subprocess is dead.
           Timer watchdogTimer;
 
           closeStdout([_]) {
             if (!stdoutDone) {
               stdoutCompleter.complete();
               stdoutDone = true;
               if (stderrDone && watchdogTimer != null) {
                 watchdogTimer.cancel();
               }
             }
           }
+
           closeStderr([_]) {
             if (!stderrDone) {
               stderrCompleter.complete();
               stderrDone = true;
 
               if (stdoutDone && watchdogTimer != null) {
                 watchdogTimer.cancel();
               }
             }
           }
 
           // Close stdin so that tests that try to block on input will fail.
           process.stdin.close();
           timeoutHandler() async {
             timedOut = true;
             if (process != null) {
               var executable;
               if (io.Platform.isLinux) {
                 executable = 'eu-stack';
               } else if (io.Platform.isMacOS) {
                 // Try to print stack traces of the timed out process.
                 // `sample` is a sampling profiler but we ask it sample for 1
                 // second with a 4 second delay between samples so that we only
                 // sample the threads once.
                 executable = '/usr/bin/sample';
               } else if (io.Platform.isWindows) {
                 bool is_x64 = command.executable.contains("X64") ||
-                              command.executable.contains("SIMARM64");
+                    command.executable.contains("SIMARM64");
                 var win_sdk_path = configuration['win_sdk_path'];
                 if (win_sdk_path != null) {
                   executable = win_sdk_path +
-                      "\\Debuggers\\" + (is_x64 ? "x64" : "x86") + "\\cdb.exe";
+                      "\\Debuggers\\" +
+                      (is_x64 ? "x64" : "x86") +
+                      "\\cdb.exe";
                   diagnostics.add("Using $executable to print stack traces");
                 } else {
                   diagnostics.add("win_sdk path not found");
                 }
               } else {
                 diagnostics.add("Capturing stack traces on"
-                                "${io.Platform.operatingSystem} not supported");
+                    "${io.Platform.operatingSystem} not supported");
               }
               if (executable != null) {
                 var pid_list = await _getPidList(process.pid, diagnostics);
                 diagnostics.add("Process list including children: $pid_list");
                 for (pid in pid_list) {
                   var arguments;
                   if (io.Platform.isLinux) {
                     arguments = ['-p $pid'];
                   } else if (io.Platform.isMacOS) {
                     arguments = ['$pid', '1', '4000', '-mayDie'];
@@ skipping 100 matching lines @@
       }
     }
     for (var excludedEnvironmentVariable in EXCLUDED_ENVIRONMENT_VARIABLES) {
       environment.remove(excludedEnvironmentVariable);
     }
 
     return environment;
   }
 }
 
-class BatchRunnerProcess  {
+class BatchRunnerProcess {
   Completer<CommandOutput> _completer;
   ProcessCommand _command;
   List<String> _arguments;
   String _runnerType;
 
   io.Process _process;
   Map _processEnvironmentOverrides;
   Completer _stdoutCompleter;
   Completer _stderrCompleter;
   StreamSubscription<String> _stdoutSubscription;
@@ skipping 104 matching lines @@
         if (_timer != null) _timer.cancel();
         _status = status;
         _stdoutSubscription.cancel();
         _stderrSubscription.cancel();
         _startProcess(_reportResult);
       } 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 = []..addAll(_command.batchArguments)..add('--batch');
+    var arguments = []
+      ..addAll(_command.batchArguments)
+      ..add('--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);
     processFuture.then((io.Process p) {
       _process = p;
@@ skipping 122 matching lines @@
 
     Iterator<TestSuite> iterator = testSuites.iterator;
     void enqueueNextSuite() {
       if (!iterator.moveNext()) {
         // 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.
@@ skipping 270 matching lines @@
       return _runCommand(command, timeout).then((CommandOutput output) {
         if (retriesLeft > 0 && shouldRetryCommand(output)) {
           DebugLogger.warning("Rerunning Command: ($retriesLeft "
               "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) {
     var batchMode = !globalConfiguration['noBatch'];
     var dart2jsBatchMode = globalConfiguration['dart2js_batch'];
 
     if (command is BrowserTestCommand) {
       return _startBrowserControllerTest(command, timeout);
     } else if (command is KernelCompilationCommand) {
@@ skipping 16 matching lines @@
         return _runAdbPrecompilationCommand(device, command, timeout)
             .whenComplete(() {
           adbDevicePool.releaseDevice(device);
         });
       });
     } else if (command is VmBatchCommand) {
       var name = command.displayName;
       return _getBatchRunner(command.displayName + command.dartFile)
           .runCommand(name, command, timeout, command.arguments);
     } else {
-      return new RunningProcess(
-          command, timeout, configuration: globalConfiguration).run();
+      return new RunningProcess(command, timeout,
+              configuration: globalConfiguration)
+          .run();
     }
   }
 
   Future<CommandOutput> _runAdbPrecompilationCommand(
       AdbDevice device, AdbPrecompilationCommand command, int timeout) async {
     var runner = command.precompiledRunnerFilename;
     var processTest = command.processTestFilename;
     var testdir = command.precompiledTestDirectory;
     var arguments = command.arguments;
     var devicedir = DartPrecompiledAdbRuntimeConfiguration.DeviceDir;
     var deviceTestDir = DartPrecompiledAdbRuntimeConfiguration.DeviceTestDir;
 
     // We copy all the files which the vm precompiler puts into the test
     // directory.
     List<String> files = new io.Directory(testdir)
         .listSync()
         .map((file) => file.path)
         .map((path) => path.substring(path.lastIndexOf('/') + 1))
         .toList();
 
     var timeoutDuration = new Duration(seconds: timeout);
 
     // All closures are of type "Future<AdbCommandResult> run()"
     List<Function> steps = [];
 
     steps.add(() => device.runAdbShellCommand(['rm', '-Rf', deviceTestDir]));
     steps.add(() => device.runAdbShellCommand(['mkdir', '-p', deviceTestDir]));
-    steps.add(() => device.pushCachedData(runner,
-                                          '$devicedir/dart_precompiled_runtime'));
-    steps.add(() => device.pushCachedData(processTest,
-                                          '$devicedir/process_test'));
-    steps.add(() => device.runAdbShellCommand(
-        ['chmod', '777', '$devicedir/dart_precompiled_runtime $devicedir/process_test']));
+    steps.add(() =>
+        device.pushCachedData(runner, '$devicedir/dart_precompiled_runtime'));
+    steps.add(
+        () => device.pushCachedData(processTest, '$devicedir/process_test'));
+    steps.add(() => device.runAdbShellCommand([
+          'chmod',
+          '777',
+          '$devicedir/dart_precompiled_runtime $devicedir/process_test'
+        ]));
 
     for (var file in files) {
       steps.add(() => device
           .runAdbCommand(['push', '$testdir/$file', '$deviceTestDir/$file']));
     }
 
     steps.add(() => device.runAdbShellCommand(
         [
           '$devicedir/dart_precompiled_runtime',
         ]..addAll(arguments),
@@ skipping 168 matching lines @@
     }
 
     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);
       }
+
       if (stdout.any(containsFailureMsg) || stderr.any(containsFailureMsg)) {
         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
@@ skipping 278 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
     _allDone();
   }
 }