Add infrastructure to run tests on android.

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 logging
 import os
 import platform
 import subprocess
 import sys
 
 _logging = logging.getLogger()
 
+from mopy.paths import Paths
 from mopy.transitive_hash import transitive_hash
 
-def main(argv):
+paths = Paths()
+
+def main():
   logging.basicConfig()
   # Uncomment to debug:
   # _logging.setLevel(logging.DEBUG)
 
-  if len(argv) < 3 or len(argv) > 4:
-    print "Usage: %s gtest_list_file root_dir [successes_cache_file]" % \
-        os.path.basename(argv[0])
-    return 0 if len(argv) < 2 else 1
+  parser = argparse.ArgumentParser(
+      description="A 'smart' test runner for gtest unit tests (that caches "
+                  "successes).")
 
-  _logging.debug("Test list file: %s", argv[1])
-  with open(argv[1], 'rb') as f:
+  debug_group = parser.add_mutually_exclusive_group()
+  debug_group.add_argument('--debug', help='Debug build (default)',

[viettrungluu, 2014/11/14 16:36:32]

By design, this should not know about
debug/release/asan/whatever-other-config-you-might-come-up-with.

+                           default=True, action='store_true')
+  debug_group.add_argument('--release', help='Release build', default=False,
+                           dest='debug', action='store_false')
+
+  os_group = parser.add_mutually_exclusive_group()
+  os_group.add_argument("--android", help="Run tests for android",

[viettrungluu, 2014/11/14 16:36:32]

It probably shouldn't have knowledge of android either. You should come up with
a more general way of plumbing in what's required.

[qsr, 2014/11/14 17:02:33]

 Hum. Running unit test on android is not the same as on other platform. You
cannot just run an executable. We have a test_runner script that handles this. I
guess I can build a script that will call the script, but I still need to know
that it is an android build to check what the apk is and if it changed.

 Also, note that this script is already doing some check on platform.system()
but we cannot do the same for android because we are cross-compiling.

+                        action='store_true')
+
+  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] != '#']
   _logging.debug("Test list: %s" % gtest_list)
 
-  print "Running tests in directory: %s" % argv[2]
-  os.chdir(argv[2])
+  print "Running tests in directory: %s" % args.root_dir
+  os.chdir(args.root_dir)
 
-  if len(argv) == 4 and argv[3]:
-    successes_cache_filename = argv[3]
-    print "Successes cache file: %s" % successes_cache_filename
+  if args.successes_cache_filename:
+    print "Successes cache file: %s" % args.successes_cache_filename
   else:
-    successes_cache_filename = None
     print "No successes cache file (will run all tests unconditionally)"
 
-  if successes_cache_filename:
+  if args.successes_cache_filename:
     # This file simply contains a list of transitive hashes of tests that
     # succeeded.
     try:
       _logging.debug("Trying to read successes cache file: %s",
-                     successes_cache_filename)
-      with open(argv[3], 'rb') as f:
+                     args.successes_cache_filename)
+      with open(args.successes_cache_filename, 'rb') as f:
         successes = set([x.strip() for x in f.readlines()])
       _logging.debug("Successes: %s", successes)
     except IOError:
       # Just assume that it didn't exist, or whatever.
-      print "Failed to read successes cache file %s (will create)" % argv[3]
+      print ("Failed to read successes cache file %s (will create)" %
+             args.successes_cache_filename)
       successes = set()
 
   # 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(successes_cache_filename, 'ab') \
-      if successes_cache_filename else None
+  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:]
       _logging.debug("%s is marked as non-cacheable" % gtest)
       cacheable = False
     else:
       cacheable = True
 
+    gtest_file = gtest
     if platform.system() == 'Windows':
-      gtest += ".exe"
+      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:
-        gtest_hash = transitive_hash(gtest)
+        gtest_hash = transitive_hash(gtest_file, not args.android)
       except subprocess.CalledProcessError:
         print "Failed to get transitive hash for %s" % gtest
         return 1
       _logging.debug("  Transitive hash: %s" % gtest_hash)
 
       if gtest_hash in successes:
         print "Skipping %s (previously succeeded)" % gtest
         continue
 
     print "Running %s...." % gtest,
     sys.stdout.flush()
     try:
-      subprocess.check_output(["./" + gtest], stderr=subprocess.STDOUT)
+      if args.android:
+        command = [ "python" ]
+        command.append(os.path.join(paths.src_root,
+                                    "build", "android", "test_runner.py"))
+        command.append("gtest")
+        command.append("--output-directory")
+        command.append(args.root_dir)
+        command.append("-s")
+        command.append(gtest)
+        command.append('--debug' if args.debug else '--release')
+      else:
+        command = [ "./" + gtest ]
+      subprocess.check_output(command, stderr=subprocess.STDOUT)
       print "Succeeded"
       # Record success.
-      if successes_cache_filename and cacheable:
+      if args.successes_cache_filename and cacheable:
         successes.add(gtest_hash)
         successes_cache_file.write(gtest_hash + '\n')
         successes_cache_file.flush()
     except subprocess.CalledProcessError as e:
       print "Failed with exit code %d and output:" % e.returncode
       print 72 * '-'
       print e.output
       print 72 * '-'
       return 1
     except OSError as e:
       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(sys.argv))
+  sys.exit(main())