[Android] Add an out-of-app instrumentation driver APK.

build/android/pylib/instrumentation/instrumentation_test_instance.py

 # Copyright 2015 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 logging
 import os
 import pickle
 import re
 import sys
 
@@ skipping 12 matching lines @@
     os.path.join(constants.DIR_SOURCE_ROOT, 'build', 'util', 'lib', 'common'))
 import unittest_util
 
 # Ref: http://developer.android.com/reference/android/app/Activity.html
 _ACTIVITY_RESULT_CANCELED = 0
 _ACTIVITY_RESULT_OK = -1
 
 _DEFAULT_ANNOTATIONS = [
     'Smoke', 'SmallTest', 'MediumTest', 'LargeTest',
     'EnormousTest', 'IntegrationTest']
+_EXTRA_ENABLE_HTTP_SERVER = (
+    'org.chromium.chrome.test.ChromeInstrumentationTestRunner.'
+        + 'EnableTestHttpServer')
+_EXTRA_DRIVER_TEST_LIST = (
+    'org.chromium.test.driver.OnDeviceInstrumentationDriver.TestList')
+_EXTRA_DRIVER_TEST_LIST_FILE = (
+    'org.chromium.test.driver.OnDeviceInstrumentationDriver.TestListFile')
+_EXTRA_DRIVER_TARGET_PACKAGE = (
+    'org.chromium.test.driver.OnDeviceInstrumentationDriver.TargetPackage')
+_EXTRA_DRIVER_TARGET_CLASS = (
+    'org.chromium.test.driver.OnDeviceInstrumentationDriver.TargetClass')
 _NATIVE_CRASH_RE = re.compile('native crash', re.IGNORECASE)
 _PICKLE_FORMAT_VERSION = 10
 
 
 # TODO(jbudorick): Make these private class methods of
 # InstrumentationTestInstance once the instrumentation test_runner is
 # deprecated.
 def ParseAmInstrumentRawOutput(raw_output):
   """Parses the output of an |am instrument -r| call.
 
@@ skipping 80 matching lines @@
   return results
 
 
 class InstrumentationTestInstance(test_instance.TestInstance):
 
   def __init__(self, args, isolate_delegate, error_func):
     super(InstrumentationTestInstance, self).__init__()
 
     self._apk_under_test = None
     self._package_info = None
+    self._suite = None
     self._test_apk = None
     self._test_jar = None
     self._test_package = None
     self._test_runner = None
     self._test_support_apk = None
-    self.__initializeApkAttributes(args, error_func)
+    self._initializeApkAttributes(args, error_func)
 
     self._data_deps = None
     self._isolate_abs_path = None
     self._isolate_delegate = None
     self._isolated_abs_path = None
     self._test_data = None
-    self.__initializeDataDependencyAttributes(args, isolate_delegate)
+    self._initializeDataDependencyAttributes(args, isolate_delegate)
 
     self._annotations = None
     self._excluded_annotations = None
     self._test_filter = None
-    self.__initializeTestFilterAttributes(args)
+    self._initializeTestFilterAttributes(args)
 
     self._flags = None
-    self.__initializeFlagAttributes(args)
+    self._initializeFlagAttributes(args)
 
-  def __initializeApkAttributes(self, args, error_func):
+    self._driver_apk = None
+    self._driver_package = None
+    self._driver_name = None
+    self._initializeDriverAttributes()
+
+  def _initializeApkAttributes(self, args, error_func):
     if args.apk_under_test.endswith('.apk'):
       self._apk_under_test = args.apk_under_test
     else:
       self._apk_under_test = os.path.join(
           constants.GetOutDirectory(), constants.SDK_BUILD_APKS_DIR,
           '%s.apk' % args.apk_under_test)
 
     if not os.path.exists(self._apk_under_test):
       error_func('Unable to find APK under test: %s' % self._apk_under_test)
 
     if args.test_apk.endswith('.apk'):
-      test_apk_root = os.path.splitext(os.path.basename(args.test_apk))[0]
+      self._suite = os.path.splitext(os.path.basename(args.test_apk))[0]
       self._test_apk = args.test_apk
     else:
-      test_apk_root = args.test_apk
+      self._suite = args.test_apk
       self._test_apk = os.path.join(
           constants.GetOutDirectory(), constants.SDK_BUILD_APKS_DIR,
           '%s.apk' % args.test_apk)
 
     self._test_jar = os.path.join(
         constants.GetOutDirectory(), constants.SDK_BUILD_TEST_JAVALIB_DIR,
-        '%s.jar' % test_apk_root)
+        '%s.jar' % self._suite)
     self._test_support_apk = os.path.join(
         constants.GetOutDirectory(), constants.SDK_BUILD_TEST_JAVALIB_DIR,
-        '%sSupport.apk' % test_apk_root)
+        '%sSupport.apk' % self._suite)
 
     if not os.path.exists(self._test_apk):
       error_func('Unable to find test APK: %s' % self._test_apk)
     if not os.path.exists(self._test_jar):
       error_func('Unable to find test JAR: %s' % self._test_jar)
 
     self._test_package = apk_helper.GetPackageName(self.test_apk)
     self._test_runner = apk_helper.GetInstrumentationName(self.test_apk)
 
     self._package_info = None
     for package_info in constants.PACKAGE_INFO.itervalues():
       if self._test_package == package_info.test_package:
         self._package_info = package_info
     if not self._package_info:
       logging.warning('Unable to find package info for %s', self._test_package)
 
-  def __initializeDataDependencyAttributes(self, args, isolate_delegate):
+  def _initializeDataDependencyAttributes(self, args, isolate_delegate):
     self._data_deps = []
     if args.isolate_file_path:
       self._isolate_abs_path = os.path.abspath(args.isolate_file_path)
       self._isolate_delegate = isolate_delegate
       self._isolated_abs_path = os.path.join(
           constants.GetOutDirectory(), '%s.isolated' % self._test_package)
     else:
       self._isolate_delegate = None
 
     # TODO(jbudorick): Deprecate and remove --test-data once data dependencies
     # are fully converted to isolate.
     if args.test_data:
       logging.info('Data dependencies specified via --test-data')
       self._test_data = args.test_data
     else:
       self._test_data = None
 
     if not self._isolate_delegate and not self._test_data:
       logging.warning('No data dependencies will be pushed.')
 
-  def __initializeTestFilterAttributes(self, args):
+  def _initializeTestFilterAttributes(self, args):
     self._test_filter = args.test_filter
 
     def annotation_dict_element(a):
       a = a.split('=')
       return (a[0], a[1] if len(a) == 2 else None)
 
     if args.annotation_str:
       self._annotations = dict(
           annotation_dict_element(a)
           for a in args.annotation_str.split(','))
     elif not self._test_filter:
       self._annotations = dict(
           annotation_dict_element(a)
           for a in _DEFAULT_ANNOTATIONS)
     else:
       self._annotations = {}
 
     if args.exclude_annotation_str:
       self._excluded_annotations = dict(
           annotation_dict_element(a)
           for a in args.exclude_annotation_str.split(','))
     else:
       self._excluded_annotations = {}
 
-  def __initializeFlagAttributes(self, args):
+  def _initializeFlagAttributes(self, args):
     self._flags = ['--disable-fre', '--enable-test-intents']
     # TODO(jbudorick): Transition "--device-flags" to "--device-flags-file"
     if hasattr(args, 'device_flags') and args.device_flags:
       with open(args.device_flags) as device_flags_file:
         stripped_lines = (l.strip() for l in device_flags_file)
         self._flags.extend([flag for flag in stripped_lines if flag])
     if hasattr(args, 'device_flags_file') and args.device_flags_file:
       with open(args.device_flags_file) as device_flags_file:
         stripped_lines = (l.strip() for l in device_flags_file)
         self._flags.extend([flag for flag in stripped_lines if flag])
 
-  @property
-  def suite(self):
-    return 'instrumentation'
+  def _initializeDriverAttributes(self):
+    self._driver_apk = os.path.join(
+        constants.GetOutDirectory(), constants.SDK_BUILD_APKS_DIR,
+        'OnDeviceInstrumentationDriver.apk')
+    if os.path.exists(self._driver_apk):
+      self._driver_package = apk_helper.GetPackageName(
+          self._driver_apk)
+      self._driver_name = apk_helper.GetInstrumentationName(
+          self._driver_apk)
+    else:
+      self._driver_apk = None
 
   @property
   def apk_under_test(self):
     return self._apk_under_test
 
   @property
   def flags(self):
     return self._flags
 
   @property
+  def driver_apk(self):
+    return self._driver_apk
+
+  @property
+  def driver_package(self):
+    return self._driver_package
+
+  @property
+  def driver_name(self):
+    return self._driver_name
+
+  @property
   def package_info(self):
     return self._package_info
 
   @property
+  def suite(self):
+    return self._suite
+
+  @property
   def test_apk(self):
     return self._test_apk
 
   @property
   def test_jar(self):
     return self._test_jar
 
   @property
   def test_support_apk(self):
     return self._test_support_apk
@@ skipping 157 matching lines @@
         a = dict(c['annotations'])
         a.update(m['annotations'])
         inflated_tests.append({
             'class': c['class'],
             'method': m['method'],
             'annotations': a,
         })
     return inflated_tests
 
   @staticmethod
+  def GetHttpServerEnvironmentVars():
+    return {
+      _EXTRA_ENABLE_HTTP_SERVER: None,
+    }
+
+  def GetDriverEnvironmentVars(
+      self, test_list=None, test_list_file_path=None):
+    env = {
+      _EXTRA_DRIVER_TARGET_PACKAGE: self.test_package,
+      _EXTRA_DRIVER_TARGET_CLASS: self.test_runner,
+    }
+
+    if test_list:
+      env[_EXTRA_DRIVER_TEST_LIST] = ','.join(test_list)
+
+    if test_list_file_path:
+      env[_EXTRA_DRIVER_TEST_LIST_FILE] = (
+          os.path.basename(test_list_file_path))
+
+    return env
+
+  @staticmethod
   def ParseAmInstrumentRawOutput(raw_output):
     return ParseAmInstrumentRawOutput(raw_output)
 
   @staticmethod
   def GenerateTestResults(
       result_code, result_bundle, statuses, start_ms, duration_ms):
     return GenerateTestResults(result_code, result_bundle, statuses,
                                start_ms, duration_ms)
 
   #override
   def TearDown(self):
     if self._isolate_delegate:
       self._isolate_delegate.Clear()