Refactor "Suppressions used" printing code in memcheck and tsan analyzer scripts

tools/valgrind/memcheck_analyze.py

 #!/usr/bin/python
 # Copyright (c) 2011 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.
 
 # memcheck_analyze.py
 
 ''' Given a valgrind XML file, parses errors and uniques them.'''
 
 import gdb_helper
 
+from collections import defaultdict
 import hashlib
 import logging
 import optparse
 import os
 import re
 import subprocess
 import sys
 import time
 from xml.dom.minidom import parse
 from xml.parsers.expat import ExpatError
@@ skipping 406 matching lines @@
     # <load_obj><obj>/usr/lib/libgcc_s.1.dylib</obj><ip>0x27000</ip></load_obj>
     # giving the filename and load address of each binary that was mapped
     # into the process.
 
     global TheAddressTable
     if self._use_gdb:
       TheAddressTable = gdb_helper.AddressTable()
     else:
       TheAddressTable = None
     cur_report_errors = set()
-    suppcounts = {}
+    suppcounts = defaultdict(int)
     badfiles = set()
 
     if self._analyze_start_time == None:
       self._analyze_start_time = time.time()
     start_time = self._analyze_start_time
 
     parse_failed = False
     for file in files:
       # Wait up to three minutes for valgrind to finish writing all files,
       # but after that, just skip incomplete files and warn.
@@ skipping 92 matching lines @@
                 # ... and we haven't seen it in other tests as well
                 self._errors.add(error)
                 cur_report_errors.add(error)
 
         suppcountlist = parsed_file.getElementsByTagName("suppcounts")
         if len(suppcountlist) > 0:
           suppcountlist = suppcountlist[0]
           for node in suppcountlist.getElementsByTagName("pair"):
             count = getTextOf(node, "count");
             name = getTextOf(node, "name");
-            if name in suppcounts:
-              suppcounts[name] += int(count)
-            else:
-              suppcounts[name] = int(count)
+            suppcounts[name] += int(count)
 
     if len(badfiles) > 0:
       logging.warn("valgrind didn't finish writing %d files?!" % len(badfiles))
       for file in badfiles:
         logging.warn("Last 20 lines of %s :" % file)
         os.system("tail -n 20 '%s' 1>&2" % file)
 
     if parse_failed:
       logging.error("FAIL! Couldn't parse Valgrind output file")
       return -2
 
-    is_sane = False
-    print "-----------------------------------------------------"
-    print "Suppressions used:"
-    print "  count name"
-
-    remaining_sanity_supp = MemcheckAnalyzer.SANITY_TEST_SUPPRESSIONS
-    for (name, count) in sorted(suppcounts.items(),
-                                key=lambda (k,v): (v,k)):
-      print "%7d %s" % (count, name)
-      if name in remaining_sanity_supp and remaining_sanity_supp[name] == count:
-        del remaining_sanity_supp[name]
-    if len(remaining_sanity_supp) == 0:
-      is_sane = True
-    print "-----------------------------------------------------"
-    sys.stdout.flush()
+    common.PrintUsedSuppressionsList(suppcounts)
 
     retcode = 0
     if cur_report_errors:
       logging.error("FAIL! There were %s errors: " % len(cur_report_errors))
 
       if TheAddressTable != None:
         TheAddressTable.ResolveAll()
 
       for error in cur_report_errors:
         logging.error(error)
 
       retcode = -1
 
     # Report tool's insanity even if there were errors.
-    if check_sanity and not is_sane:
-      logging.error("FAIL! Sanity check failed!")
-      logging.info("The following test errors were not handled: ")
-      for (name, count) in sorted(remaining_sanity_supp.items(),
-                                  key=lambda (k,v): (v,k)):
-        logging.info("%7d %s" % (count, name))
+    if check_sanity:
+      remaining_sanity_supp = MemcheckAnalyzer.SANITY_TEST_SUPPRESSIONS
+      for (name, count) in suppcounts.iteritems():
+        if (name in remaining_sanity_supp and
+            remaining_sanity_supp[name] == count):
+          del remaining_sanity_supp[name]
+      if remaining_sanity_supp:
+        logging.error("FAIL! Sanity check failed!")
+        logging.info("The following test errors were not handled: ")
+        for (name, count) in remaining_sanity_supp.iteritems():
+          logging.info("  * %dx %s" % (count, name))
       retcode = -3
 
     if retcode != 0:
       return retcode
 
     logging.info("PASS! No errors found!")
     return 0
 
 def _main():
   '''For testing only. The MemcheckAnalyzer class should be imported instead.'''
   retcode = 0
   parser = optparse.OptionParser("usage: %prog [options] <files to analyze>")
   parser.add_option("", "--source_dir",
                     help="path to top of source tree for this build"
                     "(used to normalize source paths in baseline)")
 
   (options, args) = parser.parse_args()
   if len(args) == 0:
     parser.error("no filename specified")
   filenames = args
 
   analyzer = MemcheckAnalyzer(options.source_dir, use_gdb=True)
   retcode = analyzer.Report(filenames, None)
 
   sys.exit(retcode)
 
 if __name__ == "__main__":
   _main()