Modify the Android test running scripts so they can be used from WebKit

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)
@@ skipping 44 matching lines @@
 import optparse
 import os
 import signal
 import subprocess
 import sys
 import time
 
 from pylib import android_commands
 from pylib.base_test_sharder import BaseTestSharder
 from pylib import buildbot_report
+from pylib import cmd_helper
 from pylib import constants
 from pylib import debug_info
 import emulator
 from pylib import ports
 from pylib import run_tests_helper
 from pylib import test_options_parser
 from pylib.single_test_runner import SingleTestRunner
 from pylib.test_result import BaseTestResult, TestResults
 
 
 _TEST_SUITES = ['base_unittests',
                 'cc_unittests',
                 'content_unittests',
                 'gpu_unittests',
                 'ipc_tests',
                 'media_unittests',
                 'net_unittests',
                 'sql_unittests',
                 'sync_unit_tests',
                 'ui_unittests',
                 'unit_tests',
                 'webkit_compositor_bindings_unittests',
                ]
 
 
-def TestSuiteDir(build_type):
-  """Return the base directory of test suites."""
-  return os.path.abspath(os.path.join(constants.CHROME_DIR, 'out', build_type))
-
 def FullyQualifiedTestSuites(exe, option_test_suite, build_type):
   """Return a fully qualified list
 
   Args:
     exe: if True, use the executable-based test runner.
     option_test_suite: the test_suite specified as an option.
     build_type: 'Release' or 'Debug'.
   """
-  test_suite_dir = TestSuiteDir(build_type)
+  test_suite_dir = os.path.join(cmd_helper.OutDirectory(), build_type)
   if option_test_suite:
     all_test_suites = [option_test_suite]
   else:
     all_test_suites = _TEST_SUITES
 
   if exe:
     qualified_test_suites = [os.path.join(test_suite_dir, t)
                              for t in all_test_suites]
   else:
     # out/(Debug|Release)/$SUITE_apk/$SUITE-debug.apk
@@ skipping 75 matching lines @@
       del os.environ['DISPLAY']
       self._pid = 0
 
 
 class TestSharder(BaseTestSharder):
   """Responsible for sharding the tests on the connected devices."""
 
   def __init__(self, attached_devices, test_suite, gtest_filter,
                test_arguments, timeout, rebaseline, performance_test,
                cleanup_test_files, tool, log_dump_name, fast_and_loose,
-               build_type):
+               build_type, in_webkit_checkout):
     BaseTestSharder.__init__(self, attached_devices, build_type)
     self.test_suite = test_suite
     self.test_suite_basename = os.path.basename(test_suite)
     self.gtest_filter = gtest_filter or ''
     self.test_arguments = test_arguments
     self.timeout = timeout
     self.rebaseline = rebaseline
     self.performance_test = performance_test
     self.cleanup_test_files = cleanup_test_files
     self.tool = tool
     self.log_dump_name = log_dump_name
     self.fast_and_loose = fast_and_loose
     self.build_type = build_type
+    self.in_webkit_checkout = in_webkit_checkout
     self.tests = []
     if not self.gtest_filter:
       # No filter has been specified, let's add all tests then.
       self.tests, self.attached_devices = self._GetTests()
 
   def _GetTests(self):
     """Returns a tuple of (all_tests, available_devices).
 
     Tries to obtain the list of available tests.
     Raises Exception if all devices failed.
     """
     available_devices = list(self.attached_devices)
     while available_devices:
       try:
         logging.info('Obtaining tests from %s', available_devices[-1])
         all_tests = self._GetTestsFromDevice(available_devices[-1])
         return all_tests, available_devices
       except Exception as e:
         logging.info('Failed obtaining tests from %s %s',
                      available_devices[-1], e)
         available_devices.pop()
     raise Exception('No device available to get the list of tests.')
 
   def _GetTestsFromDevice(self, device):
     test = SingleTestRunner(device, self.test_suite, self.gtest_filter,
                             self.test_arguments, self.timeout, self.rebaseline,
                             self.performance_test, self.cleanup_test_files,
                             self.tool, 0,
                             not not self.log_dump_name, self.fast_and_loose,
-                            self.build_type)
+                            self.build_type, self.in_webkit_checkout)
     # The executable/apk needs to be copied before we can call GetAllTests.
     test.test_package.StripAndCopyExecutable()
     all_tests = test.test_package.GetAllTests()
     if not self.rebaseline:
       disabled_list = test.GetDisabledTests()
       # Only includes tests that do not have any match in the disabled list.
       all_tests = filter(lambda t:
                          not any([fnmatch.fnmatch(t, disabled_pattern)
                                   for disabled_pattern in disabled_list]),
                          all_tests)
