Updates the test runner script exit codes

build/android/buildbot/bb_device_steps.py

 #!/usr/bin/env python
 # 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.
 
 import collections
 import glob
 import multiprocessing
 import os
 import shutil
 import sys
 
 import bb_utils
+import bb_annotations
 
 sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
 from pylib import android_commands
-from pylib import buildbot_report
 from pylib import constants
 from pylib.gtest import gtest_config
 
 sys.path.append(os.path.join(
     constants.DIR_SOURCE_ROOT, 'third_party', 'android_testrunner'))
 import errors
 
 
 CHROME_SRC = constants.DIR_SOURCE_ROOT
 LOGCAT_DIR = os.path.join(CHROME_SRC, 'out', 'logcat')
@@ skipping 59 matching lines @@
   print 'Rebooting: %s' % devices
   if devices:
     pool = multiprocessing.Pool(len(devices))
     results = pool.map_async(RebootDeviceSafe, devices).get(99999)
 
     for device, result in zip(devices, results):
       if result:
         print '%s failed to startup.' % device
 
     if any(results):
-      buildbot_report.PrintWarning()
+      bb_annotations.PrintWarning()
     else:
       print 'Reboots complete.'
 
 
 def RunTestSuites(options, suites):
   """Manages an invocation of test_runner.py for gtests.
 
   Args:
     options: options object.
     suites: List of suites to run.
   """
   args = ['--verbose']
   if options.target == 'Release':
     args.append('--release')
   if options.asan:
     args.append('--tool=asan')
   for suite in suites:
-    buildbot_report.PrintNamedStep(suite.name)
+    bb_annotations.PrintNamedStep(suite.name)
     cmd = ['build/android/test_runner.py', 'gtest', '-s', suite.name] + args
     if suite.is_suite_exe:
       cmd.append('--exe')
     RunCmd(cmd)
 
 def RunBrowserTestSuite(options):
   """Manages an invocation of test_runner.py for content_browsertests.
 
   Args:
     options: options object.
   """
   args = ['--verbose', '--num_retries=1']
   if options.target == 'Release':
     args.append('--release')
   if options.asan:
     args.append('--tool=asan')
-  buildbot_report.PrintNamedStep(constants.BROWSERTEST_SUITE_NAME)
+  bb_annotations.PrintNamedStep(constants.BROWSERTEST_SUITE_NAME)
   RunCmd(['build/android/test_runner.py', 'content_browsertests'] + args)
 
 def RunChromeDriverTests(_):
   """Run all the steps for running chromedriver tests."""
-  buildbot_report.PrintNamedStep('chromedriver_annotation')
+  bb_annotations.PrintNamedStep('chromedriver_annotation')
   RunCmd(['chrome/test/chromedriver/run_buildbot_steps.py',
           '--android-package=%s' % constants.CHROMIUM_TEST_SHELL_PACKAGE])
 
 def InstallApk(options, test, print_step=False):
   """Install an apk to all phones.
 
   Args:
     options: options object
     test: An I_TEST namedtuple
     print_step: Print a buildbot step
   """
   if print_step:
-    buildbot_report.PrintNamedStep('install_%s' % test.name.lower())
+    bb_annotations.PrintNamedStep('install_%s' % test.name.lower())
   args = ['--apk', test.apk, '--apk_package', test.apk_package]
   if options.target == 'Release':
     args.append('--release')
 
   RunCmd(['build/android/adb_install_apk.py'] + args, halt_on_failure=True)
 
 
 def RunInstrumentationSuite(options, test):
   """Manages an invocation of test_runner.py for instrumentation tests.
 
   Args:
     options: options object
     test: An I_TEST namedtuple
   """
