Make merging of shard test results handle test suites that are split across shards better.

tools/sharding_supervisor/sharding_supervisor.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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
@@ skipping 105 matching lines @@
 
   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')
+
+  final_testsuites = final_node.getElementsByTagName('testsuite')
+  final_testsuites_by_name = dict(
+      (suite.getAttribute('name'), suite) for suite in final_testsuites)
+
   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...
+    merged_into_final_testcase = False
     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)
+        merged_into_final_testcase = True
+
+    # We couldn't find an existing testcase to merge the results into, so we
+    # copy the node into the existing test suite.
+    if not merged_into_final_testcase:
+      testsuite = testcase.parentNode
+      final_testsuite = final_testsuites_by_name[testsuite.getAttribute('name')]
+      final_testsuite.appendChild(testcase)
 
   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.
   """
@@ skipping 123 matching lines @@
     shard_output: Buffer that stores the output from each shard.
     test_counter: Stores the total number of tests run.
     total_slaves: Total number of slaves running this test.
     slave_index: Current slave to run tests for.
 
   If total_slaves is set, we run only a subset of the tests. This is meant to be
   used when we want to shard across machines as well as across cpus. In that
   case the number of shards to execute will be the same, but they will be
   smaller, as the total number of shards in the test suite will be multiplied
   by 'total_slaves'.
- 
+
   For example, if you are on a quad core machine, the sharding supervisor by
   default will use 20 shards for the whole suite. However, if you set
   total_slaves to 2, it will split the suite in 40 shards and will only run
   shards [0-19] or shards [20-39] depending if you set slave_index to 0 or 1.
   """
 
   SHARD_COMPLETED = object()
 
   def __init__(self, test, num_shards_to_run, num_runs, color, original_order,
                prefix, retry_percent, timeout, total_slaves, slave_index,
@@ skipping 343 matching lines @@
   # shard and run the whole test
   ss = ShardingSupervisor(
       test, 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())