@@ skipping 11 matching lines @@
     """
     device_num = len(self.attached_devices)
     shard_size = (len(self.tests) + device_num - 1) / device_num
     shard_test_list = self.tests[index * shard_size : (index + 1) * shard_size]
     test_filter = ':'.join(shard_test_list) + self.gtest_filter
     return SingleTestRunner(device, self.test_suite,
                             test_filter, self.test_arguments, self.timeout,
                             self.rebaseline, self.performance_test,
                             self.cleanup_test_files, self.tool, index,
                             not not self.log_dump_name, self.fast_and_loose,
-                            self.build_type)
+                            self.build_type, self.in_webkit_checkout)
 
   def OnTestsCompleted(self, test_runners, test_results):
     """Notifies that we completed the tests."""
     test_results.LogFull('Unit test', os.path.basename(self.test_suite),
                          self.build_type, self.tests)
     test_results.PrintAnnotation()
     if test_results.failed and self.rebaseline:
       test_runners[0].UpdateFilter(test_results.failed)
     if self.log_dump_name:
       # Zip all debug info outputs into a file named by log_dump_name.
       debug_info.GTestDebugInfo.ZipAndCleanResults(
-          os.path.join(TestSuiteDir(self.build_type), 'debug_info_dumps'),
+          os.path.join(cmd_helper.OutDirectory(), self.build_type,
+              'debug_info_dumps'),
           self.log_dump_name)
 
 
 def _RunATestSuite(options):
   """Run a single test suite.
 
   Helper for Dispatch() to allow stop/restart of the emulator across
   test bundles.  If using the emulator, we start it on entry and stop
   it on exit.
 
@@ skipping 40 matching lines @@
 
   if options.performance_test or options.gtest_filter:
     # These configuration can't be split in multiple devices.
     attached_devices = [attached_devices[0]]
   sharder = TestSharder(attached_devices, options.test_suite,
                         options.gtest_filter, options.test_arguments,
                         options.timeout, options.rebaseline,
                         options.performance_test,
                         options.cleanup_test_files, options.tool,
                         options.log_dump, options.fast_and_loose,
-                        options.build_type)
+                        options.build_type, options.webkit)
   test_results = sharder.RunShardedTests()
 
   for buildbot_emulator in buildbot_emulators:
     buildbot_emulator.Shutdown()
 
   return len(test_results.failed)
 
 
 def Dispatch(options):
   """Dispatches the tests, sharding if possible.
@@ skipping 35 matching lines @@
   for test_suite in _TEST_SUITES:
     print test_suite
 
 
 def main(argv):
   option_parser = optparse.OptionParser()
   test_options_parser.AddTestRunnerOptions(option_parser, default_timeout=0)
   option_parser.add_option('-s', '--suite', dest='test_suite',
                            help='Executable name of the test suite to run '
                            '(use -s help to list them)')
+  option_parser.add_option('--out-directory', dest='out_directory',
+                           help='Path to the out/ directory, ambiguous of the '

[bulach, 2012/11/15 01:06:39]

s/ambiguous/irrespective/

[Peter Beverloo, 2012/11/15 12:11:29]

Done.

+                           'build type. Only necessary for non-Chromium uses.')
   option_parser.add_option('-d', '--device', dest='test_device',
                            help='Target device the test suite to run ')
   option_parser.add_option('-r', dest='rebaseline',
                            help='Rebaseline and update *testsuite_disabled',
                            action='store_true')
   option_parser.add_option('-f', '--gtest_filter', dest='gtest_filter',
                            help='gtest filter')
   option_parser.add_option('-a', '--test_arguments', dest='test_arguments',
                            help='Additional arguments to pass to the test')
   option_parser.add_option('-p', dest='performance_test',
                            help='Indicator of performance test',
                            action='store_true')
   option_parser.add_option('-L', dest='log_dump',
                            help='file name of log dump, which will be put in '
                            'subfolder debug_info_dumps under the same '
                            'directory in where the test_suite exists.')
   option_parser.add_option('-e', '--emulator', dest='use_emulator',
                            action='store_true',
                            help='Run tests in a new instance of emulator')
   option_parser.add_option('-n', '--emulator_count',
                            type='int', default=1,
                            help='Number of emulators to launch for running the '
                            'tests.')
   option_parser.add_option('-x', '--xvfb', dest='use_xvfb',
                            action='store_true',
                            help='Use Xvfb around tests (ignored if not Linux)')
+  option_parser.add_option('--webkit', action='store_true',
+                           help='Run the tests from a WebKit checkout.')
   option_parser.add_option('--fast', '--fast_and_loose', dest='fast_and_loose',
                            action='store_true',
                            help='Go faster (but be less stable), '
                            'for quick testing.  Example: when tracking down '
                            '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('--exit_code', action='store_true',
                            help='If set, the exit code will be total number '
                            'of failures.')
   option_parser.add_option('--exe', action='store_true',
                            help='If set, use the exe test runner instead of '
                            'the APK.')
 
   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)
+  if options.out_directory:

[bulach, 2012/11/15 01:06:39]

see above: I was thinking that the caller coud set this up when running rather
than setting the env internally here...
if we're passing the command line anyways, no need to mess up with the
environment..

[Peter Beverloo, 2012/11/15 12:11:29]

As replied earlier on: amended.

+    os.environ['ANDROID_TEST_OUT_DIRECTORY'] = options.out_directory
   emulator.DeleteAllTempAVDs()
   failed_tests_count = Dispatch(options)
 
   # Failures of individual test suites are communicated by printing a
   # STEP_FAILURE message.
   # Returning a success exit status also prevents the buildbot from incorrectly
   # marking the last suite as failed if there were failures in other suites in
   # the batch (this happens because the exit status is a sum of all failures
   # from all suites, but the buildbot associates the exit status only with the
   # most recent step).
   if options.exit_code:
     return failed_tests_count
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))