Land update to tools directory with new binaries.

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 86 matching lines @@
     // We generate a new command-line that is the special command where we
     // replace '@' with the original command executable, and generate
     // a command formed like the following
     // Let PREFIX be what is before the @.
     // Let SUFFIX be what is after the @.
     // Let EXECUTABLE be the existing executable of the command.
     // Let ARGUMENTS be the existing arguments to the existing executable.
     // The new command will be:
     // PREFIX EXECUTABLE SUFFIX ARGUMENTS
     var specialCommand = configuration['special-command'];
-    if (!specialCommand.isEmpty()) {
+    if (!specialCommand.isEmpty) {
       Expect.isTrue(specialCommand.contains('@'),
                     "special-command must contain a '@' char");
       var specialCommandSplit = specialCommand.split('@');
       var prefix = specialCommandSplit[0].trim();
       var suffix = specialCommandSplit[1].trim();
       List<Command> newCommands = [];
       for (Command c in commands) {
         // If we don't have a new prefix we will use the existing executable.
         var newExecutablePath = c.executable;;
         var newArguments = [];
 
         if (prefix.length > 0) {
           var prefixSplit = prefix.split(' ');
           newExecutablePath = prefixSplit[0];
           for (int i = 1; i < prefixSplit.length; i++) {
             var current = prefixSplit[i];
-            if (!current.isEmpty()) newArguments.add(current);
+            if (!current.isEmpty) newArguments.add(current);
           }
           newArguments.add(c.executable);
         }
 
         // Add any suffixes to the arguments of the original executable.
         var suffixSplit = suffix.split(' ');
         suffixSplit.forEach((e) {
-          if (!e.isEmpty()) newArguments.add(e);
+          if (!e.isEmpty) newArguments.add(e);
         });
 
         newArguments.addAll(c.arguments);
         final newCommand = new Command(newExecutablePath, newArguments);
         newCommands.add(newCommand);
         // If there are extra spaces inside the prefix or suffix, this fails.
         String expected =
             '$prefix ${c.executable} $suffix ${Strings.join(c.arguments, ' ')}';
         Expect.stringEquals(expected.trim(), newCommand.commandLine);
       }
@@ skipping 12 matching lines @@
   String get configurationString {
     final compiler = configuration['compiler'];
     final runtime = configuration['runtime'];
     final mode = configuration['mode'];
     final arch = configuration['arch'];
     final checked = configuration['checked'] ? '-checked' : '';
     return "$compiler-$runtime$checked ${mode}_$arch";
   }
 
   List<String> get batchRunnerArguments => ['-batch'];
-  List<String> get batchTestArguments => commands.last().arguments;
+  List<String> get batchTestArguments => commands.last.arguments;
 
   bool get usesWebDriver => TestUtils.usesWebDriver(configuration['runtime']);
 
   void completed() { completedHandler(this); }
 }
 
 
 /**
  * BrowserTestCase has an extra compilation command that is run in a separate
  * process, before the regular test is run as in the base class [TestCase].
  * If the compilation command fails, then the rest of the test is not run.
  */
 class BrowserTestCase extends TestCase {
   /**
    * Indicates the number of potential retries remaining, to compensate for
    * flaky browser tests.
    */
   int numRetries;
 
   BrowserTestCase(displayName, commands, configuration, completedHandler,
       expectedOutcomes, info, isNegative)
     : super(displayName, commands, configuration, completedHandler,
         expectedOutcomes, isNegative: isNegative, info: info) {
     numRetries = 2; // Allow two retries to compensate for flaky browser tests.
   }
 
-  List<String> get _lastArguments => commands.last().arguments;
+  List<String> get _lastArguments => commands.last.arguments;
 
   List<String> get batchRunnerArguments => [_lastArguments[0], '--batch'];
 
   List<String> get batchTestArguments =>
       _lastArguments.getRange(1, _lastArguments.length - 1);
 }
 
 
 /**
  * TestOutput records the output of a completed test: the process's exit code,
@@ skipping 226 matching lines @@
   }
 
   bool _didMultitestFail(List errors, List staticWarnings) {
     Set<String> outcome = testCase.info.multitestOutcome;
     Expect.isNotNull(outcome);
     if (outcome.contains('compile-time error') && errors.length > 0) {
       return true;
     } else if (outcome.contains('static type warning')
         && staticWarnings.length > 0) {
       return true;
-    } else if (outcome.isEmpty()
+    } else if (outcome.isEmpty
         && (errors.length > 0 || staticWarnings.length > 0)) {
       return true;
     }
     return false;
   }
 
   bool _didStandardTestFail(List errors, List staticWarnings) {
     bool hasFatalTypeErrors = false;
     int numStaticTypeAnnotations = 0;
     int numCompileTimeAnnotations = 0;
@@ skipping 283 matching lines @@
   String _status;
   bool _stdoutDrained = false;
   bool _stderrDrained = false;
   MutableValue<bool> _ignoreStreams;
   Date _startTime;
   Timer _timer;
 
   bool _isWebDriver;
 
   BatchRunnerProcess(TestCase testCase) {
-    _executable = testCase.commands.last().executable;
+    _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;
     if (_process === null) {
       // Start process if not yet started.
-      _executable = testCase.commands.last().executable;
+      _executable = testCase.commands.last.executable;
       _startProcess(() {
         doStartTest(testCase);
       });
-    } else if (testCase.commands.last().executable != _executable) {
+    } else if (testCase.commands.last.executable != _executable) {
       // Restart this runner with the right executable for this test
       // if needed.
-      _executable = testCase.commands.last().executable;
+      _executable = testCase.commands.last.executable;
       _batchArguments = testCase.batchRunnerArguments;
       _process.onExit = (exitCode) {
         _process.close();
         _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) {
       _process.close();
       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.write('--terminate\n'.charCodes);
 
       // In case the run_selenium process didn't close, kill it after 30s
       int shutdownMillisecs = 30000;
       killTimer = new Timer(shutdownMillisecs, (e) { _process.kill(); });
     } else {
       _process.kill();
     }
 
     return completer.future;
   }
@@ skipping 10 matching lines @@
     _stderrStream.onLine = _readStderr(_stderrStream, _testStderr);
     _timer = new Timer(testCase.timeout * 1000, _timeoutHandler);
     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.charCodes);
   }
 
   String _createArgumentsLine(List<String> arguments) {
     return Strings.join(arguments, ' ').concat('\n');
   }
 
   void _reportResult() {
     if (!active) return;
     // _status == '>>> TEST {PASS, FAIL, OK, CRASH, FAIL, TIMEOUT}'
 
@@ skipping 233 matching lines @@
 
   void _checkDone() {
     // When there are no more active test listers ask for more work
     // from process queue users.
     if (_activeTestListers == 0) {
      _enqueueMoreWork(this);
     }
     // If there is still no work, we are done.
     if (_activeTestListers == 0) {
       _progress.allTestsKnown();
-      if (_tests.isEmpty() && _numProcesses == 0) {
+      if (_tests.isEmpty && _numProcesses == 0) {
         _terminateBatchRunners().then((_) => _cleanupAndMarkDone());
       }
     }
   }
 
   /**
    * True if we are using a browser + platform combination that needs the
    * Selenium server jar.
    */
   bool get _needsSelenium => Platform.operatingSystem == 'macos' &&
@@ skipping 122 matching lines @@
           // TODO(ahe): How to report this as a test failure?
           exit(1);
           return true;
         });
       }
     };
   }
 
   Future _terminateBatchRunners() {
     var futures = new List();
-    for (var runners in _batchProcesses.getValues()) {
+    for (var runners in _batchProcesses.values) {
       for (var runner in runners) {
         futures.add(runner.terminate());
       }
     }
     return Futures.wait(futures);
   }
 
   BatchRunnerProcess _getBatchRunner(TestCase test) {
     // Start batch processes if needed
     var compiler = test.configuration['compiler'];
     var runners = _batchProcesses[compiler];
     if (runners == null) {
       runners = new List<BatchRunnerProcess>(_maxProcesses);
       for (int i = 0; i < _maxProcesses; i++) {
         runners[i] = new BatchRunnerProcess(test);
       }
       _batchProcesses[compiler] = runners;
     }
 
     for (var runner in runners) {
       if (!runner.active) return runner;
     }
     throw new Exception('Unable to find inactive batch runner.');
   }
 
   void _tryRunTest() {
     _checkDone();
-    if (_numProcesses < _maxProcesses && !_tests.isEmpty()) {
+    if (_numProcesses < _maxProcesses && !_tests.isEmpty) {
       TestCase test = _tests.removeFirst();
       if (_listTests) {
         var fields = [test.displayName,
                       Strings.join(new List.from(test.expectedOutcomes), ','),
                       test.isNegative.toString()];
-        fields.addAll(test.commands.last().arguments);
+        fields.addAll(test.commands.last.arguments);
         print(Strings.join(fields, '\t'));
         return;
       }
       if (test.usesWebDriver && _needsSelenium && !_isSeleniumAvailable) {
         // The server is not ready to run Selenium tests. Put the test back in
         // the queue.  Avoid spin-polling by using a timeout.
         _tests.add(test);
         new Timer(1000, (timer) {_tryRunTest();});  // Don't lose a process.
         return;
       }
@@ skipping 24 matching lines @@
         // the developer doesn't waste his or her time trying to fix a bunch of
         // tests that appear to be broken but were actually just flakes that
         // didn't get retried because there had already been one failure.
         bool allowRetry = _MAX_FAILED_NO_RETRY > _progress.numFailedTests;
         new RunningProcess(test, allowRetry, this).start();
       }
       _numProcesses++;
     }
   }
 }