Avoid random stacktraces being printed from tools/test.py during test runs

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 1836 matching lines @@
  */
 class RunningProcess {
   ProcessCommand command;
   int timeout;
   bool timedOut = false;
   DateTime startTime;
   Timer timeoutTimer;
   int pid;
   OutputLog stdout = new OutputLog();
   OutputLog stderr = new OutputLog();
+  List<String> diagnostics = <String>[];
   bool compilationSkipped = false;
   Completer<CommandOutput> completer;
 
   RunningProcess(this.command, this.timeout);
 
   Future<CommandOutput> run() {
     completer = new Completer<CommandOutput>();
     startTime = new DateTime.now();
     _runCommand();
     return completer.future;
@@ skipping 43 matching lines @@
               stderrDone = true;
 
               if (stdoutDone && watchdogTimer != null) {
                 watchdogTimer.cancel();
               }
             }
           }
 
           // Close stdin so that tests that try to block on input will fail.
           process.stdin.close();
-          void timeoutHandler() {
+          timeoutHandler() async {
             timedOut = true;
             if (process != null) {
+              var executable, arguments;
               if (io.Platform.isLinux) {
-                // Try to print stack traces of the timed out process.
-                io.Process.run('eu-stack', ['-p ${process.pid}'])
-                .then((result) {
-                  io.stdout.write(result.stdout);
-                  io.stderr.write(result.stderr);
-                })
-                .catchError(
-                    (error) => print("Error when printing stack trace: $error"))
-                .whenComplete(() {
-                  if (!process.kill()) {
-                    DebugLogger.error("Unable to kill ${process.pid}");
-                  }
-                });
+                executable = 'eu-stack';
+                arguments = ['-p ${process.pid}'];
               } 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.
-                io.Process.run('/usr/bin/sample',
-                               ['${process.pid}', '1', '4000', '-mayDie'])
-                .then((result) {
-                  io.stdout.write(result.stdout);
-                  io.stderr.write(result.stderr);
-                })
-                .catchError(
-                    (error) => print("Error when printing stack trace: $error"))
-                .whenComplete(() {
-                  if (!process.kill()) {
-                    DebugLogger.error("Unable to kill ${process.pid}");
-                  }
-                });
-              } else {
-                if (!process.kill()) {
-                  DebugLogger.error("Unable to kill ${process.pid}");
+                executable = '/usr/bin/sample';
+                arguments = ['${process.pid}', '1', '4000', '-mayDie'];
+              }
+
+              if (executable != null) {
+                try {
+                  var result = await io.Process.run(executable, arguments);
+                  diagnostics.addAll(result.stdout.split('\n'));
+                  diagnostics.addAll(result.stderr.split('\n'));
+                } catch (error) {
+                  diagnostics.add("Unable to capture stack traces: $error");
                 }
               }
+
+              if (!process.kill()) {
+                diagnostics.add("Unable to kill ${process.pid}");
+              }
             }
           }
 
           stdoutSubscription.asFuture().then(closeStdout);
           stderrSubscription.asFuture().then(closeStderr);
 
           process.exitCode.then((exitCode) {
             if (!stdoutDone || !stderrDone) {
               watchdogTimer = new Timer(MAX_STDIO_DELAY, () {
                 DebugLogger.warning(
@@ skipping 37 matching lines @@
   CommandOutput _createCommandOutput(ProcessCommand command, int exitCode) {
     var commandOutput = createCommandOutput(
         command,
         exitCode,
         timedOut,
         stdout.toList(),
         stderr.toList(),
         new DateTime.now().difference(startTime),
         compilationSkipped,
         pid);
+    commandOutput.diagnostics.addAll(diagnostics);
     return commandOutput;
   }
 
   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);
@@ skipping 1122 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
     _allDone();
   }
 }