Modify the sharding_supervisor to understand gtest's xml output.

tools/sharding_supervisor/sharding_supervisor.py

 #!/usr/bin/env 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.
 
 """Shards a given test suite and runs the shards in parallel.
 
 ShardingSupervisor is called to process the command line options and creates
 the specified number of worker threads. These threads then run each shard of
 the test in a separate process and report on the results. When all the shards
 have been completed, the supervisor reprints any lines indicating a test
 failure for convenience. If only one shard is to be run, a single subprocess
 is started for that shard and the output is identical to gtest's output.
 """
 
 
 import cStringIO
 import itertools
 import optparse
 import os
 import Queue
 import random
 import re
 import sys
 import threading
 
+from xml.dom import minidom
+
 # Add tools/ to path
 BASE_PATH = os.path.dirname(os.path.abspath(__file__))
 sys.path.append(os.path.join(BASE_PATH, ".."))
 try:
   import find_depot_tools
   # Fixes a bug in Windows where some shards die upon starting
   # TODO(charleslee): actually fix this bug
   import subprocess2 as subprocess
 except ImportError:
   # Unable to find depot_tools, so just use standard subprocess
@@ skipping 22 matching lines @@
         return int(os.sysconf("SC_NPROCESSORS_ONLN"))
       else:
         # OSX
         return int(os.popen2("sysctl -n hw.ncpu")[1].read())
     # Windows
     return int(os.environ["NUMBER_OF_PROCESSORS"])
   except ValueError:
     return SS_DEFAULT_NUM_CORES
 
 
+def GetGTestOutput(args):
+  """Extracts gtest_output from the args. Returns none if not present."""
+
+  for arg in args:
+    if '--gtest_output=' in arg:
+      return arg.split('=')[1]
+  return None
+
+
+def AppendToGTestOutput(gtest_args, value):
+  args = gtest_args[:]
+  current_value = GetGTestOutput(args)
+  if not current_value:
+    return
+
+  current_arg = '--gtest_output=' + current_value
+  args.remove(current_arg)
+  args.append('--gtest_output=' + current_value + value)
+  return args
+
+
+def RemoveGTestOutput(gtest_args):
+  args = gtest_args[:]
+  current_value = GetGTestOutput(args)
+  if not current_value:
+    return
+
+  args.remove('--gtest_output=' + current_value)
+  return args
+
+
+def AppendToXML(final_xml, generic_path, shard):
+  """Combine the shard xml file with the final xml file."""
+
+  path = generic_path + str(shard)
+  with open(path) as shard_xml_file:
+    shard_xml = minidom.parse(shard_xml_file)
+
+  if not final_xml:
+    # Out final xml is empty, let's prepopulate it with the first one we see.
+    return shard_xml
+
+  shard_node = shard_xml.documentElement
+  final_node = final_xml.documentElement
+
+  testcases = shard_node.getElementsByTagName('testcase')
+  final_testcases = final_node.getElementsByTagName('testcase')
+  for testcase in testcases:
+    name = testcase.getAttribute('name')
+    classname = testcase.getAttribute('classname')
+    failures = testcase.getElementsByTagName('failure')
+    status = testcase.getAttribute('status')
+    elapsed = testcase.getAttribute('time')
+
+    # don't bother updating the final xml if there is no data.
+    if status == 'notrun':
+      continue
+
+    # Look in our final xml to see if it's there.
+    # There has to be a better way...
+    for final_testcase in final_testcases:
+      final_name = final_testcase.getAttribute('name')
+      final_classname = final_testcase.getAttribute('classname')
+      if final_name == name and final_classname == classname:
+        # We got the same entry.
+        final_testcase.setAttribute('status', status)
+        final_testcase.setAttribute('time', elapsed)
+        for failure in failures:
+          final_testcase.appendChild(failure)
+
+  return final_xml
+
+
 def RunShard(test, total_shards, index, gtest_args, stdout, stderr):
   """Runs a single test shard in a subprocess.
 
   Returns:
     The Popen object representing the subprocess handle.
   """
   args = [test]
-  args.extend(gtest_args)
+
+  # If there is a gtest_output
+  test_args = AppendToGTestOutput(gtest_args, str(index))
+  args.extend(test_args)
   env = os.environ.copy()
   env["GTEST_TOTAL_SHARDS"] = str(total_shards)
   env["GTEST_SHARD_INDEX"] = str(index)
 
   # Use a unique log file for each shard
   # Allows ui_tests to be run in parallel on the same machine
   env["CHROME_LOG_FILE"] = "chrome_log_%d" % index
 
   return subprocess.Popen(
       args, stdout=stdout,
@@ skipping 188 matching lines @@
       worker = ShardRunner(
           self, counter, test_start, test_ok, test_fail)
       worker.start()
       workers.append(worker)
     if self.original_order:
       for worker in workers:
         worker.join()
     else:
       self.WaitForShards()
 
+    # All the shards are done.  Merge all the XML files and generate the
+    # main one.
+    output_arg = GetGTestOutput(self.gtest_args)
+    if output_arg:
+      xml, xml_path = output_arg.split(':', 1)
+      assert(xml == 'xml')
+      final_xml = None
+      for i in range(start_point, start_point + self.num_shards_to_run):
+        final_xml = AppendToXML(final_xml, xml_path, i)
+      with open(xml_path, 'w') as final_file:
+        final_xml.writexml(final_file)
+
     num_failed = len(self.failed_shards)
     if num_failed > 0:
       self.failed_shards.sort()
       self.WriteText(sys.stdout,
                      "\nFAILED SHARDS: %s\n" % str(self.failed_shards),
                      "\x1b[1;5;31m")
     else:
       self.WriteText(sys.stdout, "\nALL SHARDS PASSED!\n", "\x1b[1;5;32m")
     self.PrintSummary(self.failed_tests)
     if self.retry_percent < 0:
@@ skipping 89 matching lines @@
       sys.stdout.write("\nNOT RETRYING FAILED TESTS (too many failed)\n")
       return 1
     self.WriteText(sys.stdout, "\nRETRYING FAILED TESTS:\n", "\x1b[1;5;33m")
     sharded_description = re.compile(r": (?:\d+>)?(.*)")
     gtest_filters = [sharded_description.search(line).group(1)
                      for line in self.failed_tests]
     failed_retries = []
 
     for test_filter in gtest_filters:
       args = [self.test, "--gtest_filter=" + test_filter]
-      args.extend(self.gtest_args)
+      # Don't update the xml output files during retry.
+      stripped_gtests_args = RemoveGTestOutput(self.gtest_args)
+      args.extend(stripped_gtests_args)
       rerun = subprocess.Popen(args)
       rerun.wait()
       if rerun.returncode != 0:
         failed_retries.append(test_filter)
 
     self.WriteText(sys.stdout, "RETRY RESULTS:\n", "\x1b[1;5;33m")
     self.PrintSummary(failed_retries)
     return len(failed_retries) > 0
 
   def PrintSummary(self, failed_tests):
@@ skipping 123 matching lines @@
   # shard and run the whole test
   ss = ShardingSupervisor(
       args[0], num_shards_to_run, num_runs, options.color,
       options.original_order, options.prefix, options.retry_percent,
       options.timeout, options.total_slaves, options.slave_index, gtest_args)
   return ss.ShardTest()
 
 
 if __name__ == "__main__":
   sys.exit(main())