run_test_cases.py: Enable use of RUN_TEST_CASES_RESULT_FILE as environment variable.

tools/isolate/run_test_cases.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.
 
 """Runs each test cases as a single shard, single process execution.
 
 Similar to sharding_supervisor.py but finer grained. Runs multiple instances in
 parallel.
 """
 
 import fnmatch
 import json
 import logging
 import optparse
 import os
 import Queue
 import subprocess
 import sys
 import threading
 import time
 
 
+# These are known to influence the way the output is generated.
+KNOWN_GTEST_ENV_VARS = [
+  'GTEST_ALSO_RUN_DISABLED_TESTS',
+  'GTEST_BREAK_ON_FAILURE',
+  'GTEST_CATCH_EXCEPTIONS',
+  'GTEST_COLOR',
+  'GTEST_FILTER',
+  'GTEST_OUTPUT',
+  'GTEST_PRINT_TIME',
+  'GTEST_RANDOM_SEED',
+  'GTEST_REPEAT',
+  'GTEST_SHARD_INDEX',
+  'GTEST_SHARD_STATUS_FILE',
+  'GTEST_SHUFFLE',
+  'GTEST_THROW_ON_FAILURE',
+  'GTEST_TOTAL_SHARDS',
+]
+
+# These needs to be poped out before running a test.
+GTEST_ENV_VARS_TO_REMOVE = [
+  # TODO(maruel): Handle.
+  'GTEST_ALSO_RUN_DISABLED_TESTS',
+  'GTEST_FILTER',
+  # TODO(maruel): Handle.
+  'GTEST_OUTPUT',
+  # TODO(maruel): Handle.
+  'GTEST_RANDOM_SEED',
+  # TODO(maruel): Handle.
+  'GTEST_REPEAT',
+  'GTEST_SHARD_INDEX',
+  # TODO(maruel): Handle.
+  'GTEST_SHUFFLE',
+  'GTEST_TOTAL_SHARDS',
+]
+
+
 def num_processors():
   """Returns the number of processors.
 
   Python on OSX 10.6 raises a NotImplementedError exception.
   """
   try:
     # Multiprocessing
     import multiprocessing
     return multiprocessing.cpu_count()
   except:  # pylint: disable=W0702
@@ skipping 387 matching lines @@
   def __init__(self, executable, cwd_dir, timeout, progress):
     # Constants
     self.executable = executable
     self.cwd_dir = cwd_dir
     self.timeout = timeout
     self.progress = progress
     self.retry_count = 3
     # It is important to remove the shard environment variables since it could
     # conflict with --gtest_filter.
     self.env = os.environ.copy()
-    self.env.pop('GTEST_SHARD_INDEX', None)
-    self.env.pop('GTEST_TOTAL_SHARDS', None)
+    for name in GTEST_ENV_VARS_TO_REMOVE:
+      self.env.pop(name, None)
+    # Forcibly enable color by default, if not already disabled.
+    self.env.setdefault('GTEST_COLOR', 'on')
 
   def map(self, test_case):
     """Traces a single test case and returns its output."""
     cmd = [self.executable, '--gtest_filter=%s' % test_case]
     cmd = fix_python_path(cmd)
     out = []
     for retry in range(self.retry_count):
       start = time.time()
       output, returncode = call_with_timeout(
           cmd,
           self.timeout,
           cwd=self.cwd_dir,
           stderr=subprocess.STDOUT,
           env=self.env)
       duration = time.time() - start
       data = {
         'test_case': test_case,
         'returncode': returncode,
         'duration': duration,
-        'output': output,
+        # It needs to be valid utf-8 otherwise it can't be store.
+        'output': output.decode('ascii', 'ignore').encode('utf-8'),
       }
       if '[ RUN      ]' not in output:
         # Can't find gtest marker, mark it as invalid.
         returncode = returncode or 1
       out.append(data)
       if sys.platform == 'win32':
         output = output.replace('\r\n', '\n')
       size = returncode and retry != self.retry_count - 1
       if retry:
         self.progress.update_item(
@@ skipping 37 matching lines @@
     ]
   if whitelist:
     tests = [
       t for t in tests if any(fnmatch.fnmatch(t, s) for s in whitelist)
     ]
   logging.info(
       'Found %d test cases in %s' % (len(tests), os.path.basename(executable)))
   return tests
 
 
