[test-runner] Move test case processing beyond the multi-process boundary.

tools/testrunner/local/progress.py

 # Copyright 2012 the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 #       notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 #       copyright notice, this list of conditions and the following
 #       disclaimer in the documentation and/or other materials provided
@@ skipping 14 matching lines @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 from functools import wraps
 import json
 import os
 import sys
 import time
 
+from . import execution
 from . import junit_output
 
 
 ABS_PATH_PREFIX = os.getcwd() + os.sep
 
 
-def EscapeCommand(command):
-  parts = []
-  for part in command:
-    if ' ' in part:
-      # Escape spaces.  We may need to escape more characters for this
-      # to work properly.
-      parts.append('"%s"' % part)
-    else:
-      parts.append(part)
-  return " ".join(parts)
-
-
 class ProgressIndicator(object):
 
   def __init__(self):
     self.runner = None
 
   def SetRunner(self, runner):
     self.runner = runner
 
   def Starting(self):
     pass
@@ skipping 13 matching lines @@
   def PrintFailureHeader(self, test):
     if test.suite.IsNegativeTest(test):
       negative_marker = '[negative] '
     else:
       negative_marker = ''
     print "=== %(label)s %(negative)s===" % {
       'label': test.GetLabel(),
       'negative': negative_marker
     }
 
+  def _EscapeCommand(self, test):
+    command = execution.GetCommand(test, self.runner.context)
+    parts = []
+    for part in command:
+      if ' ' in part:
+        # Escape spaces.  We may need to escape more characters for this
+        # to work properly.
+        parts.append('"%s"' % part)
+      else:
+        parts.append(part)
+    return " ".join(parts)
+
 
 class IndicatorNotifier(object):
   """Holds a list of progress indicators and notifies them all on events."""
   def __init__(self):
     self.indicators = []
 
   def Register(self, indicator):
     self.indicators.append(indicator)
 
 
@@ skipping 21 matching lines @@
   def Done(self):
     print
     for failed in self.runner.failed:
       self.PrintFailureHeader(failed)
       if failed.output.stderr:
         print "--- stderr ---"
         print failed.output.stderr.strip()
       if failed.output.stdout:
         print "--- stdout ---"
         print failed.output.stdout.strip()
-      print "Command: %s" % EscapeCommand(self.runner.GetCommand(failed))
+      print "Command: %s" % self._EscapeCommand(failed)
       if failed.output.HasCrashed():
         print "exit code: %d" % failed.output.exit_code
         print "--- CRASHED ---"
       if failed.output.HasTimedOut():
         print "--- TIMEOUT ---"
     if len(self.runner.failed) == 0:
       print "==="
       print "=== All tests succeeded"
       print "==="
     else:
@@ skipping 67 matching lines @@
   def HasRun(self, test, has_unexpected_output):
     if has_unexpected_output:
       self.ClearLine(self.last_status_length)
       self.PrintFailureHeader(test)
       stdout = test.output.stdout.strip()
       if len(stdout):
         print self.templates['stdout'] % stdout
       stderr = test.output.stderr.strip()
       if len(stderr):
         print self.templates['stderr'] % stderr
-      print "Command: %s" % EscapeCommand(self.runner.GetCommand(test))
+      print "Command: %s" % self._EscapeCommand(test)
       if test.output.HasCrashed():
         print "exit code: %d" % test.output.exit_code
         print "--- CRASHED ---"
       if test.output.HasTimedOut():
         print "--- TIMEOUT ---"
 
   def Truncate(self, string, length):
     if length and (len(string) > (length - 3)):
       return string[:(length - 3)] + "..."
     else:
@@ skipping 67 matching lines @@
 
   def HasRun(self, test, has_unexpected_output):
     fail_text = ""
     if has_unexpected_output:
       stdout = test.output.stdout.strip()
       if len(stdout):
         fail_text += "stdout:\n%s\n" % stdout
       stderr = test.output.stderr.strip()
       if len(stderr):
         fail_text += "stderr:\n%s\n" % stderr
-      fail_text += "Command: %s" % EscapeCommand(self.runner.GetCommand(test))
+      fail_text += "Command: %s" % self._EscapeCommand(test)
       if test.output.HasCrashed():
         fail_text += "exit code: %d\n--- CRASHED ---" % test.output.exit_code
       if test.output.HasTimedOut():
         fail_text += "--- TIMEOUT ---"
     self.outputter.HasRunTest(
         [test.GetLabel()] + self.runner.context.mode_flags + test.flags,
         test.duration,
         fail_text)
 
 
@@ skipping 14 matching lines @@
         # Buildbot might start out with an empty file.
         complete_results = json.loads(f.read() or "[]")
 
     # Sort tests by duration.
     timed_tests = [t for t in self.tests if t.duration is not None]
     timed_tests.sort(lambda a, b: cmp(b.duration, a.duration))
     slowest_tests = [
       {
         "name": test.GetLabel(),
         "flags": test.flags,
-        "command": EscapeCommand(self.runner.GetCommand(test)).replace(
-            ABS_PATH_PREFIX, ""),
+        "command": self._EscapeCommand(test).replace(ABS_PATH_PREFIX, ""),
         "duration": test.duration,
       } for test in timed_tests[:20]
     ]
 
     complete_results.append({
       "arch": self.arch,
       "mode": self.mode,
       "results": self.results,
       "slowest_tests": slowest_tests,
     })
 
     with open(self.json_test_results, "w") as f:
       f.write(json.dumps(complete_results))
 
   def HasRun(self, test, has_unexpected_output):
     # Buffer all tests for sorting the durations in the end.
     self.tests.append(test)
     if not has_unexpected_output:
       # Omit tests that run as expected. Passing tests of reruns after failures
       # will have unexpected_output to be reported here has well.
       return
 
     self.results.append({
       "name": test.GetLabel(),
       "flags": test.flags,
-      "command": EscapeCommand(self.runner.GetCommand(test)).replace(
-          ABS_PATH_PREFIX, ""),
+      "command": self._EscapeCommand(test).replace(ABS_PATH_PREFIX, ""),
       "run": test.run,
       "stdout": test.output.stdout,
       "stderr": test.output.stderr,
       "exit_code": test.output.exit_code,
       "result": test.suite.GetOutcome(test),
       "expected": list(test.outcomes or ["PASS"]),
       "duration": test.duration,
 
       # TODO(machenbach): This stores only the global random seed from the
       # context and not possible overrides when using random-seed stress.
       "random_seed": self.random_seed,
       "target_name": test.suite.shell(),
       "variant": test.variant,
     })
 
 
 PROGRESS_INDICATORS = {
   'verbose': VerboseProgressIndicator,
   'dots': DotsProgressIndicator,
   'color': ColorProgressIndicator,
   'mono': MonochromeProgressIndicator
 }