Print out the ui_test test case in the reports

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
@@ skipping 97 matching lines @@
       # Try using gdb
       TheAddressTable.Add(frame_dict[OBJECT_FILE],
                           frame_dict[INSTRUCTION_POINTER])
   return frames
 
 class ValgrindError:
   ''' Takes a <DOM Element: error> node and reads all the data from it. A
   ValgrindError is immutable and is hashed on its pretty printed output.
   '''
 
-  def __init__(self, source_dir, error_node, commandline):
+  def __init__(self, source_dir, error_node, commandline, testcase):
     ''' Copies all the relevant information out of the DOM and into object
     properties.
 
     Args:
       error_node: The <error></error> DOM node we're extracting from.
       source_dir: Prefix that should be stripped from the <dir> node.
       commandline: The command that was run under valgrind
+      testcase: The test case name, if known.
     '''
 
     # Valgrind errors contain one <what><stack> pair, plus an optional
     # <auxwhat><stack> pair, plus an optional <origin><what><stack></origin>,
     # plus (since 3.5.0) a <suppression></suppression> pair.
     # (Origin is nicely enclosed; too bad the other two aren't.)
     # The most common way to see all three in one report is
     # a syscall with a parameter that points to uninitialized memory, e.g.
     # Format:
     # <error>
@@ skipping 51 matching lines @@
     #    <file>gtest-internal-inl.h</file>
     #    <line>655</line>
     #  </frame>
     # although the dir, file, and line elements are missing if there is
     # no debug info.
 
     self._kind = getTextOf(error_node, "kind")
     self._backtraces = []
     self._suppression = None
     self._commandline = commandline
+    self._testcase = testcase
 
     # Iterate through the nodes, parsing <what|auxwhat><stack> pairs.
     description = None
     for node in error_node.childNodes:
       if node.localName == "what" or node.localName == "auxwhat":
         description = "".join([n.data for n in node.childNodes
                               if n.nodeType == n.TEXT_NODE])
       elif node.localName == "xwhat":
         description = getTextOf(node, "text")
       elif node.localName == "stack":
@@ skipping 46 matching lines @@
         elif frame[SRC_FILE_DIR] != "":
           output += (" (" + frame[SRC_FILE_DIR] + "/" + frame[SRC_FILE_NAME] +
                      ":" + frame[SRC_LINE] + ")")
         else:
           output += " (" + frame[OBJECT_FILE] + ")"
         output += "\n"
 
     assert self._suppression != None, "Your Valgrind doesn't generate " \
                                       "suppressions - is it too old?"
 
+    if self._testcase:
+      output += "The report came from the `%s` test.\n" % self._testcase
     output += "Suppression (error hash=#%016X#):\n" % self.ErrorHash()
     output += ("  For more info on using suppressions see "
                "http://dev.chromium.org/developers/how-tos/using-valgrind#TOC-Suppressing-Errors")
 
     # Widen suppression slightly to make portable between mac and linux
     supp = self._suppression;
     supp = supp.replace("fun:_Znwj", "fun:_Znw*")
     supp = supp.replace("fun:_Znwm", "fun:_Znw*")
     supp = supp.replace("fun:_Znaj", "fun:_Zna*")
     supp = supp.replace("fun:_Znam", "fun:_Zna*")
@@ skipping 118 matching lines @@
     self._use_gdb = use_gdb
 
     # Contains the set of unique errors
     self._errors = set()
 
     # Contains the time when the we started analyzing the first log file.
     # This variable is used to skip incomplete logs after some timeout.
     self._analyze_start_time = None
 
 
-  def Report(self, files, check_sanity=False):
+  def Report(self, files, testcase, check_sanity=False):
     '''Reads in a set of files and prints Memcheck report.
 
     Args:
       files: A list of filenames.
       check_sanity: if true, search for SANITY_TEST_SUPPRESSIONS
     '''
     # Beyond the detailed errors parsed by ValgrindError above,
     # the xml file contain records describing suppressions that were used:
     # <suppcounts>
     #  <pair>
@@ skipping 105 matching lines @@
             for x in node.childNodes:
               if x.nodeType == node.TEXT_NODE and "Command" in x.data:
                 commandline = x.data
                 break
 
         raw_errors = parsed_file.getElementsByTagName("error")
         for raw_error in raw_errors:
           # Ignore "possible" leaks for now by default.
           if (self._show_all_leaks or
               getTextOf(raw_error, "kind") != "Leak_PossiblyLost"):
-            error = ValgrindError(self._source_dir, raw_error, commandline)
+            error = ValgrindError(self._source_dir,
+                                  raw_error, commandline, testcase)
             if error not in cur_report_errors:
               # We haven't seen such errors doing this report yet...
               if error in self._errors:
                 # ... but we saw it in earlier reports, e.g. previous UI test
                 cur_report_errors.add("This error was already printed in "
                                       "some other test, see 'hash=#%016X#'" % \
                                       error.ErrorHash())
               else:
                 # ... and we haven't seen it in other tests as well
                 self._errors.add(error)
@@ skipping 70 matching lines @@
   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)
+  retcode = analyzer.Report(filenames, None)
 
   sys.exit(retcode)
 
 if __name__ == "__main__":
   _main()