Version 1.2.0-dev.2.4

dart/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 726 matching lines @@
 
   CommandOutput get lastCommandOutput {
     if (commandOutputs.length == 0) {
       throw new Exception("CommandOutputs is empty, maybe no command was run? ("
                           "displayName: '$displayName', "
                           "configurationString: '$configurationString')");
     }
     return commandOutputs[commands[commandOutputs.length - 1]];
   }
 
+  Command get lastCommandExecuted {
+    if (commandOutputs.length == 0) {
+      throw new Exception("CommandOutputs is empty, maybe no command was run? ("
+                          "displayName: '$displayName', "
+                          "configurationString: '$configurationString')");
+    }
+    return commands[commandOutputs.length - 1];
+  }
+
   int get timeout {
     if (expectedOutcomes.contains(Expectation.SLOW)) {
       return configuration['timeout'] * SLOW_TIMEOUT_MULTIPLIER;
     } else {
       return configuration['timeout'];
     }
   }
 
   String get configurationString {
     final compiler = configuration['compiler'];
@@ skipping 107 matching lines @@
 class CommandOutputImpl extends UniqueObject implements CommandOutput {
   Command command;
   int exitCode;
 
   bool timedOut;
   List<int> stdout;
   List<int> stderr;
   Duration time;
   List<String> diagnostics;
   bool compilationSkipped;
+  int pid;
 
   /**
    * A flag to indicate we have already printed a warning about ignoring the VM
    * crash, to limit the amount of output produced per test.
    */
   bool alreadyPrintedWarning = false;
 
   // TODO(kustermann): Remove testCase from this class.
   CommandOutputImpl(Command this.command,
                     int this.exitCode,
                     bool this.timedOut,
                     List<int> this.stdout,
                     List<int> this.stderr,
                     Duration this.time,
-                    bool this.compilationSkipped) {
+                    bool this.compilationSkipped,
+                    int this.pid) {
     diagnostics = [];
   }
 
   Expectation result(TestCase testCase) {
     if (hasCrashed) return Expectation.CRASH;
     if (hasTimedOut) return Expectation.TIMEOUT;
     return hasFailed(testCase) ? Expectation.FAIL : Expectation.PASS;
   }
 
   bool get hasCrashed {
@@ skipping 65 matching lines @@
       stdout,
       stderr,
       time,
       compilationSkipped) :
     super(command,
           exitCode,
           timedOut,
           stdout,
           stderr,
           time,
-          compilationSkipped) {
+          compilationSkipped,
+          0) {
     _failedBecauseOfMissingXDisplay = _didFailBecauseOfMissingXDisplay();
     if (_failedBecauseOfMissingXDisplay) {
       DebugLogger.warning("Warning: Test failure because of missing XDisplay");
       // If we get the X server error, or DRT crashes with a core dump, retry
       // the test.
     }
   }
 
   Expectation result(TestCase testCase) {
     // Handle crashes and timeouts first
@@ skipping 329 matching lines @@
         '${indent(result.browserOutput.stderr.toString(), 2)}\n'
         '\n';
     return new BrowserControllerTestOutcome._internal(
       command, result, outcome, encodeUtf8(stdout), encodeUtf8(stderr));
   }
 
   BrowserControllerTestOutcome._internal(
       Command command, BrowserTestOutput result, this._rawOutcome,
       List<int> stdout, List<int> stderr)
       : super(command, 0, result.didTimeout, stdout, stderr, result.duration,
-              false) {
+              false, 0) {
     _result = result;
   }
 
   Expectation result(TestCase testCase) {
     // Handle timeouts first
     if (_result.didTimeout)  return Expectation.TIMEOUT;
 
     // Multitests are handled specially
     if (testCase.info != null) {
       if (testCase.info.hasRuntimeError) {
@@ skipping 21 matching lines @@
                             stdout,
                             stderr,
                             time,
                             compilationSkipped) :
     super(command,
           exitCode,
           timedOut,
           stdout,
           stderr,
           time,
-          compilationSkipped);
+          compilationSkipped,
+          0);
 
   Expectation result(TestCase testCase) {
     // TODO(kustermann): If we run the analyzer not in batch mode, make sure
     // that command.exitCodes matches 2 (errors), 1 (warnings), 0 (no warnings,
     // no errors)
 
     // Handle crashes and timeouts first
     if (hasCrashed) return Expectation.CRASH;
     if (hasTimedOut) return Expectation.TIMEOUT;
 
@@ skipping 72 matching lines @@
     }
   }
 }
 
 class VmCommandOutputImpl extends CommandOutputImpl
                           with UnittestSuiteMessagesMixin {
   static const DART_VM_EXITCODE_COMPILE_TIME_ERROR = 254;
   static const DART_VM_EXITCODE_UNCAUGHT_EXCEPTION = 255;
 
   VmCommandOutputImpl(Command command, int exitCode, bool timedOut,
-      List<int> stdout, List<int> stderr, Duration time)
-      : super(command, exitCode, timedOut, stdout, stderr, time, false);
+                      List<int> stdout, List<int> stderr, Duration time,
+                      int pid)
+      : super(command, exitCode, timedOut, stdout, stderr, time, false, pid);
 
   Expectation result(TestCase testCase) {
     // Handle crashes and timeouts first
     if (hasCrashed) return Expectation.CRASH;
     if (hasTimedOut) return Expectation.TIMEOUT;
 
     // Multitests are handled specially
     if (testCase.info != null) {
       if (testCase.info.hasCompileError) {
         if (exitCode == DART_VM_EXITCODE_COMPILE_TIME_ERROR) {
@@ skipping 29 matching lines @@
   }
 }
 
 class CompilationCommandOutputImpl extends CommandOutputImpl {
   static const DART2JS_EXITCODE_CRASH = 253;
 
   CompilationCommandOutputImpl(Command command, int exitCode, bool timedOut,
       List<int> stdout, List<int> stderr, Duration time,
       bool compilationSkipped)
       : super(command, exitCode, timedOut, stdout, stderr, time,
-              compilationSkipped);
+              compilationSkipped, 0);
 
   Expectation result(TestCase testCase) {
     // Handle general crash/timeout detection.
     if (hasCrashed) return Expectation.CRASH;
     if (hasTimedOut) return Expectation.TIMEOUT;
 
     // Handle dart2js/dart2dart specific crash detection
     if (exitCode == DART2JS_EXITCODE_CRASH ||
         exitCode == VmCommandOutputImpl.DART_VM_EXITCODE_COMPILE_TIME_ERROR ||
         exitCode == VmCommandOutputImpl.DART_VM_EXITCODE_UNCAUGHT_EXCEPTION) {
@@ skipping 23 matching lines @@
     Expectation outcome =
         exitCode == 0 ? Expectation.PASS : Expectation.COMPILETIME_ERROR;
     return _negateOutcomeIfNegativeTest(outcome, testCase.isNegative);
   }
 }
 
 class JsCommandlineOutputImpl extends CommandOutputImpl
                               with UnittestSuiteMessagesMixin {
   JsCommandlineOutputImpl(Command command, int exitCode, bool timedOut,
       List<int> stdout, List<int> stderr, Duration time)
-      : super(command, exitCode, timedOut, stdout, stderr, time, false);
+      : super(command, exitCode, timedOut, stdout, stderr, time, false, 0);
 
   Expectation result(TestCase testCase) {
     // Handle crashes and timeouts first
     if (hasCrashed) return Expectation.CRASH;
     if (hasTimedOut) return Expectation.TIMEOUT;
 
     if (testCase.info != null && testCase.info.hasRuntimeError) {
       if (exitCode != 0) return Expectation.PASS;
       return Expectation.MISSING_RUNTIME_ERROR;
     }
 
     var outcome = exitCode == 0 ? Expectation.PASS : Expectation.RUNTIME_ERROR;
     outcome = _negateOutcomeIfIncompleteAsyncTest(outcome, decodeUtf8(stdout));
     return _negateOutcomeIfNegativeTest(outcome, testCase.isNegative);
   }
 }
 
 class PubCommandOutputImpl extends CommandOutputImpl {
   PubCommandOutputImpl(PubCommand command, int exitCode, bool timedOut,
       List<int> stdout, List<int> stderr, Duration time)
-      : super(command, exitCode, timedOut, stdout, stderr, time, false);
+  : super(command, exitCode, timedOut, stdout, stderr, time, false, 0);
 
   Expectation result(TestCase testCase) {
     // Handle crashes and timeouts first
     if (hasCrashed) return Expectation.CRASH;
     if (hasTimedOut) return Expectation.TIMEOUT;
 
     if (exitCode == 0) {
       return Expectation.PASS;
     } else if ((command as PubCommand).command == 'get') {
       return Expectation.PUB_GET_ERROR;
     } else {
       return Expectation.FAIL;
     }
   }
 }
 
 class ScriptCommandOutputImpl extends CommandOutputImpl {
   final Expectation _result;
 
   ScriptCommandOutputImpl(ScriptCommand command, this._result,
                           String scriptExecutionInformation, Duration time)
-      : super(command, 0, false, [], [], time, false) {
+  : super(command, 0, false, [], [], time, false, 0) {
     var lines = scriptExecutionInformation.split("\n");
     diagnostics.addAll(lines);
   }
 
   Expectation result(TestCase testCase) => _result;
 
   bool get canRunDependendCommands => _result == Expectation.PASS;
 
   bool get successful => _result == Expectation.PASS;
 
 }
 
 CommandOutput createCommandOutput(Command command,
                                   int exitCode,
                                   bool timedOut,
                                   List<int> stdout,
                                   List<int> stderr,
                                   Duration time,
-                                  bool compilationSkipped) {
+                                  bool compilationSkipped,
+                                  [int pid = 0]) {
   if (command is ContentShellCommand) {
     return new BrowserCommandOutputImpl(
         command, exitCode, timedOut, stdout, stderr,
         time, compilationSkipped);
   } else if (command is BrowserTestCommand) {
     return new HTMLBrowserCommandOutputImpl(
         command, exitCode, timedOut, stdout, stderr,
         time, compilationSkipped);
   } else if (command is AnalysisCommand) {
     return new AnalysisCommandOutputImpl(
         command, exitCode, timedOut, stdout, stderr,
         time, compilationSkipped);
   } else if (command is VmCommand) {
     return new VmCommandOutputImpl(
-        command, exitCode, timedOut, stdout, stderr, time);
+        command, exitCode, timedOut, stdout, stderr, time, pid);
   } else if (command is CompilationCommand) {
     return new CompilationCommandOutputImpl(
         command, exitCode, timedOut, stdout, stderr, time, compilationSkipped);
   } else if (command is JSCommandlineCommand) {
     return new JsCommandlineOutputImpl(
         command, exitCode, timedOut, stdout, stderr, time);
   } else if (command is PubCommand) {
     return new PubCommandOutputImpl(
         command, exitCode, timedOut, stdout, stderr, time);
   }
 
   return new CommandOutputImpl(
       command, exitCode, timedOut, stdout, stderr,
-      time, compilationSkipped);
+      time, compilationSkipped, pid);
 }
 
 
 /**
  * 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 {
   ProcessCommand command;
   int timeout;
   bool timedOut = false;
   DateTime startTime;
   Timer timeoutTimer;
+  int pid;
   List<int> stdout = <int>[];
   List<int> stderr = <int>[];
   bool compilationSkipped = false;
   Completer<CommandOutput> completer;
 
   RunningProcess(this.command, this.timeout);
 
   Future<CommandOutput> run() {
     completer = new Completer<CommandOutput>();
     startTime = new DateTime.now();
@@ skipping 17 matching lines @@
           StreamSubscription stdoutSubscription =
               _drainStream(process.stdout, stdout);
           StreamSubscription stderrSubscription =
               _drainStream(process.stderr, stderr);
 
           var stdoutCompleter = new Completer();
           var stderrCompleter = new Completer();
 
           bool stdoutDone = false;
           bool stderrDone = false;
+          pid = process.pid;
 
           // This timer is used to close stdio to the subprocess once we got
           // the exitCode. Sometimes descendants of the subprocess keep stdio
           // handles alive even though the direct subprocess is dead.
           Timer watchdogTimer;
 
           closeStdout([_]) {
             if (!stdoutDone) {
               stdoutCompleter.complete();
               stdoutDone = true;
-
               if (stderrDone && watchdogTimer != null) {
                 watchdogTimer.cancel();
               }
             }
           }
           closeStderr([_]) {
             if (!stderrDone) {
               stderrCompleter.complete();
               stderrDone = true;
 
@@ skipping 59 matching lines @@
   }
 
   CommandOutput _createCommandOutput(ProcessCommand command, int exitCode) {
     var commandOutput = createCommandOutput(
         command,
         exitCode,
         timedOut,
         stdout,
         stderr,
         new DateTime.now().difference(startTime),
-        compilationSkipped);
+        compilationSkipped,
+        pid);
     return commandOutput;
   }
 
   StreamSubscription _drainStream(Stream<List<int>> source,
                                   List<int> destination) {
     return source.listen(destination.addAll);
   }
 
   Map<String, String> _createProcessEnvironment() {
     var environment = new Map.from(io.Platform.environment);
@@ skipping 1035 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
     _allDone();
   }
 }