1. Show crash stacks in run_webkit_tests.py stdio...

webkit/tools/layout_tests/layout_package/test_shell_thread.py

 # Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """A Thread object for running the test shell and processing URLs from a
 shared queue.
 
 Each thread runs a separate instance of the test_shell binary and validates
 the output.  When there are no more URLs to process in the shared queue, the
 thread exits.
 """
 
 import copy
 import logging
 import os
 import Queue
 import signal
 import subprocess
 import sys
 import thread
 import threading
 import time
 
 import path_utils
 import test_failures
 
-def ProcessOutput(proc, test_info, test_types, test_args, target):
+def ProcessOutput(proc, test_info, test_types, test_args, target, output_dir):
   """Receives the output from a test_shell process, subjects it to a number
   of tests, and returns a list of failure types the test produced.
 
   Args:
     proc: an active test_shell process
     test_info: Object containing the test filename, uri and timeout
     test_types: list of test types to subject the output to
     test_args: arguments to be passed to each test
     target: Debug or Release
+    output_dir: directory to put crash stack traces into
 
   Returns: a list of failure objects and times for the test being processed
   """
   outlines = []
   extra_lines = []
   failures = []
   crash = False
 
   # Some test args, such as the image hash, may be added or changed on a
   # test-by-test basis.
   local_test_args = copy.copy(test_args)
 
   start_time = time.time()
 
   line = proc.stdout.readline()
 
   # Only start saving output lines once we've loaded the URL for the test.
-  hit_load_url = False
+  url = None
+  test_string = test_info.uri.strip()
 
   while line.rstrip() != "#EOF":
     # Make sure we haven't crashed.
     if line == '' and proc.poll() is not None:
       failures.append(test_failures.FailureCrash())
 
       # This is hex code 0xc000001d, which is used for abrupt termination.
       # This happens if we hit ctrl+c from the prompt and we happen to
       # be waiting on the test_shell.
       # sdoyon: Not sure for which OS and in what circumstances the
       # above code is valid. What works for me under Linux to detect
       # ctrl+c is for the subprocess returncode to be negative SIGINT. And
       # that agrees with the subprocess documentation.
       if (-1073741510 == proc.returncode or
           -signal.SIGINT == proc.returncode):
         raise KeyboardInterrupt
       crash = True
       break
 
     # Don't include #URL lines in our output
     if line.startswith("#URL:"):
-      hit_load_url = True
-      test_string = test_info.uri.strip()
       url = line.rstrip()[5:]
       if url != test_string:
         logging.fatal("Test got out of sync:\n|%s|\n|%s|" %
                       (url, test_string))
         raise AssertionError("test out of sync")
     elif line.startswith("#MD5:"):
       local_test_args.hash = line.rstrip()[5:]
     elif line.startswith("#TEST_TIMED_OUT"):
       # Test timed out, but we still need to read until #EOF.
       failures.append(test_failures.FailureTimeout())
-    elif hit_load_url:
+    elif url:
       outlines.append(line)
     else:
       extra_lines.append(line)
 
     line = proc.stdout.readline()
 
   end_test_time = time.time()
 
   if len(extra_lines):
-    logging.warning("Previous test output extra lines after dump:\n%s" % (
-        "".join(extra_lines)))
+    extra = "".join(extra_lines)
+    if crash:
+      logging.info("Stacktrace for %s:\n%s" % (test_string, extra))
+      # Strip off "file://" since RelativeTestFilename expects filesystem paths.
+      filename = os.path.join(output_dir,
+          path_utils.RelativeTestFilename(test_string[7:]))
+      filename = os.path.splitext(filename)[0] + "-stack.txt"
+      path_utils.MaybeMakeDirectory(os.path.split(filename)[0])
+      open(filename, "wb").write(extra)
+    else:
+      logging.warning("Previous test output extra lines after dump:\n%s" %
+          extra)
 
   # Check the output and save the results.
   time_for_diffs = {}
   for test_type in test_types:
     start_diff_time = time.time()
     new_failures = test_type.CompareOutput(test_info.filename,
                                            proc,
                                            ''.join(outlines),
                                            local_test_args,
                                            target)
@@ skipping 30 matching lines @@
                total_time_for_all_diffs, time_for_diffs):
     self.filename = filename
     self.failures = failures
     self.test_run_time = test_run_time
     self.total_time_for_all_diffs = total_time_for_all_diffs
     self.time_for_diffs = time_for_diffs
 
 class SingleTestThread(threading.Thread):
   """Thread wrapper for running a single test file."""
   def __init__(self, test_shell_command, shell_args, test_info, test_types,
-      test_args, target):
+      test_args, target, output_dir):
     """
     Args:
       test_info: Object containing the test filename, uri and timeout
       See TestShellThread for documentation of the remaining arguments.
     """
 
     threading.Thread.__init__(self)
     self._command = test_shell_command
     self._shell_args = shell_args
     self._test_info = test_info
     self._test_types = test_types
     self._test_args = test_args
     self._target = target
+    self._output_dir = output_dir
 
   def run(self):
     proc = StartTestShell(self._command, self._shell_args +
         ["--time-out-ms=" + self._test_info.timeout, self._test_info.uri])
     self._test_stats = ProcessOutput(proc, self._test_info, self._test_types,
-        self._test_args, self._target)
+        self._test_args, self._target, self._output_dir)
 
   def GetTestStats(self):
     return self._test_stats
 
 class TestShellThread(threading.Thread):
 
   def __init__(self, filename_list_queue, test_shell_command, test_types,
-               test_args, shell_args, options):
+               test_args, shell_args, output_dir, options):
     """Initialize all the local state for this test shell thread.
 
     Args:
       filename_list_queue: A thread safe Queue class that contains lists of
           tuples of (filename, uri) pairs.
       test_shell_command: A list specifying the command+args for test_shell
       test_types: A list of TestType objects to run the test output against.
       test_args: A TestArguments object to pass to each TestType.
       shell_args: Any extra arguments to be passed to test_shell.exe.