-def run_test_cases(executable, test_cases, jobs, timeout, no_dump):
+def run_test_cases(executable, test_cases, jobs, timeout, result_file):
   """Traces test cases one by one."""
   progress = Progress(len(test_cases))
   with ThreadPool(jobs) as pool:
     function = Runner(executable, os.getcwd(), timeout, progress).map
     for test_case in test_cases:
       pool.add_task(function, test_case)
     results = pool.join(progress, 0.1)
     duration = time.time() - progress.start
   results = dict((item[0]['test_case'], item) for item in results)
-  if not no_dump:
-    with open('%s.run_test_cases' % executable, 'wb') as f:
+  if result_file:
+    with open(result_file, 'wb') as f:
       json.dump(results, f, sort_keys=True, indent=2)
   sys.stdout.write('\n')
   total = len(results)
   if not total:
     return 1
 
   # Classify the results
   success = []
   flaky = []
   fail = []
@@ skipping 44 matching lines @@
       default=120,
       help='Timeout for a single test case, in seconds default:%default')
   parser.add_option(
       '-v', '--verbose',
       action='count',
       default=int(os.environ.get('ISOLATE_DEBUG', 0)),
       help='Use multiple times')
   parser.add_option(
       '--no-dump',
       action='store_true',
-      help='do not generate a .test_cases file')
+      help='do not generate a .run_test_cases file')
+  parser.add_option(
+      '--result',
+      default=os.environ.get('RUN_TEST_CASES_RESULT_FILE', ''),
+      help='Override the default name of the generated .run_test_cases file')
 
   group = optparse.OptionGroup(parser, 'Which test cases to run')
   group.add_option(
       '-w', '--whitelist',
       default=[],
       action='append',
       help='filter to apply to test cases to run, wildcard-style, defaults to '
            'all test')
   group.add_option(
       '-b', '--blacklist',
       default=[],
       action='append',
       help='filter to apply to test cases to skip, wildcard-style, defaults to '
            'no test')
   group.add_option(
       '-i', '--index',
       type='int',
       default=as_digit(os.environ.get('GTEST_SHARD_INDEX', ''), None),
       help='Shard index to run')
   group.add_option(
       '-s', '--shards',
       type='int',
       default=as_digit(os.environ.get('GTEST_TOTAL_SHARDS', ''), None),
       help='Total number of shards to calculate from the --index to run')
   group.add_option(
       '-T', '--test-case-file',
       help='File containing the exact list of test cases to run')
   group.add_option(
       '--gtest_filter',
+      default=os.environ.get('GTEST_FILTER', ''),
       help='Runs a single test, provideded to keep compatibility with '
            'other tools')
   parser.add_option_group(group)
   options, args = parser.parse_args(argv)
 
   levels = [logging.ERROR, logging.INFO, logging.DEBUG]
   logging.basicConfig(
       level=levels[min(len(levels)-1, options.verbose)],
       format='%(levelname)5s %(module)15s(%(lineno)3d): %(message)s')
 
@@ skipping 32 matching lines @@
     test_cases = get_test_cases(
         executable,
         options.whitelist,
         options.blacklist,
         options.index,
         options.shards)
 
   if not test_cases:
     return 0
 
+  if options.no_dump:
+    result_file = None
+  else:
+    if options.result:
+      result_file = options.result
+    else:
+      result_file = '%s.run_test_cases' % executable
+
   return run_test_cases(
       executable,
       test_cases,
       options.jobs,
       options.timeout,
-      options.no_dump)
+      result_file)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))