[Android] Upstream changes to android_testrunner.

third_party/android_testrunner/adb_interface.py

 #!/usr/bin/python2.4
 #
 #
 # Copyright 2008, The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #     http://www.apache.org/licenses/LICENSE-2.0
@@ skipping 158 matching lines @@
     Equivalent to StartInstrumentation, except instrumentation path is
     separated into its package and runner components.
     """
     instrumentation_path = "%s/%s" % (package_name, runner_name)
     return self.StartInstrumentation(instrumentation_path, timeout_time=timeout_time,
                                      no_window_animation=no_window_animation,
                                      instrumentation_args=instrumentation_args)
 
   def StartInstrumentation(
       self, instrumentation_path, timeout_time=60*10, no_window_animation=False,
-      profile=False, instrumentation_args={}):
+      profile=False, instrumentation_args={}, silent_log=False):
 
     """Runs an instrumentation class on the target.
 
     Returns a dictionary containing the key value pairs from the
     instrumentations result bundle and a list of TestResults. Also handles the
     interpreting of error output from the device and raises the necessary
     exceptions.
 
     Args:
       instrumentation_path: string. It should be the fully classified package
       name, and instrumentation test runner, separated by "/"
         e.g. com.android.globaltimelaunch/.GlobalTimeLaunch
       timeout_time: Timeout value for the am command.
       no_window_animation: boolean, Whether you want window animations enabled
         or disabled
       profile: If True, profiling will be turned on for the instrumentation.
       instrumentation_args: Dictionary of key value bundle arguments to pass to
       instrumentation.
+      silent_log: If True, the invocation of the instrumentation test runner
+        will not be logged.
 
     Returns:
       (test_results, inst_finished_bundle)
 
       test_results: a list of TestResults
       inst_finished_bundle (dict): Key/value pairs contained in the bundle that
         is passed into ActivityManager.finishInstrumentation(). Included in this
         bundle is the return code of the Instrumentation process, any error
         codes reported by the activity manager, and any results explicitly added
         by the instrumentation code.
 
      Raises:
        WaitForResponseTimedOutError: if timeout occurred while waiting for
          response to adb instrument command
        DeviceUnresponsiveError: if device system process is not responding
        InstrumentationError: if instrumentation failed to run
     """
 
     command_string = self._BuildInstrumentationCommandPath(
         instrumentation_path, no_window_animation=no_window_animation,
         profile=profile, raw_mode=True,
         instrumentation_args=instrumentation_args)
-    logger.Log(command_string)
+    if silent_log:
+      logger.SilentLog(command_string)
+    else:
+      logger.Log(command_string)
     (test_results, inst_finished_bundle) = (
         am_instrument_parser.ParseAmInstrumentOutput(
             self.SendShellCommand(command_string, timeout_time=timeout_time,
                                   retry_count=2)))
-
     if "code" not in inst_finished_bundle:
+      logger.Log('No code available. inst_finished_bundle contains: %s '
+                 % inst_finished_bundle)
       raise errors.InstrumentationError("no test results... device setup "
                                         "correctly?")
 
     if inst_finished_bundle["code"] == "0":
-      short_msg_result = "no error message"
-      if "shortMsg" in inst_finished_bundle:
-        short_msg_result = inst_finished_bundle["shortMsg"]
-        logger.Log("Error! Test run failed: %s" % short_msg_result)
-      raise errors.InstrumentationError(short_msg_result)
+      long_msg_result = "no error message"
+      if "longMsg" in inst_finished_bundle:
+        long_msg_result = inst_finished_bundle["longMsg"]
+        logger.Log("Error! Test run failed: %s" % long_msg_result)
+      raise errors.InstrumentationError(long_msg_result)
 
     if "INSTRUMENTATION_ABORTED" in inst_finished_bundle:
       logger.Log("INSTRUMENTATION ABORTED!")
       raise errors.DeviceUnresponsiveError
 
     return (test_results, inst_finished_bundle)
 
   def StartInstrumentationNoResults(
       self, package_name, runner_name, no_window_animation=False,
       raw_mode=False, instrumentation_args={}):
@@ skipping 252 matching lines @@
       # press the MENU key, this will disable key guard if runtime is started
       # with ro.monkey set to 1
       self.SendShellCommand("input keyevent 82", retry_count=retry_count)
     else:
       self.WaitForDevicePm()
     return output
 
   def GetSerialNumber(self):
     """Returns the serial number of the targeted device."""
     return self.SendCommand("get-serialno").strip()