-  buildbot_report.PrintNamedStep('%s_instrumentation_tests' % test.name.lower())
+  bb_annotations.PrintNamedStep('%s_instrumentation_tests' % test.name.lower())
 
   InstallApk(options, test)
   args = ['--test-apk', test.test_apk, '--test_data', test.test_data,
           '--verbose', '-I']
   if options.target == 'Release':
     args.append('--release')
   if options.asan:
     args.append('--tool=asan')
   if options.upload_to_flakiness_server:
     args.append('--flakiness-dashboard-server=%s' %
                 constants.UPSTREAM_FLAKINESS_SERVER)
   if test.host_driven_root:
     args.append('--python_test_root=%s' % test.host_driven_root)
   if test.annotation:
     args.extend(['-A', test.annotation])
   if test.exclude_annotation:
     args.extend(['-E', test.exclude_annotation])
   if test.extra_flags:
     args.extend(test.extra_flags)
 
   RunCmd(['build/android/test_runner.py', 'instrumentation'] + args)
 
 
 def RunWebkitLint(target):
   """Lint WebKit's TestExpectation files."""
-  buildbot_report.PrintNamedStep('webkit_lint')
+  bb_annotations.PrintNamedStep('webkit_lint')
   RunCmd(['webkit/tools/layout_tests/run_webkit_tests.py',
           '--lint-test-files',
           '--chromium',
           '--target', target])
 
 
 def RunWebkitLayoutTests(options):
   """Run layout tests on an actual device."""
-  buildbot_report.PrintNamedStep('webkit_tests')
+  bb_annotations.PrintNamedStep('webkit_tests')
   cmd_args = [
         '--no-show-results',
         '--no-new-test-results',
         '--full-results-html',
         '--clobber-old-results',
         '--exit-after-n-failures', '5000',
         '--exit-after-n-crashes-or-timeouts', '100',
         '--debug-rwt-logging',
         '--results-directory', '..layout-test-results',
         '--target', options.target,
@@ skipping 30 matching lines @@
 
   # Wait for logcat_monitor to pull existing logcat
   RunCmd(['sleep', '5'])
 
 def ProvisionDevices(options):
   # Restart adb to work around bugs, sleep to wait for usb discovery.
   RunCmd(['adb', 'kill-server'])
   RunCmd(['adb', 'start-server'])
   RunCmd(['sleep', '1'])
 
-  buildbot_report.PrintNamedStep('provision_devices')
+  bb_annotations.PrintNamedStep('provision_devices')
   if options.reboot:
     RebootDevices()
   RunCmd(['build/android/provision_devices.py', '-t', options.target])
 
 
 def DeviceStatusCheck(_):
-  buildbot_report.PrintNamedStep('device_status_check')
+  bb_annotations.PrintNamedStep('device_status_check')
   RunCmd(['build/android/device_status_check.py'], halt_on_failure=True)
 
 
 def GetDeviceSetupStepCmds():
   return [
     ('provision_devices', ProvisionDevices),
     ('device_status_check', DeviceStatusCheck)
   ]
 
 
@@ skipping 16 matching lines @@
       ('chromedriver', RunChromeDriverTests),
       ('unit', RunUnitTests),
       ('ui', RunInstrumentationTests),
       ('webkit', RunWebkitTests),
       ('webkit_layout', RunWebkitLayoutTests)
   ]
 
 
 def LogcatDump(options):
   # Print logcat, kill logcat monitor
-  buildbot_report.PrintNamedStep('logcat_dump')
+  bb_annotations.PrintNamedStep('logcat_dump')
   logcat_file = os.path.join(CHROME_SRC, 'out', options.target, 'full_log')
   with open(logcat_file, 'w') as f:
     RunCmd([
         os.path.join(CHROME_SRC, 'build', 'android', 'adb_logcat_printer.py'),
         LOGCAT_DIR], stdout=f)
   RunCmd(['cat', logcat_file])
 
 
 def GenerateTestReport(options):
-  buildbot_report.PrintNamedStep('test_report')
+  bb_annotations.PrintNamedStep('test_report')
   for report in glob.glob(
       os.path.join(CHROME_SRC, 'out', options.target, 'test_logs', '*.log')):
     RunCmd(['cat', report])
     os.remove(report)
 
 
 def GetPostTestStepCmds():
   return [
       ('logcat_dump', LogcatDump),
       ('test_report', GenerateTestReport)
@@ skipping 60 matching lines @@
   if unknown_tests:
     return sys.exit('Unknown tests %s' % list(unknown_tests))
 
   setattr(options, 'target', options.factory_properties.get('target', 'Debug'))
 
   MainTestWrapper(options)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))