apk-based test runner work for android

build/android/run_tests.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 all the native unit tests.
 
 1. Copy over test binary to /data/local on device.
 2. Resources: chrome/unit_tests requires resources (chrome.pak and en-US.pak)
    to be deployed to the device (in /data/local/tmp).
@@ skipping 52 matching lines @@
 import emulator
 import run_tests_helper
 from single_test_runner import SingleTestRunner
 from test_package_executable import TestPackageExecutable
 from test_result import BaseTestResult, TestResults
 
 _TEST_SUITES = ['base_unittests', 'sql_unittests', 'ipc_tests', 'net_unittests',
                 'sync_unit_tests', 'content_unittests']
 
 
-def FullyQualifiedTestSuites():
-  """Return a fully qualified list that represents all known suites."""
+def FullyQualifiedTestSuites(apk):
+  """Return a fully qualified list that represents all known suites.
+
+  Args:
+    apk: if True, use the apk-based test runner"""
   # If not specified, assume the test suites are in out/Release
   test_suite_dir = os.path.abspath(os.path.join(run_tests_helper.CHROME_DIR,
                                                 'out', 'Release'))
-  return [os.path.join(test_suite_dir, t) for t in _TEST_SUITES]
+  if apk:
+    # out/Release/$SUITE_apk/ChromeNativeTests-debug.apk
+    suites = [os.path.join(test_suite_dir,
+                           t + '_apk',
+                           'ChromeNativeTests-debug.apk')
+              for t in _TEST_SUITES]
+  else:
+    suites = [os.path.join(test_suite_dir, t) for t in _TEST_SUITES]
+  return suites
 
 
 class TimeProfile(object):
   """Class for simple profiling of action, with logging of cost."""
 
   def __init__(self, description):
     self._description = description
     self.Start()
 
   def Start(self):
@@ skipping 48 matching lines @@
       try:
         os.kill(self._pid, signal.SIGKILL)
       except:
         pass
       del os.environ['DISPLAY']
       self._pid = 0
 
 
 def RunTests(device, test_suite, gtest_filter, test_arguments, rebaseline,
              timeout, performance_test, cleanup_test_files, tool,
-             log_dump_name, annotate=False):
+             log_dump_name, apk, annotate=False):
   """Runs the tests.
 
   Args:
     device: Device to run the tests.
     test_suite: A specific test suite to run, empty to run all.
     gtest_filter: A gtest_filter flag.
     test_arguments: Additional arguments to pass to the test binary.
     rebaseline: Whether or not to run tests in isolation and update the filter.
     timeout: Timeout for each test.
     performance_test: Whether or not performance test(s).
     cleanup_test_files: Whether or not to cleanup test files on device.
     tool: Name of the Valgrind tool.
     log_dump_name: Name of log dump file.
+    apk: boolean to state if we are using the apk based test runner
     annotate: should we print buildbot-style annotations?
 
   Returns:
     A TestResults object.
   """
   results = []
 
   if test_suite:
     global _TEST_SUITES
-    if not os.path.exists(test_suite):
+    if (not os.path.exists(test_suite) and
+        not os.path.splitext(test_suite)[1] == '.apk'):
       logging.critical('Unrecognized test suite %s, supported: %s' %
                        (test_suite, _TEST_SUITES))
       if test_suite in _TEST_SUITES:
         logging.critical('(Remember to include the path: out/Release/%s)',
                          test_suite)
-      return TestResults.FromOkAndFailed([], [BaseTestResult(test_suite, '')])
+      return TestResults.FromOkAndFailed([], [BaseTestResult(test_suite, '')],
+                                         False, False)
     fully_qualified_test_suites = [test_suite]
   else:
