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

tools/testing/dart/test_progress.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.
 
 library test_progress;
 
 import "dart:io";
 import "dart:io" as io;
 import "http_server.dart" as http_server;
 import "status_file_parser.dart";
 import "test_runner.dart";
 import "test_suite.dart";
 import "utils.dart";
 
 String _pad(String s, int length) {
   StringBuffer buffer = new StringBuffer();
   for (int i = s.length; i < length; i++) {
-    buffer.add(' ');
+    buffer.write(' ');
   }
-  buffer.add(s);
+  buffer.write(s);
   return buffer.toString();
 }
 
 String _padTime(int time) {
   if (time == 0) {
     return '00';
   } else if (time < 10) {
     return '0$time';
   } else {
     return '$time';
@@ skipping 28 matching lines @@
 }
 
 
 List<String> _buildFailureOutput(TestCase test,
                                  [Formatter formatter = const Formatter()]) {
   List<String> output = new List<String>();
   output.add('');
   output.add(formatter.failed('FAILED: ${test.configurationString}'
                               ' ${test.displayName}'));
   StringBuffer expected = new StringBuffer();
-  expected.add('Expected: ');
+  expected.write('Expected: ');
   for (var expectation in test.expectedOutcomes) {
-    expected.add('$expectation ');
+    expected.write('$expectation ');
   }
   output.add(expected.toString());
   output.add('Actual: ${test.lastCommandOutput.result}');
   if (!test.lastCommandOutput.hasTimedOut && test.info != null) {
     if (test.lastCommandOutput.incomplete && !test.info.hasCompileError) {
       output.add('Unexpected compile-time error.');
     } else {
       if (test.info.hasCompileError) {
         output.add('Compile-time error expected.');
       }
@@ skipping 54 matching lines @@
       io.exitCode = 1;
     }
   }
 }
 
 class FlakyLogWriter extends EventListener {
   void done(TestCase test) {
     if (test.isFlaky && test.lastCommandOutput.result != PASS) {
       var buf = new StringBuffer();
       for (var l in _buildFailureOutput(test)) {
-        buf.add("$l\n");
+        buf.write("$l\n");
       }
       _appendToFlakyFile(buf.toString());
     }
   }
 
   void _appendToFlakyFile(String msg) {
     var file = new File(TestUtils.flakyFileName());
     var fd = file.openSync(FileMode.APPEND);
     fd.writeStringSync(msg);
     fd.closeSync();
   }
 }
 
 class SummaryPrinter extends EventListener {
   void allTestsKnown() {
     if (SummaryReport.total > 0) {
       SummaryReport.printReport();
     }
   }
 }
 
 class TimingPrinter extends EventListener {
   List<TestCase> _tests = <TestCase>[];
-  Date _startTime;
+  DateTime _startTime;
 
   TimingPrinter(this._startTime);
 
   void done(TestCase testCase) {
     _tests.add(testCase);
   }
 
   void allDone() {
     // TODO: We should take all the commands into account
-    Duration d = (new Date.now()).difference(_startTime);
+    Duration d = (new DateTime.now()).difference(_startTime);
     print('\n--- Total time: ${_timeString(d)} ---');
     _tests.sort((a, b) {
       Duration aDuration = a.lastCommandOutput.time;
       Duration bDuration = b.lastCommandOutput.time;
       return bDuration.inMilliseconds - aDuration.inMilliseconds;
     });
     for (int i = 0; i < 20 && i < _tests.length; i++) {
       var name = _tests[i].displayName;
       var duration = _tests[i].lastCommandOutput.time;
       var configuration = _tests[i].configurationString;
@@ skipping 89 matching lines @@
 
   Path _tempDir() {
     // Dir will be located in the system temporary directory.
     var dir = new Directory('').createTempSync();
     var path = new Path(dir.path).directoryPath;
     dir.deleteSync();
     return path;
   }
 
   void allDone() {
-    var tempDirs = [];
+    var count = 0;
     var systemTempDir = _tempDir();
-    var lister = new Directory.fromPath(systemTempDir).list();
-    lister.onDir = (path) => tempDirs.add(path);
-    lister.onDone = (_) {
-      if (tempDirs.length > MIN_NUMBER_OF_TEMP_DIRS) {
-        DebugLogger.warning("There are ${tempDirs.length} directories "
-                            "in the system tempdir ('$systemTempDir')! "
-                            "Maybe left over directories?\n");
+    var lister = new Directory.fromPath(systemTempDir).list().listen(
+        (FileSystemEntity fse) {
+          if (fse is Directory) count++;
+        },
+        onDone: () {
+          if (count > MIN_NUMBER_OF_TEMP_DIRS) {
+            DebugLogger.warning("There are ${tempDirs.length} directories "
+                                "in the system tempdir ('$systemTempDir')! "
+                                "Maybe left over directories?\n");
       }
-    };
+    });
   }
 }
 
 class LineProgressIndicator extends EventListener {
   void done(TestCase test) {
     var status = 'pass';
     if (test.lastCommandOutput.unexpectedOutput) {
       status = 'fail';
     }
     print('Done ${test.configurationString} ${test.displayName}: $status');
@@ skipping 12 matching lines @@
       }
       print('');
     }
   }
 }
 
 class ProgressIndicator extends EventListener {
   ProgressIndicator(this._startTime);
 
   factory ProgressIndicator.fromName(String name,
-                                     Date startTime,
+                                     DateTime startTime,
                                      Formatter formatter) {
     switch (name) {
       case 'compact':
         return new CompactProgressIndicator(startTime, formatter);
       case 'line':
         return new LineProgressIndicator();
       case 'verbose':
         return new VerboseProgressIndicator(startTime);
       case 'status':
         return new ProgressIndicator(startTime);
@@ skipping 45 matching lines @@
   }
 
   int get numFailedTests => _failedTests;
 
   int _completedTests() => _passedTests + _failedTests;
 
   int _foundTests = 0;
   int _passedTests = 0;
   int _failedTests = 0;
   bool _allTestsKnown = false;
-  Date _startTime;
+  DateTime _startTime;
 }
 
 abstract class CompactIndicator extends ProgressIndicator {
-  CompactIndicator(Date startTime)
+  CompactIndicator(DateTime startTime)
       : super(startTime);
 
   void allDone() {
-    stdout.write('\n'.charCodes);
+    stdout.writeln('');
     if (_failedTests > 0) {
       // We may have printed many failure logs, so reprint the summary data.
       _printProgress();
       print('');
     }
     stdout.close();
     stderr.close();
   }
 
   void _printStartProgress(TestCase test) => _printProgress();
   void _printDoneProgress(TestCase test) => _printProgress();
 
   void _printProgress();
 }
 
 
 class CompactProgressIndicator extends CompactIndicator {
   Formatter _formatter;
 
-  CompactProgressIndicator(Date startTime, this._formatter)
+  CompactProgressIndicator(DateTime startTime, this._formatter)
       : super(startTime);
 
   void _printProgress() {
     var percent = ((_completedTests() / _foundTests) * 100).toInt().toString();
     var progressPadded = _pad(_allTestsKnown ? percent : '--', 3);
     var passedPadded = _pad(_passedTests.toString(), 5);
     var failedPadded = _pad(_failedTests.toString(), 5);
-    Duration d = (new Date.now()).difference(_startTime);
+    Duration d = (new DateTime.now()).difference(_startTime);
     var progressLine =
         '\r[${_timeString(d)} | $progressPadded% | '
         '+${_formatter.passed(passedPadded)} | '
         '-${_formatter.failed(failedPadded)}]';
-    stdout.write(progressLine.charCodes);
+    stdout.write(progressLine);
   }
 }
 
 
 class VerboseProgressIndicator extends ProgressIndicator {
-  VerboseProgressIndicator(Date startTime)
+  VerboseProgressIndicator(DateTime startTime)
       : super(startTime);
 
   void _printStartProgress(TestCase test) {
     print('Starting ${test.configurationString} ${test.displayName}...');
   }
 
   void _printDoneProgress(TestCase test) {
     var status = 'pass';
     if (test.lastCommandOutput.unexpectedOutput) {
       status = 'fail';
     }
     print('Done ${test.configurationString} ${test.displayName}: $status');
   }
 }
 
 
 class BuildbotProgressIndicator extends ProgressIndicator {
   static String stepName;
   var _failureSummary = <String>[];
 
-  BuildbotProgressIndicator(Date startTime) : super(startTime);
+  BuildbotProgressIndicator(DateTime startTime) : super(startTime);
 
   void done(TestCase test) {
     super.done(test);
     if (test.lastCommandOutput.unexpectedOutput) {
       _failureSummary.addAll(_buildFailureOutput(test));
     }
   }
 
   void _printDoneProgress(TestCase test) {
     var status = 'pass';
@@ skipping 11 matching lines @@
       print('@@@STEP_FAILURE@@@');
       print('@@@BUILD_STEP $stepName failures@@@');
       for (String line in _failureSummary) {
         print(line);
       }
       print('');
     }
     super.allDone();
   }
 }
-