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

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:".codeUnits;
-      var bytesNewLine = "\n".codeUnits;
-      var bytesEOF = "#EOF\n".codeUnits;
+      var bytesContentLength = "Content-Length:".charCodes;
+      var bytesNewLine = "\n".charCodes;
+      var bytesEOF = "#EOF\n".charCodes;
 
       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 = new StringBuffer();
+        field.clear();
         continue;
       }
-      field.write(c);
+      field.add(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;
-  DateTime startTime;
+  Date 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 DateTime.now();
+    startTime = new Date.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.exitCode.then(_commandComplete);
+          process.onExit = _commandComplete;
           _drainStream(process.stdout, stdout);
           _drainStream(process.stderr, stderr);
-          timeoutTimer = new Timer(new Duration(seconds: testCase.timeout),
-                                   timeoutHandler);
+          timeoutTimer = new Timer(1000 * 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 DateTime.now().difference(startTime),
+        new Date.now().difference(startTime),
         compilationSkipped);
     return commandOutput;
   }
 
-  void _drainStream(Stream<List<int>> source, List<int> destination) {
-    source.listen(destination.addAll);
+  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;
   }
 
   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;
-  Completer _stdoutCompleter;
-  Completer _stderrCompleter;
-  StreamSubscription<String> _stdoutSubscription;
-  StreamSubscription<String> _stderrSubscription;
-  Function _processExitHandler;
+  io.StringInputStream _stdoutStream;
+  io.StringInputStream _stderrStream;
 
   TestCase _currentTest;
   List<int> _testStdout;
   List<int> _testStderr;
   String _status;
-  DateTime _startTime;
+  bool _stdoutDrained = false;
+  bool _stderrDrained = false;
+  MutableValue<bool> _ignoreStreams;
+  Date _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;
-      _processExitHandler = (_) {
+      _process.onExit = (exitCode) {
         _startProcess(() {
           doStartTest(testCase);
         });
       };
       _process.kill();
     } else {
       doStartTest(testCase);
     }
   }
 
   Future terminate() {
     if (_process == null) return new Future.immediate(true);
     Completer completer = new Completer();
     Timer killTimer;
-    _processExitHandler = (_) {
+    _process.onExit = (exitCode) {
       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.writeln('--terminate');
+      _process.stdin.write('--terminate\n'.charCodes);
 
       // In case the run_selenium process didn't close, kill it after 30s
-      killTimer = new Timer(new Duration(seconds: 30), _process.kill);
+      int shutdownMillisecs = 30000;
+      killTimer = new Timer(shutdownMillisecs, (e) { _process.kill(); });
     } else {
       _process.kill();
     }
 
     return completer.future;
   }
 
   void doStartTest(TestCase testCase) {
-    _startTime = new DateTime.now();
+    _startTime = new Date.now();
     _testStdout = [];
     _testStderr = [];
     _status = null;
-    _stdoutCompleter = new Completer();
-    _stderrCompleter = new Completer();
-    _timer = new Timer(new Duration(seconds: testCase.timeout),
-                       _timeoutHandler);
+    _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);
 
     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.write(line);
-    _stdoutSubscription.resume();
-    _stderrSubscription.resume();
-    Future.wait([_stdoutCompleter.future,
-                 _stderrCompleter.future]).then((_) => _reportResult());
+    _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);
   }
 
   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 DateTime.now().difference(_startTime),
+                               new Date.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;
-        _stdoutSubscription.cancel();
-        _stderrSubscription.cancel();
+        // 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;
         _startProcess(_reportResult);
       } else {  // No active test case running.
         _process = null;
       }
     }
     return handler;
   }
 
-  void _timeoutHandler() {
-    _processExitHandler = makeExitHandler(">>> TEST TIMEOUT");
+  void _timeoutHandler(ignore) {
+    _process.onExit = makeExitHandler(">>> TEST TIMEOUT");
     _process.kill();
   }
 
   _startProcess(callback) {
     Future processFuture = io.Process.start(_executable, _batchArguments);
     processFuture.then((io.Process p) {
       _process = p;
-
-      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;
-      });
+      _stdoutStream = new io.StringInputStream(_process.stdout);
+      _stderrStream = new io.StringInputStream(_process.stderr);
+      _process.onExit = makeExitHandler(">>> TEST CRASH");
       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,
-               DateTime startTime,
+               Date 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.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();
+        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();
           }
           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.
    */
-  void seleniumServerHandler(String line) {
-    if (new RegExp(r".*Started.*Server.*").hasMatch(line) ||
-        new RegExp(r"Exception.*Selenium is already running.*").hasMatch(
-        line)) {
-      resumeTesting();
+  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();
+      }
     }
+    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}';
-    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;
-          });
-        }
+    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;
+        });
       }
-    });
+    };
   }
 
   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(new Duration(milliseconds: 100),
-                  _tryRunTest);  // Don't lose a process.
+        new Timer(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(new Duration(milliseconds: 100),
-                  _tryRunTest);  // Don't lose a process.
+        new Timer(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();
     }
   }
 }