Roll latest version of gtest-parallel.

gtest-parallel

 #!/usr/bin/env python2
 # Copyright 2013 Google Inc. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #     http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import cPickle
 import errno
 import gzip
 import json
 import multiprocessing
 import optparse
 import os
+import re
 import signal
 import subprocess
 import sys
 import tempfile
 import thread
 import threading
 import time
 import zlib
 
 # An object that catches SIGINT sent to the Python process and notices
@@ skipping 354 matching lines @@
   # run if it was successful, or None if the test is new or the most
   # recent run failed.
   tests = [x for x in tests if x[0] is None]
 
 # Sort tests by falling runtime (with None, which is what we get for
 # new and failing tests, being considered larger than any real
 # runtime).
 tests.sort(reverse=True, key=lambda x: ((1 if x[0] is None else 0), x))
 
 # Repeat tests (-r flag).
-tests *= options.repeat
+tests = [(test, i + 1) for test in tests for i in range(options.repeat)]
 test_lock = threading.Lock()
 job_id = 0
 logger.log(str(-1) + ': TESTCNT ' + ' ' + str(len(tests)))
 
 exit_code = 0
 
 # Create directory for test log output.
 try:
   os.makedirs(options.output_dir)
 except OSError as e:
   # Ignore errors if this directory already exists.
   if e.errno != errno.EEXIST or not os.path.isdir(options.output_dir):
     raise e
 # Remove files from old test runs.
 for logfile in os.listdir(options.output_dir):
   os.remove(os.path.join(options.output_dir, logfile))
 
 # Run the specified job. Return the elapsed time in milliseconds if
 # the job succeeds, or None if the job fails. (This ensures that
 # failing tests will run first the next time.)
-def run_job((command, job_id, test)):
+def run_job((command, job_id, test, test_index)):
   begin = time.time()
 
-  with tempfile.NamedTemporaryFile(dir=options.output_dir, delete=False) as log:
+  test_name = re.sub('[^A-Za-z0-9]', '_', test) + '-' + str(test_index) + '.log'
+  with open(os.path.join(options.output_dir, test_name), 'w') as log:
     sub = subprocess.Popen(command + ['--gtest_filter=' + test] +
                              ['--gtest_color=' + options.gtest_color],
-                           stdout=log.file,
-                           stderr=log.file)
+                           stdout=log, stderr=log)
     try:
       code = sigint_handler.wait(sub)
     except sigint_handler.ProcessWasInterrupted:
       thread.exit()
     runtime_ms = int(1000 * (time.time() - begin))
     logger.logfile(job_id, log.name)
 
   test_results.log(test, {
       "expected": "PASS",
       "actual": "PASS" if code == 0 else "FAIL",
       "time": runtime_ms,
   })
   logger.log("%s: EXIT %s %d" % (job_id, code, runtime_ms))
   if code == 0:
     return runtime_ms
   global exit_code
   exit_code = code
   return None
 
 def worker():
   global job_id
   while True:
     job = None
     test_lock.acquire()
     if job_id < len(tests):
-      (_, test_binary, test, command) = tests[job_id]
+      ((_, test_binary, test, command), test_index) = tests[job_id]
       logger.log(str(job_id) + ': TEST ' + test_binary + ' ' + test)
-      job = (command, job_id, test)
+      job = (command, job_id, test, test_index)
     job_id += 1
     test_lock.release()
     if job is None:
       return
     times.record_test_time(test_binary, test, run_job(job))
 
 def start_daemon(func):
   t = threading.Thread(target=func)
   t.daemon = True
   t.start()
   return t
 
 workers = [start_daemon(worker) for i in range(options.workers)]
 
 [t.join() for t in workers]
 logger.end()
 times.write_to_file(save_file)
 if options.print_test_times:
   ts = sorted((times.get_test_time(test_binary, test), test_binary, test)
               for (_, test_binary, test, _) in tests
               if times.get_test_time(test_binary, test) is not None)
   for (time_ms, test_binary, test) in ts:
     print "%8s %s" % ("%dms" % time_ms, test)
 
 test_results.dump_to_file_and_close()
 sys.exit(-signal.SIGINT if sigint_handler.got_sigint() else exit_code)