-    fully_qualified_test_suites = FullyQualifiedTestSuites()
+    fully_qualified_test_suites = FullyQualifiedTestSuites(apk)
   debug_info_list = []
   print 'Known suites: ' + str(_TEST_SUITES)
   print 'Running these: ' + str(fully_qualified_test_suites)
   for t in fully_qualified_test_suites:
     if annotate:
       print '@@@BUILD_STEP Test suite %s@@@' % os.path.basename(t)
     test = SingleTestRunner(device, t, gtest_filter, test_arguments,
                             timeout, rebaseline, performance_test,
                             cleanup_test_files, tool, 0, not not log_dump_name)
     test.Run()
 
     results += [test.test_results]
     # Collect debug info.
     debug_info_list += [test.dump_debug_info]
     if rebaseline:
       test.UpdateFilter(test.test_results.failed)
     elif test.test_results.failed:
       test.test_results.LogFull()
   # Zip all debug info outputs into a file named by log_dump_name.
   debug_info.GTestDebugInfo.ZipAndCleanResults(
       os.path.join(run_tests_helper.CHROME_DIR, 'out', 'Release',
           'debug_info_dumps'),
       log_dump_name, [d for d in debug_info_list if d])
 
   if annotate:
     if test.test_results.timed_out:
       print '@@@STEP_WARNINGS@@@'
     elif test.test_results.failed:
       print '@@@STEP_FAILURE@@@'
+    elif test.test_results.overall_fail:
+      print '@@@STEP_FAILURE@@@'
     else:
       print 'Step success!'  # No annotation needed
 
   return TestResults.FromTestResults(results)
 
 
 class TestSharder(BaseTestSharder):
   """Responsible for sharding the tests on the connected devices."""
 
   def __init__(self, attached_devices, test_suite, gtest_filter,
@@ skipping 90 matching lines @@
                           options.performance_test,
                           options.cleanup_test_files, options.tool)
     test_results = sharder.RunShardedTests()
   else:
     test_results = RunTests(attached_devices[0], options.test_suite,
                             options.gtest_filter, options.test_arguments,
                             options.rebaseline, options.timeout,
                             options.performance_test,
                             options.cleanup_test_files, options.tool,
                             options.log_dump,
+                            options.apk,
                             annotate=options.annotate)
 
   for buildbot_emulator in buildbot_emulators:
     buildbot_emulator.Shutdown()
 
   # Another chance if we timed out?  At this point It is safe(r) to
   # run fast and loose since we just uploaded all the test data and
   # binary.
   if test_results.timed_out and options.repeat:
     logging.critical('Timed out; repeating in fast_and_loose mode.')
@@ skipping 20 matching lines @@
     ListTestSuites()
     return 0
 
   if options.use_xvfb:
     xvfb = Xvfb()
     xvfb.Start()
 
   if options.test_suite:
     all_test_suites = [options.test_suite]
   else:
-    all_test_suites = FullyQualifiedTestSuites()
+    all_test_suites = FullyQualifiedTestSuites(options.apk)
   failures = 0
   for suite in all_test_suites:
     options.test_suite = suite
     failures += _RunATestSuite(options)
 
   if options.use_xvfb:
     xvfb.Stop()
   return failures
 
 
@@ skipping 41 matching lines @@
                            'tests that hang to add to the disabled list, '
                            'there is no need to redeploy the test binary '
                            'or data to the device again.  '
                            'Don\'t use on bots by default!')
   option_parser.add_option('--repeat', dest='repeat', type='int',
                            default=2,
                            help='Repeat count on test timeout')
   option_parser.add_option('--annotate', default=True,
                            help='Print buildbot-style annotate messages '
                            'for each test suite.  Default=True')
+  option_parser.add_option('--apk', default=False,
+                           help='Use the apk test runner '
+                           '(off by default for now)')
   options, args = option_parser.parse_args(argv)
   if len(args) > 1:
     print 'Unknown argument:', args[1:]
     option_parser.print_usage()
     sys.exit(1)
   run_tests_helper.SetLogLevel(options.verbose_count)
   return Dispatch(options)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))