[Android] Enable running uiautomator tests.

build/android/pylib/instrumentation/test_runner.py

 # 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 the Java tests. See more information on run_instrumentation_tests.py."""
 
 import logging
 import os
 import re
 import shutil
 import sys
 import time
 
 from pylib import android_commands
 from pylib import cmd_helper
 from pylib import constants
 from pylib import forwarder
 from pylib import json_perf_parser
 from pylib import perf_tests_helper
 from pylib import valgrind_tools
 from pylib.base import base_test_runner
 from pylib.base import test_result
 
-import apk_info
-
 
 _PERF_TEST_ANNOTATION = 'PerfTest'
 
 
 class TestRunner(base_test_runner.BaseTestRunner):
   """Responsible for running a series of tests connected to a single device."""
 
   _DEVICE_DATA_DIR = 'chrome/test/data'
   _EMMA_JAR = os.path.join(os.environ.get('ANDROID_BUILD_TOP', ''),
                            'external/emma/lib/emma.jar')
   _COVERAGE_MERGED_FILENAME = 'unittest_coverage.es'
   _COVERAGE_WEB_ROOT_DIR = os.environ.get('EMMA_WEB_ROOTDIR')
   _COVERAGE_FILENAME = 'coverage.ec'
   _COVERAGE_RESULT_PATH = ('/data/data/com.google.android.apps.chrome/files/' +
                            _COVERAGE_FILENAME)
   _COVERAGE_META_INFO_PATH = os.path.join(os.environ.get('ANDROID_BUILD_TOP',
                                                          ''),
                                           'out/target/common/obj/APPS',
                                           'Chrome_intermediates/coverage.em')
   _HOSTMACHINE_PERF_OUTPUT_FILE = '/tmp/chrome-profile'
   _DEVICE_PERF_OUTPUT_SEARCH_PREFIX = (constants.DEVICE_PERF_OUTPUT_DIR +
                                        '/chrome-profile*')
   _DEVICE_HAS_TEST_FILES = {}
 
-  def __init__(self, options, device, shard_index, coverage, apks,
-               ports_to_forward):
+  def __init__(self, options, device, shard_index, coverage, test_pkg,
+               ports_to_forward, is_uiautomator_test=False):
     """Create a new TestRunner.
 
     Args:
       options: An options object with the following required attributes:
       -  build_type: 'Release' or 'Debug'.
       -  install_apk: Re-installs the apk if opted.
       -  save_perf_json: Whether or not to save the JSON file from UI perf
             tests.
       -  screenshot_failures: Take a screenshot for a test failure
       -  tool: Name of the Valgrind tool.
       -  wait_for_debugger: blocks until the debugger is connected.
       -  disable_assertions: Whether to disable java assertions on the device.
       device: Attached android device.
       shard_index: Shard index.
       coverage: Collects coverage information if opted.
-      apks: A list of ApkInfo objects need to be installed. The first element
-            should be the tests apk, the rests could be the apks used in test.
-            The default is ChromeTest.apk.
+      test_pkg: A TestPackage object.
       ports_to_forward: A list of port numbers for which to set up forwarders.
                         Can be optionally requested by a test case.
+      is_uiautomator_test: Whether this is a uiautomator test.
     Raises:
       Exception: if coverage metadata is not available.
     """
     super(TestRunner, self).__init__(device, options.tool, options.build_type)
     self._lighttp_port = constants.LIGHTTPD_RANDOM_PORT_FIRST + shard_index
 
-    if not apks:
-      apks = [apk_info.ApkInfo(options.test_apk_path,
-                               options.test_apk_jar_path)]
-
     self.build_type = options.build_type
-    self.install_apk = options.install_apk
     self.test_data = options.test_data
     self.save_perf_json = options.save_perf_json
     self.screenshot_failures = options.screenshot_failures
     self.wait_for_debugger = options.wait_for_debugger
     self.disable_assertions = options.disable_assertions
-
     self.coverage = coverage
-    self.apks = apks
-    self.test_apk = apks[0]
-    self.instrumentation_class_path = self.test_apk.GetPackageName()
+    self.test_pkg = test_pkg
     self.ports_to_forward = ports_to_forward
