Changes argument passing to use options objects

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.
 
 """Class for running instrumentation tests on a single device."""
 
 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 json_perf_parser
 from pylib import perf_tests_helper
 from pylib import valgrind_tools
 from pylib.base import base_test_result
 from pylib.base import base_test_runner
 
 import test_result
 
 
@@ skipping 19 matching lines @@
 
 class TestRunner(base_test_runner.BaseTestRunner):
   """Responsible for running a series of tests connected to a single device."""
 
   _DEVICE_DATA_DIR = 'chrome/test/data'
   _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, build_type, test_data, install_apk, save_perf_json,
-               screenshot_failures, tool, wait_for_debugger, disable_assertions,
-               push_deps, cleanup_test_files, device, shard_index, test_pkg,
+  def __init__(self, test_options, device, shard_index, test_pkg,
                ports_to_forward):
     """Create a new TestRunner.
 
     Args:
-      build_type: 'Release' or 'Debug'.
-      test_data: Location of the test data.
-      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.
-      push_deps: If True, push all dependencies to the device.
-      cleanup_test_files: Whether or not to cleanup test files on device.
+      test_options: An InstrumentationOptions object containing the set of
+          options relevant to running instrumentation tests.
       device: Attached android device.
       shard_index: Shard index.
       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.
+          Can be optionally requested by a test case.
     """
-    super(TestRunner, self).__init__(device, tool, build_type, push_deps,
-                                     cleanup_test_files)
+    super(TestRunner, self).__init__(device, test_options.tool,
+                                     test_options.build_type,
+                                     test_options.push_deps,
+                                     test_options.cleanup_test_files)
     self._lighttp_port = constants.LIGHTTPD_RANDOM_PORT_FIRST + shard_index
 
-    self.build_type = build_type
-    self.test_data = test_data
-    self.save_perf_json = save_perf_json
-    self.screenshot_failures = screenshot_failures
-    self.wait_for_debugger = wait_for_debugger
-    self.disable_assertions = disable_assertions
+    self.options = test_options
     self.test_pkg = test_pkg
     self.ports_to_forward = ports_to_forward
-    self.install_apk = install_apk
 
   #override
   def InstallTestPackage(self):
-    if self.install_apk:
+    if self.options.install_apk:
       self.test_pkg.Install(self.adb)
 
   #override
   def PushDataDeps(self):
     # TODO(frankf): Implement a general approach for copying/installing
     # once across test runners.
     if TestRunner._DEVICE_HAS_TEST_FILES.get(self.device, False):
       logging.warning('Already copied test files to device %s, skipping.',
                       self.device)
       return
 
     test_data = _GetDataFilesForTestSuite(self.test_pkg.GetApkName())
     if test_data:
       # Make sure SD card is ready.
       self.adb.WaitForSdCardReady(20)
       for p in test_data:
         self.adb.PushIfNeeded(
             os.path.join(constants.DIR_SOURCE_ROOT, p),
             os.path.join(self.adb.GetExternalStorage(), p))
 
     # TODO(frankf): Specify test data in this file as opposed to passing
     # as command-line.
-    for dest_host_pair in self.test_data:
+    for dest_host_pair in self.options.test_data:
       dst_src = dest_host_pair.split(':',1)
       dst_layer = dst_src[0]
       host_src = dst_src[1]
       host_test_files_path = constants.DIR_SOURCE_ROOT + '/' + 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)
     self.tool.CopyFiles()
     TestRunner._DEVICE_HAS_TEST_FILES[self.device] = True
 
   def _GetInstrumentationArgs(self):
     ret = {}
-    if self.wait_for_debugger:
+    if self.options.wait_for_debugger:
       ret['debug'] = 'true'
     return ret
 
   def _TakeScreenshot(self, test):
     """Takes a screenshot from the device."""
     screenshot_name = os.path.join(constants.SCREENSHOTS_DIR, test + '.png')
     logging.info('Taking screenshot named %s', screenshot_name)
     self.adb.TakeScreenshot(screenshot_name)
 
   def SetUp(self):
     """Sets up the test harness and device before all tests are run."""
     super(TestRunner, self).SetUp()
     if not self.adb.IsRootEnabled():
       logging.warning('Unable to enable java asserts for %s, non rooted device',
                       self.device)
     else:
