Make the heapheck runner recognize the sanity tests.

tools/heapcheck/heapcheck_test.py

 #!/usr/bin/python
 # 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.
 
 # heapcheck_test.py
 
 """Wrapper for running the test under heapchecker and analyzing the output."""
 
 import datetime
 import logging
 import os
 import re
 
 import common
 import google.path_utils
 import suppressions
 
 
 class HeapcheckWrapper(object):
   TMP_FILE = 'heapcheck.log'
+  SANITY_TEST_SUPPRESSION = "Heapcheck sanity test"
 
   def __init__(self, supp_files):
     self._mode = 'strict'
     self._timeout = 1200
     self._nocleanup_on_exit = False
     self._suppressions = []
     for fname in supp_files:
       self._suppressions.extend(suppressions.ReadSuppressionsFromFile(fname))
     if os.path.exists(self.TMP_FILE):
       os.remove(self.TMP_FILE)
@@ skipping 19 matching lines @@
         '/../../third_party/tcmalloc/chromium/src/pprof')
     self.PutEnvAndLog('LD_PRELOAD', '/usr/lib/debug/libstdc++.so')
 
     common.RunSubprocess(proc, self._timeout)
 
     # Always return true, even if running the subprocess failed. We depend on
     # Analyze to determine if the run was valid. (This behaviour copied from
     # the purify_test.py script.)
     return True
 
-  def Analyze(self, log_lines):
+  def Analyze(self, log_lines, check_sanity=False):
     """Analyzes the app's output and applies suppressions to the reports.
 
     Analyze() searches the logs for leak reports and tries to apply
     suppressions to them. Unsuppressed reports and other log messages are
     dumped as is.
 
+    If |check_sanity| is True, the list of suppressed reports is searched for a
+    report starting with SANITY_TEST_SUPPRESSION. If there isn't one, Analyze
+    returns 2 regardless of the unsuppressed reports.
+
     Args:
-      log_lines: An iterator over the app's log lines.
+      log_lines:      An iterator over the app's log lines.
+      check_sanity:   A flag that determines whether we should check the tool's
+                      sanity.
     Returns:
-      1, if unsuppressed reports remain in the output, 0 otherwise.
+      2, if the sanity check fails,
+      1, if unsuppressed reports remain in the output and the sanity check
+      passes,
+      0, if all the errors are suppressed and the sanity check passes.
     """
     leak_report = re.compile(
         'Leak of ([0-9]*) bytes in ([0-9]*) objects allocated from:')
-    stack_line = re.compile('\s*@\s*0x[0-9a-fA-F]*\s*(\S*)')
+    stack_line = re.compile('\s*@\s*[0-9a-fA-F]*\s*(\S*)')
     return_code = 0
     # leak signature: [number of bytes, number of objects]
     cur_leak_signature = None
     cur_stack = []
     cur_report = []
     # Statistics grouped by suppression description:
     # [hit count, bytes, objects].
     used_suppressions = {}
     for line in log_lines:
       line = line.rstrip()  # remove the trailing \n
@@ skipping 29 matching lines @@
               used_suppressions[description] = [1] + cur_leak_signature
         cur_stack = []
         cur_report = []
         cur_leak_signature = None
         match = leak_report.match(line)
         if match:
           cur_leak_signature = map(int, match.groups())
         else:
           print line
     # Print the list of suppressions used.
+    is_sane = False
     if used_suppressions:
       print
       print '-----------------------------------------------------'
       print 'Suppressions used:'
       print '   count    bytes  objects name'
       histo = {}
       for description in used_suppressions:
+        if description.startswith(HeapcheckWrapper.SANITY_TEST_SUPPRESSION):
+          is_sane = True
         hits, bytes, objects = used_suppressions[description]
         line = '%8d %8d %8d %s' % (hits, bytes, objects, description)
         if hits in histo:
           histo[hits].append(line)
         else:
           histo[hits] = [line]
       keys = histo.keys()
       keys.sort()
       for count in keys:
         for line in histo[count]:
           print line
       print '-----------------------------------------------------'
+    if is_sane:
+      return return_code
+    else:
+      logging.error("Sanity check failed")
+      return 2
 
-    return return_code
-
-  def RunTestsAndAnalyze(self):
+  def RunTestsAndAnalyze(self, check_sanity):
     self.Execute()
     log_file = file(self.TMP_FILE, 'r')
-    ret = self.Analyze(log_file)
+    ret = self.Analyze(log_file, check_sanity)
     log_file.close()
     return ret
 
-  def Main(self, args):
+  def Main(self, args, check_sanity=False):
     self._args = args
     start = datetime.datetime.now()
     retcode = -1
-    retcode = self.RunTestsAndAnalyze()
+    retcode = self.RunTestsAndAnalyze(check_sanity)
     end = datetime.datetime.now()
     seconds = (end - start).seconds
     hours = seconds / 3600
     seconds %= 3600
     minutes = seconds / 60
     seconds %= 60
     logging.info('elapsed time: %02d:%02d:%02d', hours, minutes, seconds)
     return retcode
 
 
-def RunTool(args, supp_files):
+def RunTool(args, supp_files, module):
   tool = HeapcheckWrapper(supp_files)
-  return tool.Main(args[1:])
+  MODULES_TO_SANITY_CHECK = ["base"]
+  check_sanity = module in MODULES_TO_SANITY_CHECK
+  return tool.Main(args[1:], check_sanity)