Make Progress support an arbitrary number of columns.

googletest/run_test_cases.py

 #!/usr/bin/env python
 # Copyright 2013 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.
 
 """Runs each test cases as a single shard, single process execution.
 
 Similar to sharding_supervisor.py but finer grained. It runs each test case
 individually instead of running per shard. Runs multiple instances in parallel.
 """
@@ skipping 846 matching lines @@
       else:
         line = '%s %s' % (i['test_case'], duration)
       if self.verbose or not test_case_has_passed or try_count > 0:
         # Print output in one of three cases:
         # - --verbose was specified.
         # - The test failed.
         # - The wasn't the first attempt (this is needed so the test parser can
         #   detect that a test has been successfully retried).
         if i['output']:
           line += '\n' + i['output']
-      self.progress.update_item(line, index=1, size=need_to_retry)
+      self.progress.update_item(line, col0=1, col1=need_to_retry)
 
       if need_to_retry:
         priority = self._retry(priority, i['test_case'], try_count)
 
       # Delay yielding when only one test case is running, in case of a
       # crash-after-succeed.
       if len(test_cases) > 1:
         yield i
 
     if proc.returncode and not got_failure_at_least_once:
       if results and len(test_cases) == 1:
         # Crash after pass.
         results[-1]['returncode'] = proc.returncode
 
       if try_count < self.retries:
         # This is tricky, one of the test case failed but each did print that
         # they succeeded! Retry them *all* individually.
         if not self.verbose and not try_count:
           # Print all the output as one shot when not verbose to be sure the
           # potential stack trace is printed.
           output = ''.join(i['output'] for i in results)
           self.progress.update_item(output, raw=True)
         for i in results:
           priority = self._retry(priority, i['test_case'], try_count)
-          self.progress.update_item('', size=1)
+          self.progress.update_item('', col1=1)
 
     # Only yield once the process completed when there is only one test case as
     # a safety precaution.
     if results and len(test_cases) == 1:
       yield results[-1]
 
   def _retry(self, priority, test_case, try_count):
     """Adds back the same task again only if relevant.
 
     It may add it either at lower (e.g. higher value) priority or at the end of
@@ skipping 272 matching lines @@
   if not clusters:
     clusters = calc_cluster_default(len(test_cases), jobs)
   else:
     # Limit the value.
     clusters = max(min(clusters, len(test_cases) / jobs), 1)
 
   logging.debug('%d test cases with clusters of %d', len(test_cases), clusters)
 
   if gtest_output:
     gtest_output = gen_gtest_output_dir(cwd, gtest_output)
-  progress = threading_utils.Progress(len(test_cases))
+  progress = threading_utils.Progress([0, len(test_cases)])
   progress.use_cr_only = not no_cr
-  serial_tasks = threading_utils.QueueWithProgress(0)
-  serial_tasks.set_progress(progress)
+  serial_tasks = threading_utils.QueueWithProgress(progress)
 
   def add_serial_task(priority, func, *args, **kwargs):
     """Adds a serial task, to be executed later."""
     assert isinstance(priority, int)
     assert callable(func)
     serial_tasks.put((priority, func, args, kwargs))
 
   with threading_utils.ThreadPoolWithProgress(
       progress, jobs, jobs, len(test_cases)) as pool:
     runner = ChromiumGoogleTestRunner(
@@ skipping 400 matching lines @@
         options.gtest_output,
         result_file,
         options.verbose)
   except Failure as e:
     print >> sys.stderr, e.args[0]
     return 1
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))