-      if self.adb.SetJavaAssertsEnabled(enable=not self.disable_assertions):
+      if self.adb.SetJavaAssertsEnabled(
+          enable=not self.options.disable_assertions):
         self.adb.Reboot(full_reboot=False)
 
     # We give different default value to launch HTTP server based on shard index
     # because it may have race condition when multiple processes are trying to
     # launch lighttpd with same port at same time.
     http_server_ports = self.LaunchTestHttpServer(
         os.path.join(constants.DIR_SOURCE_ROOT), self._lighttp_port)
     if self.ports_to_forward:
       self.StartForwarder([(port, port) for port in self.ports_to_forward])
     self.flags.AddFlags(['--enable-test-intents'])
@@ skipping 85 matching lines @@
       # Obtain the relevant perf data.  The data is dumped to a
       # JSON formatted file.
       json_string = self.adb.GetProtectedFileContents(
           '/data/data/com.google.android.apps.chrome/files/PerfTestData.txt')
 
       if json_string:
         json_string = '\n'.join(json_string)
       else:
         raise Exception('Perf file does not exist or is empty')
 
-      if self.save_perf_json:
+      if self.options.save_perf_json:
         json_local_file = '/tmp/chromium-android-perf-json-' + raw_test_name
         with open(json_local_file, 'w') as f:
           f.write(json_string)
         logging.info('Saving Perf UI JSON from test ' +
                      test + ' to ' + json_local_file)
 
       raw_perf_data = regex.group(1).split(';')
 
       for raw_perf_set in raw_perf_data:
         if raw_perf_set:
@@ skipping 15 matching lines @@
 
   def _GetIndividualTestTimeoutScale(self, test):
     """Returns the timeout scale for the given |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:
+    if self.options.wait_for_debugger:
       timeout_scale *= 100
     return timeout_scale
 
   def _GetIndividualTestTimeoutSecs(self, test):
     """Returns the timeout in seconds for the given |test|."""
     annotations = self.test_pkg.GetTestAnnotations(test)
     if 'Manual' in annotations:
       return 600 * 60
     if 'External' in annotations:
       return 10 * 60
@@ skipping 23 matching lines @@
     try:
       self.TestSetup(test)
       start_date_ms = int(time.time()) * 1000
       raw_result = self._RunTest(test, timeout)
       duration_ms = int(time.time()) * 1000 - start_date_ms
       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:
+        if (self.options.screenshot_failures or
+            log.find('INJECT_EVENTS perm') >= 0):
           self._TakeScreenshot(test)
         result = test_result.InstrumentationTestResult(
             test, base_test_result.ResultType.FAIL, start_date_ms, duration_ms,
             log=log)
       else:
         result = test_result.InstrumentationTestResult(
             test, base_test_result.ResultType.PASS, start_date_ms, duration_ms)
       results.AddResult(result)
     # Catch exceptions thrown by StartInstrumentation().
     # See ../../third_party/android/testrunner/adb_interface.py
     except (android_commands.errors.WaitForResponseTimedOutError,
             android_commands.errors.DeviceUnresponsiveError,
             android_commands.errors.InstrumentationError), e:
       if start_date_ms:
         duration_ms = int(time.time()) * 1000 - start_date_ms
       else:
         start_date_ms = int(time.time()) * 1000
         duration_ms = 0
       message = str(e)
       if not message:
         message = 'No information.'
       results.AddResult(test_result.InstrumentationTestResult(
           test, base_test_result.ResultType.CRASH, start_date_ms, duration_ms,
           log=message))
       raw_result = None
     self.TestTeardown(test, raw_result)
     return (results, None if results.DidRunPass() else test)