coverage_posix.py: use proper root directory for Linux now that...

tools/code_coverage/coverage_posix.py

 #!/usr/bin/env python
 # Copyright (c) 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.
 
 """Generate and process code coverage.
 
 TODO(jrg): rename this from coverage_posix.py to coverage_all.py!
 
 Written for and tested on Mac, Linux, and Windows.  To use this script
@@ skipping 43 matching lines @@
 import glob
 import logging
 import optparse
 import os
 import shutil
 import subprocess
 import sys
 import time
 import traceback
 
+
 class Coverage(object):
   """Doitall class for code coverage."""
 
   def __init__(self, directory, options, args):
     super(Coverage, self).__init__()
     logging.basicConfig(level=logging.DEBUG)
     self.directory = directory
     self.options = options
     self.args = args
     self.directory_parent = os.path.dirname(self.directory)
@@ skipping 85 matching lines @@
       inclusion = ['unit_tests']
       keep = []
       for test in self.tests:
         for i in inclusion:
           if i in test:
             keep.append(test)
       self.tests = keep
       logging.info('After trimming tests we have ' + ' '.join(self.tests))
       return
     if self.IsLinux():
+      # self.tests = filter(lambda t: t.endswith('base_unittests'), self.tests)
       return
     if self.IsMac():
       exclusion = ['automated_ui_tests']
       punted = []
       for test in self.tests:
         for e in exclusion:
           if test.endswith(e):
             punted.append(test)
       self.tests = filter(lambda t: t not in punted, self.tests)
       if punted:
@@ skipping 74 matching lines @@
       if not os.path.exists(fulltest):
         logging.info(fulltest + ' does not exist')
         if self.options.strict:
           sys.exit(2)
       else:
         logging.info('%s path exists' % fulltest)
       cmdlist = [fulltest, '--gtest_print_time']
 
       # If asked, make this REAL fast for testing.
       if self.options.fast_test:
+        logging.info('Running as a FAST test for testing')
         # cmdlist.append('--gtest_filter=RenderWidgetHost*')
-        cmdlist.append('--gtest_filter=CommandLine*')
+        # cmdlist.append('--gtest_filter=CommandLine*')
+        cmdlist.append('--gtest_filter=C*')
 
       self.BeforeRunOneTest(fulltest)
       logging.info('Running test ' + str(cmdlist))
       try:
         retcode = subprocess.call(cmdlist)
       except:  # can't "except WindowsError" since script runs on non-Windows
         logging.info('EXCEPTION while running a unit test')
         logging.info(traceback.format_exc())
         retcode = 999
       self.AfterRunOneTest(fulltest)
@@ skipping 13 matching lines @@
     # Stop counters
     cmdlist = [self.perf, '-shutdown']
     self.Run(cmdlist)
     full_output = self.vsts_output + '.coverage'
     shutil.move(full_output, self.vsts_output)
     # generate lcov!
     self.GenerateLcovWindows(testname)
 
   def AfterRunAllTests(self):
     """Do things right after running ALL tests."""
+    # On POSIX we can do it all at once without running out of memory.
+    # This contrasts with Windows where we must do it after each test.
     if self.IsPosix():
-      # On POSIX we can do it all at once without running out of memory.
       self.GenerateLcovPosix()
+    # Only on Linux do we have the Xvfb step.
     if self.IsLinux() and self.options.xvfb:
       self.StopXvfb()
 
   def StartXvfb(self):
     """Start Xvfb and set an appropriate DISPLAY environment.  Linux only.
 
     Copied from http://src.chromium.org/viewvc/chrome/trunk/tools/buildbot/
       scripts/slave/slave_utils.py?view=markup
     with some simplifications (e.g. no need to use xdisplaycheck, save
     pid in var not file, etc)
@@ skipping 26 matching lines @@
       logging.info('Xvfb: killing')
       try:
         os.kill(self.xvfb_pid, signal.SIGKILL)
       except:
         pass
       del os.environ['DISPLAY']
       self.xvfb_pid = 0
 
 
   def GenerateLcovPosix(self):
-    """Convert profile data to lcov."""
+    """Convert profile data to lcov on Mac or Linux."""
+    if self.IsLinux():
+      # With Linux/make the current directory for this command is
+      # .../src/chrome but we need to be in .../src for the relative
+      # path of source files to be correct.  On Mac source files are
+      # compiled with abs paths so this isn't a problem.
+      start_dir = os.getcwd()
+      os.chdir('..')
     command = [self.mcov,
                '--directory', self.directory_parent,
                '--output', self.coverage_info_file]
-    print >>sys.stderr, 'Assembly command: ' + ' '.join(command)
+    logging.info('Assembly command: ' + ' '.join(command))
     retcode = subprocess.call(command)
     if retcode:
       logging.fatal('COVERAGE: %s failed; return code: %d' %
                     (command[0], retcode))
       if self.options.strict:
         sys.exit(retcode)
+    if self.IsLinux():
+      os.chdir(start_dir)
 
   def GenerateLcovWindows(self, testname=None):
     """Convert VSTS format to lcov.  Appends coverage data to sum file."""
     lcov_file = self.vsts_output + '.lcov'
     if os.path.exists(lcov_file):
       os.remove(lcov_file)
     # generates the file (self.vsts_output + ".lcov")
 
     cmdlist = [self.analyzer,
                '-sym_path=' + self.directory,
@@ skipping 87 matching lines @@
   if options.trim:
     coverage.TrimTests()
   coverage.RunTests()
   if options.genhtml:
     coverage.GenerateHtml()
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main())