Print times for individual tests that take longer than 1 second to run.

webkit/tools/layout_tests/layout_package/test_shell_thread.py

 # Copyright (c) 2006-2008 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.
@@ skipping 157 matching lines @@
     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._options = options
     self._failures = {}
     self._canceled = False
     self._exception_info = None
     self._timing_stats = {}
+    self._test_times = []
 
     # Current directory of tests we're running.
     self._current_dir = None
     # Number of tests in self._current_dir.
     self._num_tests_in_current_dir = None
     # Time at which we started running tests from self._current_dir.
     self._current_dir_start_time = None
 
     if self._options.run_singly:
       # When we're running one test per test_shell process, we can enforce
       # a hard timeout. test_shell uses a default of 10 seconds if no
       # time-out-ms is given, and the test_shell watchdog uses 2.5x the
       # test_shell's value.  We want to be larger than that.
       self._time_out_sec = int(self._options.time_out_ms) * 3.0 / 1000.0
       logging.info("Setting Python per-test timeout to %s ms (%s sec)" %
                    (1000 * self._time_out_sec, self._time_out_sec))
 
 
   def GetFailures(self):
     """Returns a dictionary mapping test filename to a list of
     TestFailures."""
     return self._failures
 
   def GetTimingStats(self):
     """Returns a dictionary mapping test directory to a tuple of
     (number of tests in that directory, time to run the tests)"""
     return self._timing_stats;
 
+  def GetIndividualTestTimingStats(self):
+    """Returns a list of (time, test_filename) tuples where time is the
+    time it took to run the test."""
+    return self._test_times
+
   def Cancel(self):
     """Set a flag telling this thread to quit."""
     self._canceled = True
 
   def GetExceptionInfo(self):
     """If run() terminated on an uncaught exception, return it here
     ((type, value, traceback) tuple).
     Returns None if run() terminated normally. Meant to be called after
     joining this thread."""
     return self._exception_info
@@ skipping 116 matching lines @@
     # Ok, load the test URL...
     self._test_shell_proc.stdin.write(test_uri + "\n")
     # 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()
 
+    start_time = time.time()
+
     # ...and read the response
-    return ProcessOutput(self._test_shell_proc, filename, test_uri,
-                         self._test_types, self._test_args,
-                         self._options.target)
+    failures = ProcessOutput(self._test_shell_proc, filename, test_uri,
+        self._test_types, self._test_args, self._options.target)
+
+    time_to_run_test = time.time() - start_time
+    self._test_times.append((time_to_run_test, filename))
+    return 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