Updates the test runner script exit codes

build/android/pylib/gtest/dispatch.py

 # Copyright (c) 2013 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.
 
 """Dispatches GTests."""
 
 import copy
 import fnmatch
 import logging
 import os
 
 from pylib import android_commands
 from pylib import cmd_helper
 from pylib import constants
 from pylib import ports
+from pylib.base import base_test_result
 from pylib.base import shard
 from pylib.utils import emulator
 from pylib.utils import report_results
 from pylib.utils import xvfb
 
 import gtest_config
 import test_runner
 
 
 def _FullyQualifiedTestSuites(exe, option_test_suite, build_type):
   """Get a list of absolute paths to test suite targets.
 
   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'.
 
   Returns:
     A list of tuples containing the suite and absolute path.
     Ex. ('content_unittests',
           '/tmp/chrome/src/out/Debug/content_unittests_apk/'
           'content_unittests-debug.apk')
+
+  Raises:
+    Exception: Test suite not found.

[frankf, 2013/07/03 21:26:37]

Exception if test ...

[gkanwar, 2013/07/03 23:15:18]

Done.

   """
   def GetQualifiedSuite(suite):
     if suite.is_suite_exe:
       relpath = suite.name
     else:
       # out/(Debug|Release)/$SUITE_apk/$SUITE-debug.apk
       relpath = os.path.join(suite.name + '_apk', suite.name + '-debug.apk')
     return suite.name, os.path.join(test_suite_dir, relpath)
 
   test_suite_dir = os.path.join(cmd_helper.OutDirectory.get(), build_type)
@@ skipping 38 matching lines @@
   Obtains a list of enabled tests from the test package on the device,
   then filters it again using the disabled list on the host.
 
   Args:
     runner_factory: callable that takes a devices and returns a TestRunner.
     devices: list of devices.
 
   Returns:
     List of all enabled tests.
 
-  Raises Exception if all devices failed.
+  Raises:
+    Exception: All devices failed.
   """
   for device in devices:
     try:
       logging.info('Obtaining tests from %s', device)
       runner = runner_factory(device, 0)
       return GetTestsFromDevice(runner)
     except Exception as e:
       logging.warning('Failed obtaining tests from %s with exception: %s',
                       device, e)
   raise Exception('No device available to get the list of tests.')
 
 
 def _RunATestSuite(options, suite_name):
   """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.
 
   Args:
     options: options for running the tests.
     suite_name: name of the test suite being run.
 
   Returns:
-    0 if successful, number of failing tests otherwise.
+    base_test_result.TestRunResult object with the test results
+
+  Raises:
+    Exception: Device not attached, or failed to reset test server port.
   """
   step_name = os.path.basename(options.test_suite).replace('-debug.apk', '')
   attached_devices = []
   buildbot_emulators = []
 
   if options.use_emulator:
     buildbot_emulators = emulator.LaunchEmulators(options.emulator_count,
                                                   options.abi,
                                                   wait_for_boot=True)
     attached_devices = [e.device for e in buildbot_emulators]
@@ skipping 44 matching lines @@
       results=test_results,
       test_type='Unit test',
       test_package=suite_name,
       build_type=options.build_type,
       flakiness_server=options.flakiness_dashboard_server)
   report_results.PrintAnnotation(test_results)
 
   for buildbot_emulator in buildbot_emulators:
     buildbot_emulator.Shutdown()
 
-  return len(test_results.GetNotPass())
+  return test_results
 
 
 def _ListTestSuites():
   """Display a list of available test suites."""
   print 'Available test suites are:'
   for test_suite in gtest_config.STABLE_TEST_SUITES:
     print test_suite
 
 
 def Dispatch(options):
   """Dispatches the tests, sharding if possible.
 
   If options.use_emulator is True, all tests will be run in new emulator
   instance.
 
   Args:
     options: options for running the tests.
 
   Returns:
-    0 if successful, number of failing tests otherwise.
+    base_test_result.TestRunResults object with the results of running the tests
   """
   if options.test_suite == 'help':
     _ListTestSuites()
     return 0
 
   if options.use_xvfb:
     framebuffer = xvfb.Xvfb()
     framebuffer.Start()
 
   all_test_suites = _FullyQualifiedTestSuites(options.exe, options.test_suite,
                                               options.build_type)
-  failures = 0
+  results = base_test_result.TestRunResults()
   for suite_name, suite_path in all_test_suites:

[frankf, 2013/07/03 21:26:37]

Future TODO: I don't think it's common workflow to run all the suites at once.
So let's make -s mandatory which is consistant with how instrumentation tests
are run as well.

     # Give each test suite its own copy of options.
     test_options = copy.deepcopy(options)
     test_options.test_suite = suite_path
-    failures += _RunATestSuite(test_options, suite_name)
+    results.AddTestRunResults(_RunATestSuite(test_options, suite_name))
 
   if options.use_xvfb:
     framebuffer.Stop()
-  return failures
+
+  return results