Add token to stderr as well as stdout for batch processing.

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 148 matching lines @@
 }
 
 
 /**
  * TestOutput records the output of a completed test: the process's exit code,
  * the standard output and standard error, whether the process timed out, and
  * the time the process took to run.  It also contains a pointer to the
  * [TestCase] this is the output of.
  */
 class TestOutput {
-  final TestCase testCase;
-  final int exitCode;
-  final bool timedOut;
-  final List<String> stdout;
-  final List<String> stderr;
-  final Duration time;
+  TestCase testCase;
+  int exitCode;
+  bool timedOut;
   bool failed = false;
+  List<String> stdout;
+  List<String> stderr;
+  Duration time;
   /**
    * Set to true if we encounter a condition in the output that indicates we
    * need to rerun this test.
    */
-  bool requestRetry = false;
+  bool requestRetry;
 
   TestOutput(this.testCase, this.exitCode, this.timedOut, this.stdout,
              this.stderr, this.time) {
     testCase.output = this;
+    requestRetry = false;
   }
 
   String get result() =>
       hasCrashed ? CRASH : (hasTimedOut ? TIMEOUT : (hasFailed ? FAIL : PASS));
 
   bool get unexpectedOutput() => !testCase.expectedOutcomes.contains(result);
 
   bool get hasCrashed() {
     if (new Platform().operatingSystem() == 'windows') {
       // The VM uses std::abort to terminate on asserts.
@@ skipping 69 matching lines @@
   List<Function> handlers;
   bool allowRetries = false;
 
   /** Which command of [testCase.commands] is currently being executed. */
   int currentStep;
 
   RunningProcess(TestCase this.testCase,
       [this.allowRetries, this.processQueue]);
 
   /**
-   * Called when all commands are executed. [exitCode] is 0 if all commands
+   * Called when all commands are executed. [exitCode] is 0 if all command
    * succeded, otherwise it will have the exit code of the first failing
    * command.
    */
   void testComplete(int exitCode) {
     new TestOutput(testCase, exitCode, timedOut, stdout,
                    stderr, new Date.now().difference(startTime));
     timeoutTimer.cancel();
     if (testCase.output.unexpectedOutput && testCase.configuration['verbose']) {
       print(testCase.displayName);
       for (var line in testCase.output.stderr) print(line);
@@ skipping 39 matching lines @@
           && testCase.configuration['component'] == 'webdriver') {
         // Note: processQueue will always be non-null for component == webdriver
         // (It is only null for component == vm)
         processQueue._getBatchRunner(testCase).startTest(testCase);
       } else {
         runCommand(testCase.commands[currentStep++], stepExitHandler);
       }
     }
   }
 
+  Function makeReadHandler(StringInputStream source, List<String> destination) {
+    return () {
+      if (source.closed) return;  // TODO(whesse): Remove when bug is fixed.
+      var line = source.readLine();
+      while (null != line) {
+        destination.add(line);
+        line = source.readLine();
+      }
+    };
+  }
+
   void start() {
     Expect.isFalse(testCase.expectedOutcomes.contains(SKIP));
-    stdout = [];
-    stderr = [];
+    stdout = new List<String>();
+    stderr = new List<String>();
     currentStep = 0;
     runCommand(testCase.commands[currentStep++], stepExitHandler);
   }
 
   void runCommand(Command command,
                   void exitHandler(int exitCode)) {
     if (new Platform().operatingSystem() == 'windows') {
       // Windows can't handle the first command if it is a .bat file or the like
       // with the slashes going the other direction.
       // TODO(efortuna): Remove this when fixed (Issue 1306).
       command.executable = command.executable.replaceAll('/', '\\');
     }
     process = new Process.start(command.executable, command.arguments);
     process.exitHandler = exitHandler;
     startTime = new Date.now();
     InputStream stdoutStream = process.stdout;
     InputStream stderrStream = process.stderr;
     StringInputStream stdoutStringStream = new StringInputStream(stdoutStream);
     StringInputStream stderrStringStream = new StringInputStream(stderrStream);
     stdoutStringStream.lineHandler =
-        _makeReadHandler(stdoutStringStream, stdout);
+        makeReadHandler(stdoutStringStream, stdout);
     stderrStringStream.lineHandler =
-        _makeReadHandler(stderrStringStream, stderr);
+        makeReadHandler(stderrStringStream, stderr);
     timeoutTimer = new Timer(timeoutHandler, 1000 * testCase.timeout);
   }
 
   void timeoutHandler(Timer unusedTimer) {
     timedOut = true;
     process.kill();
   }
 }
 
 class BatchRunnerProcess {
   String _executable;
   List<String> _batchArguments;
 
   Process _process;
   StringInputStream _stdoutStream;
   StringInputStream _stderrStream;
 
   TestCase _currentTest;
   List<String> _testStdout;
   List<String> _testStderr;
+  bool _stderrDrained = false;
   Date _startTime;
   Timer _timer;
 
   bool _isWebDriver;
 
   BatchRunnerProcess(TestCase testCase) {
     _executable = testCase.commands.last().executable;
     _batchArguments = testCase.batchRunnerArguments;
     _isWebDriver = testCase.configuration['component'] == 'webdriver';
   }
@@ skipping 42 matching lines @@
         bool shutdownMillisecs = 30000;
         new Timer((e) { if (!closed) _process.kill(); }, shutdownMillisecs);
       } else {
         _process.kill();
       }
     }
   }
 
   void doStartTest(TestCase testCase) {
     _startTime = new Date.now();
-    _testStdout = [];
-    _testStderr = [];
+    _testStdout = new List<String>();
+    _testStderr = new List<String>();
+    _stderrDrained = false;
     _stdoutStream.lineHandler = _readStdout(_stdoutStream, _testStdout);
-    _stderrStream.lineHandler = _makeReadHandler(_stderrStream, _testStderr);
+    _stderrStream.lineHandler = _readStderr(_stderrStream, _testStderr);
     _timer = new Timer(_timeoutHandler, testCase.timeout * 1000);
     var line = _createArgumentsLine(testCase.batchTestArguments);
     _process.stdin.write(line.charCodes());
   }
 
   String _createArgumentsLine(List<String> arguments) {
     return Strings.join(arguments, ' ') + '\n';
   }
 