+      output_dir: Directory to put crash stacks into.
       options: A property dictionary as produced by optparse. The command-line
           options should match those expected by run_webkit_tests; they
           are typically passed via the run_webkit_tests.TestRunner class.
     """
     threading.Thread.__init__(self)
     self._filename_list_queue = filename_list_queue
     self._filename_list = []
     self._test_shell_command = test_shell_command
     self._test_types = test_types
     self._test_args = test_args
     self._test_shell_proc = None
     self._shell_args = shell_args
+    self._output_dir = output_dir

[tony, 2009/10/29 23:13:51]

Nit: Maybe just use options.results_directory rather than adding an extra input
param?

     self._options = options
     self._failures = {}
     self._canceled = False
     self._exception_info = None
     self._directory_timing_stats = {}
     self._test_stats = []
     self._num_tests = 0
     self._start_time = 0
     self._stop_time = 0
 
@@ skipping 141 matching lines @@
       test_info: Object containing the test filename, uri and timeout
 
     Return:
       A list of TestFailure objects describing the error.
     """
     worker = SingleTestThread(self._test_shell_command,
                               self._shell_args,
                               test_info,
                               self._test_types,
                               self._test_args,
-                              self._options.target)
+                              self._options.target,
+                              self._output_dir)
 
     worker.start()
 
     # When we're running one test per test_shell process, we can enforce
     # a hard timeout. the test_shell watchdog uses 2.5x the timeout
     # We want to be larger than that.
     worker.join(int(test_info.timeout) * 3.0 / 1000.0)
     if worker.isAlive():
       # If join() returned with the thread still running, the test_shell.exe is
       # completely hung and there's nothing more we can do with it.  We have
@@ skipping 38 matching lines @@
 
     # If the test shell is dead, the above may cause an IOError as we
     # try to write onto the broken pipe. If this is the first test for
     # this test shell process, than the test shell did not
     # successfully start. If this is not the first test, then the
     # previous tests have caused some kind of delayed crash. We don't
     # try to recover here.
     self._test_shell_proc.stdin.flush()
 
     stats = ProcessOutput(self._test_shell_proc, test_info, self._test_types,
-        self._test_args, self._options.target)
+        self._test_args, self._options.target, self._output_dir)
 
     self._test_stats.append(stats)
     return stats.failures
 
 
   def _EnsureTestShellIsRunning(self):
     """Start the shared test shell, if it's not running.  Not for use when
     running tests singly, since those each start a separate test shell in
     their own thread.
     """
     if (not self._test_shell_proc or
         self._test_shell_proc.poll() is not None):
       self._test_shell_proc = StartTestShell(self._test_shell_command,
                                              self._shell_args)
 
   def _KillTestShell(self):
     """Kill the test shell process if it's running."""
     if self._test_shell_proc:
       self._test_shell_proc.stdin.close()
       self._test_shell_proc.stdout.close()
       if self._test_shell_proc.stderr:
         self._test_shell_proc.stderr.close()
       if sys.platform not in ('win32', 'cygwin'):
         # Closing stdin/stdout/stderr hangs sometimes on OS X.
         subprocess.Popen(["kill", "-9", str(self._test_shell_proc.pid)])
       self._test_shell_proc = None