Reapply "Update the test runner to use the new dart:io API"

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 658 matching lines @@
      *     #EOF\n
      * So we need to get the byte-range of the png data first, before
      * comparing it with the content of the expected output file.
      *
      * On a layout tests, the DRT output is directly compared with the
      * content of the expected output.
      */
     var stdout = testCase.commandOutputs[command].stdout;
     var file = new io.File.fromPath(command.expectedOutputFile);
     if (file.existsSync()) {
-      var bytesContentLength = "Content-Length:".charCodes;
-      var bytesNewLine = "\n".charCodes;
-      var bytesEOF = "#EOF\n".charCodes;
+      var bytesContentLength = "Content-Length:".codeUnits;
+      var bytesNewLine = "\n".codeUnits;
+      var bytesEOF = "#EOF\n".codeUnits;
 
       var expectedContent = file.readAsBytesSync();
       if (command.isPixelTest) {
         var startOfContentLength = findBytes(stdout, bytesContentLength);
         if (startOfContentLength >= 0) {
           var newLineAfterContentLength = findBytes(stdout,
                                                     bytesNewLine,
                                                     startOfContentLength);
           if (newLineAfterContentLength > 0) {
             var startPosition = newLineAfterContentLength +
@@ skipping 210 matching lines @@
     bool escaped = false;
     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.clear();
+        field = new StringBuffer();
         continue;
       }
-      field.add(c);
+      field.write(c);
     }
     result.add(field.toString());
     return result;
   }
 }
 
 /**
  * A RunningProcess actually runs a test, getting the command lines from
  * its [TestCase], starting the test process (and first, a compilation
  * process if the TestCase is a [BrowserTestCase]), creating a timeout
  * timer, and recording the results in a new [CommandOutput] object, which it
  * attaches to the TestCase.  The lifetime of the RunningProcess is limited
  * to the time it takes to start the process, run the process, and record
  * the result; there are no pointers to it, so it should be available to
  * be garbage collected as soon as it is done.
  */
 class RunningProcess {
   TestCase testCase;
   Command command;
   bool timedOut = false;
-  Date startTime;
+  DateTime startTime;
   Timer timeoutTimer;
   List<int> stdout = <int>[];
   List<int> stderr = <int>[];
   bool compilationSkipped = false;
   Completer<CommandOutput> completer;
 
   RunningProcess(TestCase this.testCase, Command this.command);
 
   Future<CommandOutput> start() {
     Expect.isFalse(testCase.expectedOutcomes.contains(SKIP));
 
     completer = new Completer<CommandOutput>();
-    startTime = new Date.now();
+    startTime = new DateTime.now();
     _runCommand();
     return completer.future;
   }
 
   void _runCommand() {
     command.outputIsUpToDate.then((bool isUpToDate) {
       if (isUpToDate) {
         compilationSkipped = true;
         _commandComplete(0);
       } else {
         var processOptions = _createProcessOptions();
         Future processFuture = io.Process.start(command.executable,
                                                 command.arguments,
                                                 processOptions);
         processFuture.then((io.Process process) {
-          void timeoutHandler(_) {
+          void timeoutHandler() {
             timedOut = true;
             if (process != null) {
               process.kill();
             }
           }
-          process.onExit = _commandComplete;
+          process.exitCode.then(_commandComplete);
           _drainStream(process.stdout, stdout);
           _drainStream(process.stderr, stderr);
-          timeoutTimer = new Timer(1000 * testCase.timeout, timeoutHandler);
+          timeoutTimer = new Timer(new Duration(seconds: testCase.timeout),
+                                   timeoutHandler);
         }).catchError((e) {
           print("Process error:");
           print("  Command: $command");
           print("  Error: $e");
           _commandComplete(-1);
           return true;
         });
       }
     });
   }
 
   void _commandComplete(int exitCode) {
     if (timeoutTimer != null) {
       timeoutTimer.cancel();
     }
     var commandOutput = _createCommandOutput(command, exitCode);
     completer.complete(commandOutput);
   }
 
   CommandOutput _createCommandOutput(Command command, int exitCode) {
     var incomplete = command != testCase.commands.last;
     var commandOutput = new CommandOutput.fromCase(
         testCase,
         command,
         exitCode,
         incomplete,
         timedOut,
         stdout,
         stderr,
-        new Date.now().difference(startTime),
+        new DateTime.now().difference(startTime),
         compilationSkipped);
     return commandOutput;
   }
 
-  void _drainStream(io.InputStream source, List<int> destination) {
-    void onDataHandler () {
-      if (source.closed) {
-        return;  // TODO(whesse): Remove when bug is fixed.
-      }
-      var data = source.read();
-      while (data != null) {
-        destination.addAll(data);
-        data = source.read();
-      }
-    }
-    source.onData = onDataHandler;
-    source.onClosed = onDataHandler;
+  void _drainStream(Stream<List<int>> source, List<int> destination) {
+    source.listen(destination.addAll);
   }
 
   io.ProcessOptions _createProcessOptions() {
     var baseEnvironment = command.environment != null ?
         command.environment : io.Platform.environment;
     io.ProcessOptions options = new io.ProcessOptions();
     options.environment = new Map<String, String>.from(baseEnvironment);
     options.environment['DART_CONFIGURATION'] =
         TestUtils.configurationDir(testCase.configuration);
     return options;
   }
 }
 
-/**
- * This class holds a value, that can be changed.  It is used when
- * closures need a shared value, that they can all change and read.
- */
-class MutableValue<T> {
-  MutableValue(T this.value);
-  T value;
-}
-
 class BatchRunnerProcess {
   Command _command;
   String _executable;
   List<String> _batchArguments;
 
   io.Process _process;
-  io.StringInputStream _stdoutStream;
-  io.StringInputStream _stderrStream;
+  Completer _stdoutCompleter;
+  Completer _stderrCompleter;
+  StreamSubscription<String> _stdoutSubscription;
+  StreamSubscription<String> _stderrSubscription;
+  Function _processExitHandler;
 
   TestCase _currentTest;
   List<int> _testStdout;
   List<int> _testStderr;
   String _status;
-  bool _stdoutDrained = false;
-  bool _stderrDrained = false;
-  MutableValue<bool> _ignoreStreams;
-  Date _startTime;
+  DateTime _startTime;
   Timer _timer;
 
   bool _isWebDriver;
 
   BatchRunnerProcess(TestCase testCase) {
     _command = testCase.commands.last;
     _executable = testCase.commands.last.executable;
     _batchArguments = testCase.batchRunnerArguments;
     _isWebDriver = testCase.usesWebDriver;
   }
 
   bool get active => _currentTest != null;
 
   void startTest(TestCase testCase) {
     Expect.isNull(_currentTest);
     _currentTest = testCase;
     _command = testCase.commands.last;
     if (_process == null) {
       // Start process if not yet started.
       _executable = testCase.commands.last.executable;
       _startProcess(() {
         doStartTest(testCase);
       });
     } else if (testCase.commands.last.executable != _executable) {
       // Restart this runner with the right executable for this test
       // if needed.
       _executable = testCase.commands.last.executable;
       _batchArguments = testCase.batchRunnerArguments;
-      _process.onExit = (exitCode) {
+      _processExitHandler = (_) {
         _startProcess(() {
           doStartTest(testCase);
         });
       };
       _process.kill();
     } else {
       doStartTest(testCase);
     }
   }
 
   Future terminate() {
     if (_process == null) return new Future.immediate(true);
     Completer completer = new Completer();
     Timer killTimer;
-    _process.onExit = (exitCode) {
+    _processExitHandler = (_) {
       if (killTimer != null) killTimer.cancel();
       completer.complete(true);
     };
     if (_isWebDriver) {
       // Use a graceful shutdown so our Selenium script can close
       // the open browser processes. On Windows, signals do not exist
       // and a kill is a hard kill.
-      _process.stdin.write('--terminate\n'.charCodes);
+      _process.stdin.writeln('--terminate');
 
       // In case the run_selenium process didn't close, kill it after 30s
-      int shutdownMillisecs = 30000;
-      killTimer = new Timer(shutdownMillisecs, (e) { _process.kill(); });
+      killTimer = new Timer(new Duration(seconds: 30), _process.kill);
     } else {
       _process.kill();
     }
 
     return completer.future;
   }
 
   void doStartTest(TestCase testCase) {
-    _startTime = new Date.now();
+    _startTime = new DateTime.now();
     _testStdout = [];
     _testStderr = [];
     _status = null;
-    _stdoutDrained = false;
-    _stderrDrained = false;
-    _ignoreStreams = new MutableValue<bool>(false);  // Captured by closures.
-    _readStdout(_stdoutStream, _testStdout);
-    _readStderr(_stderrStream, _testStderr);
-    _timer = new Timer(testCase.timeout * 1000, _timeoutHandler);
+    _stdoutCompleter = new Completer();
+    _stderrCompleter = new Completer();
+    _timer = new Timer(new Duration(seconds: testCase.timeout),
+                       _timeoutHandler);
 
     if (testCase.commands.last.environment != null) {
       print("Warning: command.environment != null, but we don't support custom "
             "environments for batch runner tests!");
     }
 
     var line = _createArgumentsLine(testCase.batchTestArguments);
-    _process.stdin.onError = (err) {
-      print('Error on batch runner input stream stdin');
-      print('  Input line: $line');
-      print('  Previous test\'s status: $_status');
-      print('  Error: $err');
-      throw err;
-    };
-    _process.stdin.write(line.charCodes);
+    _process.stdin.write(line);
+    _stdoutSubscription.resume();
+    _stderrSubscription.resume();
+    Future.wait([_stdoutCompleter.future,
+                 _stderrCompleter.future]).then((_) => _reportResult());
   }
 
   String _createArgumentsLine(List<String> arguments) {
     return arguments.join(' ').concat('\n');
   }
 
   void _reportResult() {
     if (!active) 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;
     new CommandOutput.fromCase(_currentTest,
                                _command,
                                exitCode,
                                false,
                                (outcome == "TIMEOUT"),
                                _testStdout,
                                _testStderr,
-                               new Date.now().difference(_startTime),
+                               new DateTime.now().difference(_startTime),
                                false);
     var test = _currentTest;
     _currentTest = null;
     test.completed();
   }
 
-  void _stderrDone() {
-    _stderrDrained = true;
-    // Move on when both stdout and stderr has been drained.
-    if (_stdoutDrained) _reportResult();
-  }
-
-  void _stdoutDone() {
-    _stdoutDrained = true;
-    // Move on when both stdout and stderr has been drained.
-    if (_stderrDrained) _reportResult();
-  }
-
-  void _readStdout(io.StringInputStream stream, List<int> buffer) {
-    var ignoreStreams = _ignoreStreams;  // Capture this mutable object.
-    void onLineHandler() {
-      if (ignoreStreams.value) {
-         while (stream.readLine() != null) {
-          // Do nothing.
-        }
-        return;
-      }
-      // Otherwise, process output and call _reportResult() when done.
-      var line = stream.readLine();
-      while (line != null) {
-        if (line.startsWith('>>> TEST')) {
-          _status = line;
-        } else if (line.startsWith('>>> BATCH')) {
-          // ignore
-        } else if (line.startsWith('>>> ')) {
-          throw new Exception(
-               'Unexpected command from ${testCase.configuration['compiler']} '
-               'batch runner.');
-        } else {
-          buffer.addAll(encodeUtf8(line));
-          buffer.addAll("\n".charCodes);
-        }
-        line = stream.readLine();
-      }
-      if (_status != null) {
-        _timer.cancel();
-        _stdoutDone();
-      }
-    }
-    stream.onLine = onLineHandler;
-  }
-
-  void _readStderr(io.StringInputStream stream, List<int> buffer) {
-    var ignoreStreams = _ignoreStreams;  // Capture this mutable object.
-    void onLineHandler() {
-      if (ignoreStreams.value) {
-        while (stream.readLine() != null) {
-          // Do nothing.
-        }
-        return;
-      }
-      // Otherwise, process output and call _reportResult() when done.
-      var line = stream.readLine();
-      while (line != null) {
-        if (line.startsWith('>>> EOF STDERR')) {
-          _stderrDone();
-        } else {
-          buffer.addAll(encodeUtf8(line));
-          buffer.addAll("\n".charCodes);
-        }
-        line = stream.readLine();
-      }
-    }
-    stream.onLine = onLineHandler;
-  }
-
   ExitCodeEvent makeExitHandler(String status) {
     void handler(int exitCode) {
       if (active) {
         if (_timer != null) _timer.cancel();
         _status = status;
-        // Read current content of streams, ignore any later output.
-        _ignoreStreams.value = true;
-        var line = _stdoutStream.readLine();
-        while (line != null) {
-          _testStdout.add(line);
-          line = _stdoutStream.readLine();
-        }
-        line = _stderrStream.readLine();
-        while (line != null) {
-          _testStderr.add(line);
-          line = _stderrStream.readLine();
-        }
-        _stderrDrained = true;
-        _stdoutDrained = true;
+        _stdoutSubscription.cancel();
+        _stderrSubscription.cancel();
         _startProcess(_reportResult);
       } else {  // No active test case running.
         _process = null;
       }
     }
     return handler;
   }
 
-  void _timeoutHandler(ignore) {
-    _process.onExit = makeExitHandler(">>> TEST TIMEOUT");
+  void _timeoutHandler() {
+    _processExitHandler = makeExitHandler(">>> TEST TIMEOUT");
     _process.kill();
   }
 
   _startProcess(callback) {
     Future processFuture = io.Process.start(_executable, _batchArguments);
     processFuture.then((io.Process p) {
       _process = p;
-      _stdoutStream = new io.StringInputStream(_process.stdout);
-      _stderrStream = new io.StringInputStream(_process.stderr);
-      _process.onExit = makeExitHandler(">>> TEST CRASH");
+
+      var _stdoutStream =
+          _process.stdout
+              .transform(new io.StringDecoder())
+              .transform(new io.LineTransformer());
+      _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 ${testCase.configuration['compiler']} '
+              'batch runner.');
+        } else {
+          _testStdout.addAll(encodeUtf8(line));
+          _testStdout.addAll("\n".codeUnits);
+        }
+        if (_status != null) {
+          _stdoutSubscription.pause();
+          _timer.cancel();
+          _stdoutCompleter.complete(null);
+        }
+      });
+      _stdoutSubscription.pause();
+
+      var _stderrStream =
+          _process.stderr
+              .transform(new io.StringDecoder())
+              .transform(new io.LineTransformer());
+      _stderrSubscription = _stderrStream.listen((String line) {
+        if (line.startsWith('>>> EOF STDERR')) {
+          _stderrSubscription.pause();
+          _stderrCompleter.complete(null);
+        } else {
+          _testStderr.addAll(encodeUtf8(line));
+          _testStderr.addAll("\n".codeUnits);
+        }
+      });
+      _stderrSubscription.pause();
+
+      _processExitHandler = makeExitHandler(">>> TEST CRASH");
+      _process.exitCode.then((exitCode) {
+        _processExitHandler(exitCode);
+      });
+
+      _process.stdin.done.catchError((err) {
+        print('Error on batch runner input stream stdin');
+        print('  Previous test\'s status: $_status');
+        print('  Error: $err');
+        throw err;
+      });
       callback();
     }).catchError((e) {
       print("Process error:");
       print("  Command: $_executable ${_batchArguments.join(' ')}");
       print("  Error: $e");
       // If there is an error starting a batch process, chances are that
       // it will always fail. So rather than re-trying a 1000+ times, we
       // exit.
       io.exit(1);
       return true;
@@ skipping 52 matching lines @@
   io.Process _seleniumServer = null;
 
   /** True if we are in the process of starting the server. */
   bool _startingServer = false;
 
   /** True if we find that there is already a selenium jar running. */
   bool _seleniumAlreadyRunning = false;
 
   ProcessQueue(this._maxProcesses,
                this._maxBrowserProcesses,
-               Date startTime,
+               DateTime startTime,
                testSuites,
                this._eventListener,
                this._allDone,
                [bool verbose = false,
                 bool listTests = false])
       : _verbose = verbose,
         _listTests = listTests,
         _tests = new Queue<TestCase>(),
         _batchProcesses = new Map<String, List<BatchRunnerProcess>>(),
         _testCache = new Map<String, List<TestInformation>>() {
@@ skipping 65 matching lines @@
       String cmd = 'ps';
       var arg = ['aux'];
       if (io.Platform.operatingSystem == 'windows') {
         cmd = 'tasklist';
         arg.add('/v');
       }
 
       Future processFuture = io.Process.start(cmd, arg);
       processFuture.then((io.Process p) {
         // Drain stderr to not leak resources.
-        p.stderr.onData = p.stderr.read;
-        final io.StringInputStream stdoutStringStream =
-            new io.StringInputStream(p.stdout);
-        stdoutStringStream.onLine = () {
-          var line = stdoutStringStream.readLine();
-          while (null != line) {
-            var regexp = new RegExp(r".*selenium-server-standalone.*");
-            if (regexp.hasMatch(line)) {
-              _seleniumAlreadyRunning = true;
-              resumeTesting();
-            }
-            line = stdoutStringStream.readLine();
+        p.stderr.listen((_) {});
+        final Stream<String> stdoutStringStream =
+            p.stdout.transform(new io.StringDecoder())
+                    .transform(new io.LineTransformer());
+        stdoutStringStream.listen((String line) {
+          var regexp = new RegExp(r".*selenium-server-standalone.*");
+          if (regexp.hasMatch(line)) {
+            _seleniumAlreadyRunning = true;
+            resumeTesting();
           }
           if (!_isSeleniumAvailable) {
             _startSeleniumServer();
           }
-        };
+        });
       }).catchError((e) {
         print("Error starting process:");
         print("  Command: $cmd ${arg.join(' ')}");
         print("  Error: $e");
         // TODO(ahe): How to report this as a test failure?
         io.exit(1);
         return true;
       });
     }
   }
 
   void _runTest(TestCase test) {
     if (test.usesWebDriver) {
       browserUsed = test.configuration['browser'];
       if (_needsSelenium) _ensureSeleniumServerRunning();
     }
     eventTestAdded(test);
     _tests.add(test);
     _tryRunTest();
   }
 
   /**
    * Monitor the output of the Selenium server, to know when we are ready to
    * begin running tests.
    * source: Output(Stream) from the Java server.
    */
-  VoidFunction makeSeleniumServerHandler(io.StringInputStream source) {
-    void handler() {
-      if (source.closed) return;  // TODO(whesse): Remove when bug is fixed.
-      var line = source.readLine();
-      while (null != line) {
-        if (new RegExp(r".*Started.*Server.*").hasMatch(line) ||
-            new RegExp(r"Exception.*Selenium is already running.*").hasMatch(
-            line)) {
-          resumeTesting();
-        }
-        line = source.readLine();
-      }
+  void seleniumServerHandler(String line) {
+    if (new RegExp(r".*Started.*Server.*").hasMatch(line) ||
+        new RegExp(r"Exception.*Selenium is already running.*").hasMatch(
+        line)) {
+      resumeTesting();
     }
-    return handler;
   }
 
   /**
    * For browser tests using Safari or Opera, we need to use the Selenium 1.0
    * Java server.
    */
   void _startSeleniumServer() {
     // Get the absolute path to the Selenium jar.
     String filePath = TestUtils.testScriptPath;
     String pathSep = io.Platform.pathSeparator;
     int index = filePath.lastIndexOf(pathSep);
     filePath = '${filePath.substring(0, index)}${pathSep}testing${pathSep}';
-    var lister = new io.Directory(filePath).list();
-    lister.onFile = (String file) {
-      if (new RegExp(r"selenium-server-standalone-.*\.jar").hasMatch(file)
-          && _seleniumServer == null) {
-        Future processFuture = io.Process.start('java', ['-jar', file]);
-        processFuture.then((io.Process server) {
-          _seleniumServer = server;
-          // Heads up: there seems to an obscure data race of some form in
-          // the VM between launching the server process and launching the test
-          // tasks that disappears when you read IO (which is convenient, since
-          // that is our condition for knowing that the server is ready).
-          io.StringInputStream stdoutStringStream =
-              new io.StringInputStream(_seleniumServer.stdout);
-          io.StringInputStream stderrStringStream =
-              new io.StringInputStream(_seleniumServer.stderr);
-          stdoutStringStream.onLine =
-              makeSeleniumServerHandler(stdoutStringStream);
-          stderrStringStream.onLine =
-              makeSeleniumServerHandler(stderrStringStream);
-        }).catchError((e) {
-          print("Process error:");
-          print("  Command: java -jar $file");
-          print("  Error: $e");
-          // TODO(ahe): How to report this as a test failure?
-          io.exit(1);
-          return true;
-        });
+    new io.Directory(filePath).list().listen((io.FileSystemEntity fse) {
+      if (fse is io.File) {
+        String file = fse.path;
+        if (new RegExp(r"selenium-server-standalone-.*\.jar").hasMatch(file)
+            && _seleniumServer == null) {
+          Future processFuture = io.Process.start('java', ['-jar', file]);
+          processFuture.then((io.Process server) {
+            _seleniumServer = server;
+            // Heads up: there seems to an obscure data race of some form in
+            // the VM between launching the server process and launching the
+            // test tasks that disappears when you read IO (which is
+            // convenient, since that is our condition for knowing that the
+            // server is ready).
+            Stream<String> stdoutStringStream =
+                _seleniumServer.stdout.transform(new io.StringDecoder())
+                .transform(new io.LineTransformer());
+            Stream<String> stderrStringStream =
+                _seleniumServer.stderr.transform(new io.StringDecoder())
+                .transform(new io.LineTransformer());
+            stdoutStringStream.listen(seleniumServerHandler);
+            stderrStringStream.listen(seleniumServerHandler);
+          }).catchError((e) {
+            print("Process error:");
+            print("  Command: java -jar $file");
+            print("  Error: $e");
+            // TODO(ahe): How to report this as a test failure?
+            io.exit(1);
+            return true;
+          });
+        }
       }
-    };
+    });
   }
 
   Future _terminateBatchRunners() {
     var futures = new List();
     for (var runners in _batchProcesses.values) {
       for (var runner in runners) {
         futures.add(runner.terminate());
       }
     }
     // Change to Future.wait when updating binaries.
@@ skipping 28 matching lines @@
                       test.isNegative.toString()];
         fields.addAll(test.commands.last.arguments);
         print(fields.join('\t'));
         return;
       }
       if (test.usesWebDriver && _needsSelenium && !_isSeleniumAvailable || (test
           is BrowserTestCase && test.waitingForOtherTest)) {
         // The test is not yet ready to run. Put the test back in
         // the queue.  Avoid spin-polling by using a timeout.
         _tests.add(test);
-        new Timer(100, (_) => _tryRunTest());  // Don't lose a process.
+        new Timer(new Duration(milliseconds: 100),
+                  _tryRunTest);  // Don't lose a process.
         return;
       }
       // Before running any commands, we print out all commands if '--verbose'
       // was specified.
       if (_verbose && test.commandOutputs.length == 0) {
         int i = 1;
         if (test is BrowserTestCase) {
           // Additional command for rerunning the steps locally after the fact.
           var command =
             test.configuration["_servers_"].httpServerCommandline();
           print('$i. $command');
           i++;
         }
         for (Command command in test.commands) {
           print('$i. $command');
           i++;
         }
       }
 
       var isLastCommand =
           ((test.commands.length-1) == test.commandOutputs.length);
       var isBrowserCommand = isLastCommand && (test is BrowserTestCase);
       if (isBrowserCommand && _numBrowserProcesses == _maxBrowserProcesses) {
         // If there is no free browser runner, put it back into the queue.
         _tests.add(test);
-        new Timer(100, (_) => _tryRunTest());  // Don't lose a process.
+        new Timer(new Duration(milliseconds: 100),
+                  _tryRunTest);  // Don't lose a process.
         return;
       }
 
       eventStartTestCase(test);
 
       // Analyzer and browser test commands can be run by a [BatchRunnerProcess]
       var nextCommandIndex = test.commandOutputs.keys.length;
       var numberOfCommands = test.commands.length;
-        
-      var useBatchRunnerForAnalyzer = 
+
+      var useBatchRunnerForAnalyzer =
           test.configuration['analyzer'] &&
           test.displayName != 'dartc/junit_tests';
       var isWebdriverCommand = nextCommandIndex == (numberOfCommands - 1) &&
                                test.usesWebDriver &&
                                !test.configuration['noBatch'];
       if (useBatchRunnerForAnalyzer || isWebdriverCommand) {
         TestCaseEvent oldCallback = test.completedHandler;
         void testCompleted(TestCase test_arg) {
           _numProcesses--;
           if (isBrowserCommand) {
@@ skipping 142 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
   }
 }