-  // This removes the line handler from stderr and  reads all 
-  // remaining bytes from it.
-  // TODO(zundel): dart:io stream apis need flush()? issue 1407
-  _drainStderr() {
-    _stderrStream.lineHandler = null;
-    while(true) {
-      var available = 0;
-      try {
-        available = _process.stderr.available();
-      } catch (SocketIOException ex) {
-        break;
-      }
-      if (available <= 0) break;
-      String result = _stderrStream.readLine();
-      if (result == null) {
-        // This is intended to catch the last line, but might foul up
-        // if more bytes immediately come available after read() and before
-        // the test for available()
-        result = _stderrStream.read();
-        if (result == null) {
-          var buf = new List<int>(available);
-          _process.stderr.readInto(buf, 0, available);
-          result = new String.fromCharCodes(buf);
-          _testStderr.add(result);
-          break;
-        }
-      }
-      _testStderr.add(result);
-    }
-  }
-  
-  int _reportResult(String output) {
-    _drainStderr();
+  void _testCompleted() {
     var test = _currentTest;
     _currentTest = null;
+    test.completed();
+  }
 
+  int _reportResult(String output) {
     // output = '>>> TEST {PASS, FAIL, OK, CRASH, FAIL, TIMEOUT}'
     var outcome = output.split(" ")[2];
     var exitCode = 0;
     if (outcome == "CRASH") exitCode = -10;
     if (outcome == "FAIL" || outcome == "TIMEOUT") exitCode = 1;
-    new TestOutput(test, exitCode, outcome == "TIMEOUT", _testStdout,
+    new TestOutput(_currentTest, exitCode, outcome == "TIMEOUT", _testStdout,
                    _testStderr, new Date.now().difference(_startTime));
-    test.completed();
+    // Move on when both stdout and stderr has been drained.
+    if (_stderrDrained) _testCompleted();
+  }
+
+  void _stderrDone() {
+    _stderrDrained = true;
+    // Move on when both stdout and stderr has been drained.
+    if (_currentTest.output != null) _testCompleted();
   }
 
   Function _readStdout(StringInputStream stream, List<String> buffer) {
     return () {
       var status;
-      if (stream.closed) return;  // TODO(whesse): Remove when bug is fixed.
       var line = stream.readLine();
-      // Drain the input stream to get the error output.
       while (line != null) {
         if (line.startsWith('>>> TEST')) {
           status = line;
         } else if (line.startsWith('>>> BATCH START')) {
           // ignore
         } else if (line.startsWith('>>> ')) {
           throw new Exception('Unexpected command from dartc batch runner.');
         } else {
           buffer.add(line);
         }
         line = stream.readLine();
       }
       if (status != null) {
         _timer.cancel();
         // For crashing processes, let the exit handler deal with it.
         if (!status.contains("CRASH")) {
           _reportResult(status);
         }
       }
     };
   }
-  
+
+  Function _readStderr(StringInputStream stream, List<String> buffer) {
+    return () {
+      var line = stream.readLine();
+      while (line != null) {
+        if (line.startsWith('>>> EOF STDERR')) {
+          _stderrDone();
+        } else {
+          buffer.add(line);
+        }
+        line = stream.readLine();
+      }
+    };
+  }
+
   void _exitHandler(exitCode) {
     if (_timer != null) _timer.cancel();
-    _reportResult(">>> TEST CRASH");
     _process.close();
-    _startProcess();
+    _startProcess(() {
+      _reportResult(">>> TEST CRASH");
+    });
   }
 
   void _timeoutHandler(ignore) {
-    _process.exitHandler = (exitCode) {_
-      reportResult(">>> TEST TIMEOUT");
+    _process.exitHandler = (exitCode) {
       _process.close();
-      _startProcess();
+      _startProcess(() {
+        _reportResult(">>> TEST TIMEOUT");
+      });
     };
     _process.kill();
   }
 
-  void _startProcess([Function then = null]) {
+  void _startProcess(then) {
     _process = new Process.start(_executable, _batchArguments);
     _stdoutStream = new StringInputStream(_process.stdout);
     _stderrStream = new StringInputStream(_process.stderr);
-    _testStdout = [];
-    _testStderr = [];
+    _testStdout = new List<String>();
+    _testStderr = new List<String>();
+    _stderrDrained = false;
     _stdoutStream.lineHandler = _readStdout(_stdoutStream, _testStdout);
-    _stderrStream.lineHandler =_makeReadHandler(_stderrStream, _testStderr);
+    _stderrStream.lineHandler = _readStderr(_stderrStream, _testStderr);
     _process.exitHandler = _exitHandler;
     _process.startHandler = then;
   }
 }
 
 /**
  * ProcessQueue is the master control class, responsible for running all
  * the tests in all the TestSuites that have been registered.  It includes
  * a rate-limited queue to run a limited number of tests in parallel,
  * a ProgressIndicator which prints output when tests are started and
@@ skipping 230 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++;
     }
   }
 }
-
-Function _makeReadHandler(StringInputStream source, List<String> destination) {
-  return () {
-    if (source.closed) return;  // TODO(whesse): Remove when bug is fixed.
-    var line = source.readLine();
-    while (null != line) {
-      destination.add(line);
-      line = source.readLine();
-    }
-  };
-}
-
-