+    self.is_uiautomator_test = is_uiautomator_test
+    if self.is_uiautomator_test:
+      self.package_name = options.package_name
+    else:
+      self.install_apk = options.install_apk
 
     self.forwarder = None
 
     if self.coverage:
       if os.path.exists(TestRunner._COVERAGE_MERGED_FILENAME):
         os.remove(TestRunner._COVERAGE_MERGED_FILENAME)
       if not os.path.exists(TestRunner._COVERAGE_META_INFO_PATH):
         raise Exception('FATAL ERROR in ' + sys.argv[0] +
                         ' : Coverage meta info [' +
                         TestRunner._COVERAGE_META_INFO_PATH +
@@ skipping 13 matching lines @@
       return
     for dest_host_pair in self.test_data:
       dst_src = dest_host_pair.split(':',1)
       dst_layer = dst_src[0]
       host_src = dst_src[1]
       host_test_files_path = constants.CHROME_DIR + '/' + host_src
       if os.path.exists(host_test_files_path):
         self.adb.PushIfNeeded(host_test_files_path,
                               self.adb.GetExternalStorage() + '/' +
                               TestRunner._DEVICE_DATA_DIR + '/' + dst_layer)
-    if self.install_apk:
-      for apk in self.apks:
-        self.adb.ManagedInstall(apk.GetApkPath(),
-                                package_name=apk.GetPackageName())
+    if self.is_uiautomator_test:
+      self.test_pkg.Install(self.adb)
+    elif self.install_apk:
+      self.test_pkg.Install(self.adb)
+
     self.tool.CopyFiles()
     TestRunner._DEVICE_HAS_TEST_FILES[self.device] = True
 
   def SaveCoverageData(self, test):
     """Saves the Emma coverage data before it's overwritten by the next test.
 
     Args:
       test: the test whose coverage data is collected.
     """
     if not self.coverage:
@@ skipping 104 matching lines @@
 
   def _IsPerfTest(self, test):
     """Determines whether a test is a performance test.
 
     Args:
       test: The name of the test to be checked.
 
     Returns:
       Whether the test is annotated as a performance test.
     """
-    return _PERF_TEST_ANNOTATION in self.test_apk.GetTestAnnotations(test)
+    return _PERF_TEST_ANNOTATION in self.test_pkg.GetTestAnnotations(test)
 
   def SetupPerfMonitoringIfNeeded(self, test):
     """Sets up performance monitoring if the specified test requires it.
 
     Args:
       test: The name of the test to be run.
     """
     if not self._IsPerfTest(test):
       return
     self.adb.Adb().SendCommand('shell rm ' +
@@ skipping 78 matching lines @@
           perf_tests_helper.PrintPerfResult(perf_set[1], perf_set[2],
                                             [result['average']],
                                             result['units'])
 
   def _SetupIndividualTestTimeoutScale(self, test):
     timeout_scale = self._GetIndividualTestTimeoutScale(test)
     valgrind_tools.SetChromeTimeoutScale(self.adb, timeout_scale)
 
   def _GetIndividualTestTimeoutScale(self, test):
     """Returns the timeout scale for the given |test|."""
-    annotations = self.apks[0].GetTestAnnotations(test)
+    annotations = self.test_pkg.GetTestAnnotations(test)
     timeout_scale = 1
     if 'TimeoutScale' in annotations:
       for annotation in annotations:
         scale_match = re.match('TimeoutScale:([0-9]+)', annotation)
         if scale_match:
           timeout_scale = int(scale_match.group(1))
     if self.wait_for_debugger:
       timeout_scale *= 100
     return timeout_scale
 
   def _GetIndividualTestTimeoutSecs(self, test):
     """Returns the timeout in seconds for the given |test|."""
-    annotations = self.apks[0].GetTestAnnotations(test)
+    annotations = self.test_pkg.GetTestAnnotations(test)
     if 'Manual' in annotations:
       return 600 * 60
     if 'External' in annotations:
       return 10 * 60
     if 'LargeTest' in annotations or _PERF_TEST_ANNOTATION in annotations:
       return 5 * 60
     if 'MediumTest' in annotations:
       return 3 * 60
     return 1 * 60
 
   def RunTest(self, test):
     """Runs the test, generating the coverage if needed.
 
     Returns:
       A test_result.TestResults object.
     """
-    instrumentation_path = (self.instrumentation_class_path +
-                            '/android.test.InstrumentationTestRunner')
-    instrumentation_args = self._GetInstrumentationArgs()
     raw_result = None
     start_date_ms = None
     test_results = test_result.TestResults()
+    timeout=(self._GetIndividualTestTimeoutSecs(test) *
+             self._GetIndividualTestTimeoutScale(test) *
+             self.tool.GetTimeoutScale())
     try:
       self.TestSetup(test)
       start_date_ms = int(time.time()) * 1000
-      args_with_filter = dict(instrumentation_args)
-      args_with_filter['class'] = test
-      # |raw_results| is a list that should contain
-      # a single TestResult object.
-      logging.warn(args_with_filter)
-      (raw_results, _) = self.adb.Adb().StartInstrumentation(
-          instrumentation_path=instrumentation_path,
-          instrumentation_args=args_with_filter,
-          timeout_time=(self._GetIndividualTestTimeoutSecs(test) *
-                        self._GetIndividualTestTimeoutScale(test) *
-                        self.tool.GetTimeoutScale()))
+
+      if self.is_uiautomator_test:
+        self.adb.ClearApplicationState(self.package_name)
+        # TODO(frankf): Stop-gap solution. Should use annotations.
+        if 'FirstRun' in test:
+          self.flags.RemoveFlags(['--disable-fre'])
+        else:
+          self.flags.AddFlags(['--disable-fre'])
+        raw_result = self.adb.RunUIAutomatorTest(
+            test, self.test_pkg.GetPackageName(), timeout)
+      else:
+        raw_result = self.adb.RunInstrumentationTest(
+            test, self.test_pkg.GetPackageName(),
+            self._GetInstrumentationArgs(), timeout)
+
       duration_ms = int(time.time()) * 1000 - start_date_ms
-      assert len(raw_results) == 1
-      raw_result = raw_results[0]
       status_code = raw_result.GetStatusCode()
       if status_code:
         log = raw_result.GetFailureReason()
         if not log:
           log = 'No information.'
         if self.screenshot_failures or log.find('INJECT_EVENTS perm') >= 0:
           self._TakeScreenshot(test)
         test_results.failed = [test_result.SingleTestResult(
             test, start_date_ms, duration_ms, log)]
       else:
@@ skipping 10 matching lines @@
         start_date_ms = int(time.time()) * 1000
         duration_ms = 0
       message = str(e)
       if not message:
         message = 'No information.'
       test_results.crashed = [test_result.SingleTestResult(
           test, start_date_ms, duration_ms, message)]
       raw_result = None
     self.TestTeardown(test, raw_result)
     return (test_results, None if test_results.ok else test)