Update unit test file format.

mojo/tools/test_runner.py

 #!/usr/bin/env python
 # Copyright 2014 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.
 
 """A "smart" test runner for gtest unit tests (that caches successes)."""
 
 import argparse
+import json
 import logging
 import os
 import platform
 import subprocess
 import sys
 
 _logging = logging.getLogger()
 
 from mopy.paths import Paths
 from mopy.transitive_hash import file_hash, transitive_hash
@@ skipping 16 matching lines @@
   parser.add_argument("gtest_list_file",
                       help="The file containing the tests to run.")
   parser.add_argument("root_dir", help="The build directory.")
   parser.add_argument("successes_cache_filename",
                       help="The file caching test results.", default=None,
                       nargs='?')
   args = parser.parse_args()
 
   _logging.debug("Test list file: %s", args.gtest_list_file)
   with open(args.gtest_list_file, 'rb') as f:
-    gtest_list = [y for y in [x.strip() for x in f.readlines()] \
-                      if y and y[0] != '#']
+    stripped_file = ''.join(
+        [l for l in f.readlines() if not l.lstrip().startswith('#')])

[viettrungluu, 2014/12/03 16:15:37]

I see.

Rather than doing something weird, why don't you just say that the file should
be a valid Python dictionary and eval() it (like gyp)?

(Then you'll get proper comments, including same-line comments, and trailing
commas in dictionaries/lists.)

[qsr, 2014/12/03 16:38:32]

Done.

+    gtest_list = json.loads(stripped_file)
   _logging.debug("Test list: %s" % gtest_list)
 
   print "Running tests in directory: %s" % args.root_dir
   os.chdir(args.root_dir)
 
   if args.successes_cache_filename:
     print "Successes cache file: %s" % args.successes_cache_filename
   else:
     print "No successes cache file (will run all tests unconditionally)"
 
@@ skipping 14 matching lines @@
 
   # Run gtests with color if we're on a TTY (and we're not being told explicitly
   # what to do).
   if sys.stdout.isatty() and 'GTEST_COLOR' not in os.environ:
     _logging.debug("Setting GTEST_COLOR=yes")
     os.environ['GTEST_COLOR'] = 'yes'
 
   # TODO(vtl): We may not close this file on failure.
   successes_cache_file = open(args.successes_cache_filename, 'ab') \
       if args.successes_cache_filename else None
-  for gtest in gtest_list:
-    if gtest[0] == '*':
-      gtest = gtest[1:]
+  for gtest_dict in gtest_list:
+    if gtest_dict.get("disabled"):
+      continue
+    if args.android and not gtest_dict.get("run_on_android"):

[viettrungluu, 2014/12/03 16:15:37]

Having arbitrary/hacky entries like run_on_android kind of speaks to why having
a non-programmatic test list format is doomed to failure. (It's not a successful
format if you have to keep on modifying the consumer(s) of the list to support
various conditions.)

Soon-ish, I want to extract the higher-level list out of get_test_list.py into
something that's exec'ed in Python, which will provide a cleaner programmatic
model and separation between (programmatic) "data" and code.

For now, I can live with this sort of thing (except we shouldn't bother with
pretending that it's JSON), but it's not really that much (if any) better than
just embedding the test list directly in this file....

+      continue
+
+    gtest = gtest_dict["test"]
+    cacheable = gtest_dict.get("cacheable", True)
+    if not cacheable:
       _logging.debug("%s is marked as non-cacheable" % gtest)
-      cacheable = False
-    else:
-      cacheable = True
 
     gtest_file = gtest
     if platform.system() == 'Windows':
       gtest_file += ".exe"
     if args.android:
       gtest_file = gtest + "_apk/" + gtest + "-debug.apk"
 
     if successes_cache_file and cacheable:
       _logging.debug("Getting transitive hash for %s ... " % gtest)
       try:
@@ skipping 42 matching lines @@
       print "  Failed to start test"
       return 1
   print "All tests succeeded"
   if successes_cache_file:
     successes_cache_file.close()
 
   return 0
 
 if __name__ == '__main__':
   sys.exit(main())