Change Android build configurations (step 2).

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 64 matching lines @@
                 'ipc_tests',
                 'media_unittests',
                 'net_unittests',
                 'sql_unittests',
                 'sync_unit_tests',
                 'ui_unittests',
                 'unit_tests',
                ]
 
 
-def FullyQualifiedTestSuites(exe, option_test_suite):
+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'.
   """
-  # Assume the test suites are in out/Release.
-  test_suite_dir = os.path.abspath(os.path.join(constants.CHROME_DIR,
-                                                'out', 'Release'))
+  test_suite_dir = TestSuiteDir(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/Release/$SUITE_apk/$SUITE-debug.apk
+    # out/(Debug|Release)/$SUITE_apk/$SUITE-debug.apk
     qualified_test_suites = [os.path.join(test_suite_dir,
                                           t + '_apk',
                                           t + '-debug.apk')
                              for t in all_test_suites]
   for t, q in zip(all_test_suites, qualified_test_suites):
     if not os.path.exists(q):
       logging.critical('Test suite %s not found in %s.\n'
                        'Supported test suites:\n %s\n'
                        'Ensure it has been built.\n',
                        t, q, _TEST_SUITES)
@@ skipping 73 matching lines @@
     buildbot_report.PrintError()
   else:
     print 'Step success!'  # No annotation needed
 
 
 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):
+               cleanup_test_files, tool, log_dump_name, fast_and_loose,
+               build_type):
     BaseTestSharder.__init__(self, attached_devices)
     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
     test = SingleTestRunner(self.attached_devices[0], test_suite, gtest_filter,
                             test_arguments, timeout, rebaseline,
                             performance_test, cleanup_test_files, tool, 0,
-                            not not self.log_dump_name, fast_and_loose)
+                            not not self.log_dump_name, fast_and_loose,
+                            build_type)
     self.tests = []
     if not self.gtest_filter:
       # No filter has been specified, let's add all tests then.
       # The executable/apk needs to be copied before we can call GetAllTests.
       test.test_package.StripAndCopyExecutable()
       all_tests = test.test_package.GetAllTests()
       if not rebaseline:
         disabled_list = test.GetDisabledTests()
         # Only includes tests that do not have any match in the disabled list.
         all_tests = filter(lambda t:
@@ skipping 13 matching lines @@
       A SingleTestRunner object.
     """
     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)
+                            not not self.log_dump_name, self.fast_and_loose,
+                            self.build_type)
 
   def OnTestsCompleted(self, test_runners, test_results):
     """Notifies that we completed the tests."""
     test_results.LogFull('Unit test', os.path.basename(self.test_suite))
     PrintAnnotationForTestResults(test_results)
     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(constants.CHROME_DIR, 'out', 'Release',
-                       'debug_info_dumps'),
+          os.path.join(TestSuiteDir(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 39 matching lines @@
     raise Exception('Failed to reset test server port.')
 
   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.log_dump, options.fast_and_loose,
+                        options.build_type)
   test_results = sharder.RunShardedTests()
 
   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 17 matching lines @@
     0 if successful, number of failing tests otherwise.
   """
   if options.test_suite == 'help':
     ListTestSuites()
     return 0
 
   if options.use_xvfb:
     xvfb = Xvfb()
     xvfb.Start()
 
-  all_test_suites = FullyQualifiedTestSuites(options.exe, options.test_suite)
+  all_test_suites = FullyQualifiedTestSuites(options.exe, options.test_suite,
+                                             options.build_type)
   failures = 0
   for suite in all_test_suites:
     options.test_suite = suite
     failures += _RunATestSuite(options)
 
   if options.use_xvfb:
     xvfb.Stop()
   return failures
 
 
@@ skipping 46 matching lines @@
                            '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)
   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))