Print test duration in verbose mode.

presubmit_support.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """Enables directory-specific presubmit checks to run at upload and/or commit.
 """
 
 __version__ = '1.7.0'
 
 # TODO(joi) Add caching where appropriate/needed. The API is designed to allow
 # caching (between all different invocations of presubmit scripts for a given
 # change). We should add it as our presubmit scripts start feeling slow.
 
 import cpplint
 import cPickle  # Exposed through the API.
 import cStringIO  # Exposed through the API.
-import collections
 import contextlib
 import fnmatch
 import glob
 import inspect
 import json  # Exposed through the API.
 import logging
 import marshal  # Exposed through the API.
 import multiprocessing
 import optparse
 import os  # Somewhat exposed through the API.
@@ skipping 20 matching lines @@
 
 
 # Ask for feedback only once in program lifetime.
 _ASKED_FOR_FEEDBACK = False
 
 
 class PresubmitFailure(Exception):
   pass
 
 
-CommandData = collections.namedtuple('CommandData',
-                                     ['name', 'cmd', 'kwargs', 'message'])
+class CommandData(object):
+  def __init__(self, name, cmd, kwargs, message):
+    self.name = name
+    self.cmd = cmd
+    self.kwargs = kwargs
+    self.message = message
+    self.info = None
+
 
 def normpath(path):
   '''Version of os.path.normpath that also changes backward slashes to
   forward slashes when not running on Windows.
   '''
   # This is safe to always do because the Windows version of os.path.normpath
   # will replace forward slashes with backward slashes.
   path = path.replace(os.sep, '/')
   return os.path.normpath(path)
 
@@ skipping 390 matching lines @@
       file_item = file_item.AbsoluteLocalPath()
     if not file_item.startswith(self.change.RepositoryRoot()):
       raise IOError('Access outside the repository root is denied.')
     return gclient_utils.FileRead(file_item, mode)
 
   @property
   def tbr(self):
     """Returns if a change is TBR'ed."""
     return 'TBR' in self.change.tags
 
-  @staticmethod
-  def RunTests(tests_mix, parallel=True):
+  def RunTests(self, tests_mix, parallel=True):
     tests = []
     msgs = []
     for t in tests_mix:
       if isinstance(t, OutputApi.PresubmitResult):
         msgs.append(t)
       else:
         assert issubclass(t.message, _PresubmitResult)
         tests.append(t)
+        if self.verbose:
+          t.info = _PresubmitNotifyResult
     if len(tests) > 1 and parallel:
       pool = multiprocessing.Pool()
       # async recipe works around multiprocessing bug handling Ctrl-C
       msgs.extend(pool.map_async(CallCommand, tests).get(99999))
       pool.close()
       pool.join()
     else:
       msgs.extend(map(CallCommand, tests))
     return [m for m in msgs if m]
 
@@ skipping 854 matching lines @@
     for method_name in method_names:
       if not hasattr(presubmit_canned_checks, method_name):
         raise NonexistantCannedCheckFilter(method_name)
       filtered[method_name] = getattr(presubmit_canned_checks, method_name)
       setattr(presubmit_canned_checks, method_name, lambda *_a, **_kw: [])
     yield
   finally:
     for name, method in filtered.iteritems():
       setattr(presubmit_canned_checks, name, method)
 
+
 def CallCommand(cmd_data):
-  # multiprocessing needs a top level function with a single argument.
+  """Runs an external program, potentially from a child process created by the
+  multiprocessing module.
+
+  multiprocessing needs a top level function with a single argument.
+  """
   cmd_data.kwargs['stdout'] = subprocess.PIPE
   cmd_data.kwargs['stderr'] = subprocess.STDOUT
   try:
+    start = time.time()
     (out, _), code = subprocess.communicate(cmd_data.cmd, **cmd_data.kwargs)
-    if code != 0:
-      return cmd_data.message('%s failed\n%s' % (cmd_data.name, out))
+    duration = time.time() - start
   except OSError as e:
+    duration = time.time() - start

[iannucci, 2013/12/02 19:36:38]

finally?

[M-A Ruel, 2013/12/02 21:23:24]

You cannot do try/finally/except in python, only try/except/finally.

     return cmd_data.message(
-        '%s exec failure\n   %s' % (cmd_data.name, e))
+        '%s exec failure (%4.2fs)\n   %s' % (cmd_data.name, duration, e))
+  if code != 0:
+    return cmd_data.message(
+        '%s (%4.2fs) failed\n%s' % (cmd_data.name, duration, out))
+  if cmd_data.info:
+    return cmd_data.info('%s (%4.2fs)' % (cmd_data.name, duration))
 
 
 def Main(argv):
   parser = optparse.OptionParser(usage="%prog [options] <files...>",
                                  version="%prog " + str(__version__))
   parser.add_option("-c", "--commit", action="store_true", default=False,
                    help="Use commit instead of upload checks")
   parser.add_option("-u", "--upload", action="store_false", dest='commit',
                    help="Use upload instead of commit checks")
   parser.add_option("-r", "--recursive", action="store_true",
@@ skipping 70 matching lines @@
   except PresubmitFailure, e:
     print >> sys.stderr, e
     print >> sys.stderr, 'Maybe your depot_tools is out of date?'
     print >> sys.stderr, 'If all fails, contact maruel@'
     return 2
 
 
 if __name__ == '__main__':
   fix_encoding.fix_encoding()
   sys.exit(Main(None))