| #!/usr/bin/env python3 |
| # |
| # Copyright 2019 - 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 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an 'AS IS' BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| import os |
| |
| import yaml |
| from acts.keys import Config |
| from acts.test_utils.instrumentation import app_installer |
| from acts.test_utils.instrumentation import config_wrapper |
| from acts.test_utils.instrumentation.instrumentation_command_builder import \ |
| InstrumentationCommandBuilder |
| from acts.test_utils.instrumentation.adb_commands import common |
| |
| from acts import base_test |
| |
| RESOLVE_FILE_MARKER = 'FILE' |
| FILE_NOT_FOUND = 'File is missing from ACTS config' |
| DEFAULT_POWER_CONFIG_FILE = 'power_config.yaml' |
| |
| |
| class InstrumentationTestError(Exception): |
| pass |
| |
| |
| class InstrumentationBaseTest(base_test.BaseTestClass): |
| """Base class for power tests based on am instrument.""" |
| |
| def __init__(self, configs): |
| """Initialize an InstrumentationBaseTest |
| |
| Args: |
| configs: Dict representing the test configuration |
| """ |
| super().__init__(configs) |
| # Take power config path directly from ACTS config if found, otherwise |
| # try to find the power config in the same directory as the ACTS config |
| power_config_path = '' |
| if 'power_config' in self.user_params: |
| power_config_path = self.user_params['power_config'][0] |
| elif Config.key_config_path.value in self.user_params: |
| power_config_path = os.path.join( |
| self.user_params[Config.key_config_path.value], |
| DEFAULT_POWER_CONFIG_FILE) |
| self._power_config = None |
| if os.path.exists(power_config_path): |
| self._power_config = self._load_power_config(power_config_path) |
| else: |
| self.log.warning( |
| 'Power config file %s does not exist' % power_config_path) |
| |
| def _load_power_config(self, path): |
| """Load the power config file into a InstrumentationConfigWrapper |
| object. |
| |
| Args: |
| path: Path to the power config file. |
| |
| Returns: The loaded power config as an InstrumentationConfigWrapper |
| """ |
| try: |
| with open(path, mode='r', encoding='utf-8') as f: |
| config_dict = yaml.safe_load(f) |
| except Exception as e: |
| raise InstrumentationTestError( |
| 'Cannot open or parse power config file %s' % path) from e |
| if not self._resolve_file_paths(config_dict): |
| self.log.warning('File paths missing from power config.') |
| |
| # Write out a copy of the resolved power config |
| with open(os.path.join(self.log_path, 'resolved_power_config.yaml'), |
| mode='w', encoding='utf-8') as f: |
| yaml.safe_dump(config_dict, f) |
| |
| return config_wrapper.ConfigWrapper(config_dict) |
| |
| def _resolve_file_paths(self, config): |
| """Recursively resolve all 'FILE' markers found in the power config to |
| their corresponding paths in the ACTS config, i.e. in self.user_params. |
| |
| Args: |
| config: The power config to update |
| |
| Returns: True if all 'FILE' markers are resolved. |
| """ |
| success = True |
| for key, value in config.items(): |
| # Recursive call; resolve files in nested maps |
| if isinstance(value, dict): |
| success &= self._resolve_file_paths(value) |
| # Replace file resolver markers with paths from ACTS config |
| elif value == RESOLVE_FILE_MARKER: |
| if key not in self.user_params: |
| success = False |
| config[key] = FILE_NOT_FOUND |
| else: |
| config[key] = self.user_params[key] |
| return success |
| |
| def _prepare_device(self): |
| """Prepares the device for testing.""" |
| pass |
| |
| def setup_class(self): |
| """Class setup""" |
| self.ad_dut = self.android_devices[0] |
| self.ad_apps = app_installer.AppInstaller(self.ad_dut) |
| self._prepare_device() |
| |
| def adb_run(self, cmds, non_blocking=False): |
| """Run the specified command, or list of commands, with the ADB shell. |
| |
| Args: |
| cmds: A string or list of strings representing ADB shell command(s) |
| non_blocking: Run asynchronously |
| |
| Returns: dict mapping command to resulting stdout |
| """ |
| if isinstance(cmds, str): |
| cmds = [cmds] |
| adb = self.ad_dut.adb |
| adb_shell = adb.shell_nb if non_blocking else adb.shell |
| out = {} |
| for cmd in cmds: |
| out[cmd] = adb_shell(cmd) |
| return out |
| |
| # Basic preparer methods |
| |
| def enable_airplane_mode(self): |
| """Run the set of commands to properly enable airplane mode.""" |
| self.adb_run(common.airplane_mode.toggle(True)) |
| self.adb_run(common.auto_time.toggle(False)) |
| self.adb_run(common.auto_timezone.toggle(False)) |
| self.adb_run(common.location_gps.toggle(False)) |
| self.adb_run(common.location_network.toggle(False)) |
| self.adb_run(common.wifi.toggle(False)) |
| self.adb_run(common.bluetooth.toggle(False)) |
| |
| def grant_permissions(self, permissions_apk_path): |
| """Grant all runtime permissions with PermissionUtils. |
| |
| Args: |
| permissions_apk_path: Path to PermissionUtils.apk |
| """ |
| self.log.info('Granting all revoked runtime permissions.') |
| |
| # Install PermissionUtils.apk |
| self.ad_apps.install(permissions_apk_path) |
| if not self.ad_apps.is_installed(permissions_apk_path): |
| raise InstrumentationTestError( |
| 'Failed to install PermissionUtils.apk, abort!') |
| package_name = self.ad_apps.get_package_name(permissions_apk_path) |
| |
| # Run the instrumentation command |
| cmd_builder = InstrumentationCommandBuilder() |
| cmd_builder.set_manifest_package(package_name) |
| cmd_builder.set_runner('.PermissionInstrumentation') |
| cmd_builder.add_flag('-w') |
| cmd_builder.add_flag('-r') |
| cmd_builder.add_key_value_param('command', 'grant-all') |
| cmd = cmd_builder.build() |
| self.log.debug('Instrumentation call: %s' % cmd) |
| self.adb_run(cmd) |
| |
| # Uninstall PermissionUtils.apk |
| self.ad_apps.uninstall(permissions_apk_path) |
