def setUpClass(self): """Creates a mirror and turns on the framework-layer NFC service.""" self.dut = self.registerController(android_device)[0] self.getUserParams(opt_param_names=[PASSTHROUGH_MODE_KEY]) self.dut.shell.InvokeTerminal("one") self.dut.shell.one.Execute("setenforce 0") # SELinux permissive mode if not precondition_utils.CanRunHidlHalTest(self, self.dut, self.dut.shell.one): self._skip_all_testcases = True return self.dut.shell.one.Execute("svc nfc disable") # Turn off time.sleep(5) if getattr(self, PASSTHROUGH_MODE_KEY, True): self.dut.shell.one.Execute( "setprop vts.hal.vts.hidl.get_stub true") else: self.dut.shell.one.Execute( "setprop vts.hal.vts.hidl.get_stub false") self.dut.hal.InitHidlHal(target_type="nfc", target_basepaths=self.dut.libPaths, target_version=1.0, target_package="android.hardware.nfc", target_component_name="INfc", bits=int(self.abi_bitness)) if self.coverage.enabled: self.coverage.LoadArtifacts() self.coverage.InitializeDeviceCoverage(self._dut)
def setUpClass(self): """Creates a mirror and turns on the framework-layer CONTEXTHUB service.""" self.dut = self.registerController(android_device)[0] self.dut.shell.InvokeTerminal("one") self.dut.shell.one.Execute("setenforce 0") # SELinux permissive mode if not precondition_utils.CanRunHidlHalTest(self, self.dut, self.dut.shell.one): self._skip_all_testcases = True return if self.profiling.enabled: self.profiling.EnableVTSProfiling(self.dut.shell.one) # Bring down the Android runtime so it doesn't interfere with the test #self.dut.shell.one.Execute("stop") self.dut.hal.InitHidlHal(target_type="contexthub", target_basepaths=self.dut.libPaths, target_version=1.0, target_package="android.hardware.contexthub", target_component_name="IContexthub", bits=int(self.abi_bitness)) self.types = self.dut.hal.contexthub.GetHidlTypeInterface("types") logging.info("types: %s", self.types)
def setUpClass(self): """Creates a mirror and turns on the framework-layer GNSS service.""" self.dut = self.android_devices[0] self.passthrough_mode = self.getUserParam( keys.ConfigKeys.IKEY_PASSTHROUGH_MODE, default_value=True) self.dut.shell.Execute("setenforce 0") # SELinux permissive mode if not precondition_utils.CanRunHidlHalTest(self, self.dut, self.dut.shell.default): self._skip_all_testcases = True return mode = "true" if self.passthrough_mode else "false" self.dut.shell.Execute("setprop %s %s" % (self.SYSPROP_GETSTUB, mode)) self.dut.hal.InitHidlHal(target_type="gnss", target_basepaths=self.dut.libPaths, target_version=1.0, target_package="android.hardware.gnss", target_component_name="IGnss", bits=int(self.abi_bitness)) if self.coverage.enabled: self.coverage.LoadArtifacts() self.coverage.InitializeDeviceCoverage(self._dut)
def setUpClass(self): """Creates a mirror and init vehicle hal.""" self.dut = self.registerController(android_device)[0] self.dut.shell.InvokeTerminal("one") self.dut.shell.one.Execute("setenforce 0") # SELinux permissive mode if not precondition_utils.CanRunHidlHalTest(self, self.dut, self.dut.shell.one): self._skip_all_testcases = True return if self.profiling.enabled: self.profiling.EnableVTSProfiling(self.dut.shell.one) self.dut.hal.InitHidlHal(target_type="radio", target_basepaths=self.dut.libPaths, target_version=1.0, target_package="android.hardware.radio", target_component_name="IRadio", hw_binder_service_name="Radio", bits=int(self.abi_bitness)) self.radio = self.dut.hal.radio # shortcut self.radio_types = self.dut.hal.radio.GetHidlTypeInterface("types") logging.info("Radio types: %s", self.radio_types)
def setUpClass(self): """Creates a mirror and init tv hdmi cec hal service.""" self.dut = self.registerController(android_device)[0] self.dut.shell.InvokeTerminal("one") self.dut.shell.one.Execute("setenforce 0") # SELinux permissive mode if not precondition_utils.CanRunHidlHalTest(self, self.dut, self.dut.shell.one): self._skip_all_testcases = True return self.dut.shell.one.Execute("setprop vts.hal.vts.hidl.get_stub true") if self.coverage.enabled: self.coverage.LoadArtifacts() self.coverage.InitializeDeviceCoverage(self.dut) if self.profiling.enabled: self.profiling.EnableVTSProfiling(self.dut.shell.one) self.dut.hal.InitHidlHal(target_type="tv_cec", target_basepaths=self.dut.libPaths, target_version=1.0, target_package="android.hardware.tv.cec", target_component_name="IHdmiCec", bits=int(self.abi_bitness)) time.sleep(1) # Wait for hal to be ready self.vtypes = self.dut.hal.tv_cec.GetHidlTypeInterface("types") logging.info("tv_cec types: %s", self.vtypes)
def setUpClass(self): """Checks precondition.""" self._initial_test_case_cnt = 0 super(HidlHalGTest, self).setUpClass() if not hasattr(self, "_target_hals"): self._target_hals = [] opt_params = [ keys.ConfigKeys.IKEY_SKIP_IF_THERMAL_THROTTLING, keys.ConfigKeys.IKEY_DISABLE_CPU_FREQUENCY_SCALING ] self.getUserParams(opt_param_names=opt_params) self._skip_if_thermal_throttling = self.getUserParam( keys.ConfigKeys.IKEY_SKIP_IF_THERMAL_THROTTLING, default_value=False) self._disable_cpu_frequency_scaling = self.getUserParam( keys.ConfigKeys.IKEY_DISABLE_CPU_FREQUENCY_SCALING, default_value=True) if not self.isSkipAllTests(): self._cpu_freq = cpu_frequency_scaling.CpuFrequencyScalingController( self._dut) if self._disable_cpu_frequency_scaling: logging.info("Disable CPU frequency scaling") self._cpu_freq.DisableCpuScaling() else: self._cpu_freq = None if not self.isSkipAllTests(): ret = precondition_utils.CanRunHidlHalTest( self, self._dut, self.shell, self.run_as_compliance_test) if not ret: self.skipAllTests("HIDL HAL precondition check failed.") # Extend timeout if there are multiple service instance combinations. if (not self.isSkipAllTests() and self._initial_test_case_cnt and len(self.testcases) > self._initial_test_case_cnt): self.resetTimeout(self.timeout * len(self.testcases) / float(self._initial_test_case_cnt)) if self.sancov.enabled and self._target_hals: self.sancov.InitializeDeviceCoverage(self._dut, self._target_hals) if self.coverage.enabled and self._target_hals: self.coverage.SetHalNames(self._target_hals) self.coverage.SetCoverageReportFilePrefix(self.test_module_name + self.abi_bitness)
def setUpClass(self): self.dut = self.registerController(android_device)[0] self.dut.shell.InvokeTerminal("one") self.dut.shell.one.Execute("setenforce 0") # SELinux permissive mode if not precondition_utils.CanRunHidlHalTest(self, self.dut, self.dut.shell.one): self._skip_all_testcases = True return self.dut.hal.InitHidlHal(target_type="media_omx", target_basepaths=self.dut.libPaths, target_version=1.0, target_package="android.hardware.media.omx", target_component_name="IOmxStore", bits=int(self.abi_bitness)) if self.coverage.enabled: self.coverage.LoadArtifacts() self.coverage.InitializeDeviceCoverage(self._dut)
def setUpClass(self): """Creates a mirror and turns on the framework-layer SENSORS service.""" self.dut = self.registerController(android_device)[0] self.dut.shell.InvokeTerminal("one") self.dut.shell.one.Execute("setenforce 0") # SELinux permissive mode if not precondition_utils.CanRunHidlHalTest(self, self.dut, self.dut.shell.one): self._skip_all_testcases = True return # Test using the binderized mode self.dut.shell.one.Execute("setprop vts.hal.vts.hidl.get_stub true") self.dut.hal.InitHidlHal(target_type="sensors", target_basepaths=self.dut.libPaths, target_version=1.0, target_package="android.hardware.sensors", target_component_name="ISensors", bits=int(self.abi_bitness))
def setUpClass(self): """Basic setup process for host-side hidl hal tests. Test precondition check, prepare for profiling and coverage measurement if enabled. """ # Testability check. if not precondition_utils.CanRunHidlHalTest( self, self.dut, self.shell, self.run_as_compliance_test): self.skipAllTests( "precondition check for hidl hal tests didn't pass") return # Initialization for coverage measurement. if self.coverage.enabled and self.coverage.global_coverage: self.coverage.InitializeDeviceCoverage(self.dut) if self.TEST_HAL_SERVICES: self.coverage.SetHalNames(self.TEST_HAL_SERVICES) self.coverage.SetCoverageReportFilePrefix( self.test_module_name + self.abi_bitness) # Enable profiling. if self.profiling.enabled: self.profiling.EnableVTSProfiling(self.shell)
def setUpClass(self): """Creates a mirror and init vehicle hal.""" self.dut = self.registerController(android_device)[0] self.dut.shell.InvokeTerminal("one") self.dut.shell.one.Execute("setenforce 0") # SELinux permissive mode if not precondition_utils.CanRunHidlHalTest(self, self.dut, self.dut.shell.one): self._skip_all_testcases = True return results = self.dut.shell.one.Execute("id -u system") system_uid = results[const.STDOUT][0].strip() logging.info("system_uid: %s", system_uid) if self.coverage.enabled: self.coverage.LoadArtifacts() self.coverage.InitializeDeviceCoverage(self.dut) if self.profiling.enabled: self.profiling.EnableVTSProfiling(self.dut.shell.one) self.dut.hal.InitHidlHal( target_type="vehicle", target_basepaths=self.dut.libPaths, target_version=2.0, target_package="android.hardware.automotive.vehicle", target_component_name="IVehicle", bits=int(self.abi_bitness)) self.vehicle = self.dut.hal.vehicle # shortcut self.vehicle.SetCallerUid(system_uid) self.vtypes = self.dut.hal.vehicle.GetHidlTypeInterface("types") logging.info("vehicle types: %s", self.vtypes) asserts.assertEqual(0x00ff0000, self.vtypes.VehiclePropertyType.MASK) asserts.assertEqual(0x0f000000, self.vtypes.VehicleArea.MASK)
def setUpClass(self): '''Prepare class, push binaries, set permission, create test cases.''' required_params = [ keys.ConfigKeys.IKEY_DATA_FILE_PATH, ] opt_params = [ keys.ConfigKeys.IKEY_BINARY_TEST_SOURCE, keys.ConfigKeys.IKEY_BINARY_TEST_WORKING_DIRECTORY, keys.ConfigKeys.IKEY_BINARY_TEST_ENVP, keys.ConfigKeys.IKEY_BINARY_TEST_ARGS, keys.ConfigKeys.IKEY_BINARY_TEST_LD_LIBRARY_PATH, keys.ConfigKeys.IKEY_BINARY_TEST_PROFILING_LIBRARY_PATH, keys.ConfigKeys.IKEY_BINARY_TEST_DISABLE_FRAMEWORK, keys.ConfigKeys.IKEY_BINARY_TEST_STOP_NATIVE_SERVERS, keys.ConfigKeys.IKEY_NATIVE_SERVER_PROCESS_NAME, ] self.getUserParams(req_param_names=required_params, opt_param_names=opt_params) # test-module-name is required in binary tests. self.getUserParam(keys.ConfigKeys.KEY_TESTBED_NAME, error_if_not_found=True) logging.info("%s: %s", keys.ConfigKeys.IKEY_DATA_FILE_PATH, self.data_file_path) self.binary_test_source = self.getUserParam( keys.ConfigKeys.IKEY_BINARY_TEST_SOURCE, default_value=[]) self.working_directory = {} if hasattr(self, keys.ConfigKeys.IKEY_BINARY_TEST_WORKING_DIRECTORY): self.binary_test_working_directory = map( str, self.binary_test_working_directory) for token in self.binary_test_working_directory: tag = '' path = token if self.TAG_DELIMITER in token: tag, path = token.split(self.TAG_DELIMITER) self.working_directory[tag] = path self.envp = {} if hasattr(self, keys.ConfigKeys.IKEY_BINARY_TEST_ENVP): self.binary_test_envp = map(str, self.binary_test_envp) for token in self.binary_test_envp: tag = '' path = token split = token.find(self.TAG_DELIMITER) if split >= 0: tag, arg = token[:split], token[split + len(self.TAG_DELIMITER):] if tag in self.envp: self.envp[tag] += ' %s' % path else: self.envp[tag] = path self.args = {} if hasattr(self, keys.ConfigKeys.IKEY_BINARY_TEST_ARGS): self.binary_test_args = map(str, self.binary_test_args) for token in self.binary_test_args: tag = '' arg = token split = token.find(self.TAG_DELIMITER) if split >= 0: tag, arg = token[:split], token[split + len(self.TAG_DELIMITER):] if tag in self.args: self.args[tag] += ' %s' % arg else: self.args[tag] = arg self.ld_library_path = { self.DEFAULT_TAG_32: self.DEFAULT_LD_LIBRARY_PATH_32, self.DEFAULT_TAG_64: self.DEFAULT_LD_LIBRARY_PATH_64, } if hasattr(self, keys.ConfigKeys.IKEY_BINARY_TEST_LD_LIBRARY_PATH): self.binary_test_ld_library_path = map( str, self.binary_test_ld_library_path) for token in self.binary_test_ld_library_path: tag = '' path = token if self.TAG_DELIMITER in token: tag, path = token.split(self.TAG_DELIMITER) if tag in self.ld_library_path: self.ld_library_path[tag] = '{}:{}'.format( path, self.ld_library_path[tag]) else: self.ld_library_path[tag] = path self.profiling_library_path = { self.DEFAULT_TAG_32: self.DEFAULT_PROFILING_LIBRARY_PATH_32, self.DEFAULT_TAG_64: self.DEFAULT_PROFILING_LIBRARY_PATH_64, } if hasattr(self, keys.ConfigKeys.IKEY_BINARY_TEST_PROFILING_LIBRARY_PATH): self.binary_test_profiling_library_path = map( str, self.binary_test_profiling_library_path) for token in self.binary_test_profiling_library_path: tag = '' path = token if self.TAG_DELIMITER in token: tag, path = token.split(self.TAG_DELIMITER) self.profiling_library_path[tag] = path self._dut = self.android_devices[0] self.shell = self._dut.shell if self.coverage.enabled and self.coverage.global_coverage: self.coverage.LoadArtifacts() self.coverage.InitializeDeviceCoverage(self._dut) # TODO: only set permissive mode for userdebug and eng build. self.shell.Execute("setenforce 0") # SELinux permissive mode if not precondition_utils.CanRunHidlHalTest(self, self._dut, self.shell): self._skip_all_testcases = True self.testcases = [] self.tags = set() self.CreateTestCases() cmd = list( set('chmod 755 %s' % test_case.path for test_case in self.testcases)) cmd_results = self.shell.Execute(cmd) if any(cmd_results[const.EXIT_CODE]): logging.error( 'Failed to set permission to some of the binaries:\n' '%s\n%s', cmd, cmd_results) stop_requested = False if getattr(self, keys.ConfigKeys.IKEY_BINARY_TEST_DISABLE_FRAMEWORK, False): # Stop Android runtime to reduce interference. logging.debug("Stops the Android framework.") self._dut.stop() stop_requested = True if getattr(self, keys.ConfigKeys.IKEY_BINARY_TEST_STOP_NATIVE_SERVERS, False): logging.debug("Stops all properly configured native servers.") results = self._dut.setProp(self.SYSPROP_VTS_NATIVE_SERVER, "1") stop_requested = True if stop_requested: native_server_process_names = getattr( self, keys.ConfigKeys.IKEY_NATIVE_SERVER_PROCESS_NAME, []) if native_server_process_names: for native_server_process_name in native_server_process_names: while True: cmd_result = self.shell.Execute("ps -A") if cmd_result[const.EXIT_CODE][0] != 0: logging.error("ps command failed (exit code: %s", cmd_result[const.EXIT_CODE][0]) break if (native_server_process_name not in cmd_result[const.STDOUT][0]): logging.info("Process %s not running", native_server_process_name) break logging.info("Checking process %s", native_server_process_name) time.sleep(1)