def setup_class(self): super(WifiTethering2GPskOTATest, self).setup_class() ota_updater.initialize(self.user_params, self.android_devices) self.hotspot_device = self.android_devices[0] self.tethered_device = self.android_devices[1] req_params = ("wifi_hotspot_psk", ) self.unpack_userparams(req_params) # verify hotspot device has lte data and supports tethering nutils.verify_lte_data_and_tethering_supported(self.hotspot_device) # Save a wifi soft ap configuration and verify that it works wutils.save_wifi_soft_ap_config(self.hotspot_device, self.wifi_hotspot_psk, WIFI_CONFIG_APBAND_2G) self._verify_wifi_tethering() # Run OTA below, if ota fails then abort all tests. try: ota_updater.update(self.hotspot_device) except Exception as err: raise signals.TestAbortClass( "Failed up apply OTA update. Aborting tests")
def setup_class(self): super(AdvertisingSetTest, self).setup_class() self.adv_ad = self.android_devices[0] if not self.adv_ad.droid.bluetoothIsLeExtendedAdvertisingSupported(): raise signals.TestAbortClass( "Advertiser does not support LE Extended Advertising")
def wait_for_sim_ready(self,ad): wait_for_sim_ready_on_sim_config = { SINGLE_SIM_CONFIG : lambda:wait_for_sim_ready_by_adb(self.log,ad), MULTI_SIM_CONFIG : lambda:wait_for_sims_ready_by_adb(self.log,ad) } if not wait_for_sim_ready_on_sim_config[self.sim_config["config"]]: raise signals.TestAbortClass("unable to load the SIM")
def setup_class(self): TelephonyBaseTest.setup_class(self) for ad in self.android_devices: if not is_sim_lock_enabled(ad): self.setup_dut(ad) return True self.log.error("No device meets SIM READY or LOADED requirement") raise signals.TestAbortClass("No device meets SIM requirement")
def setup_class(self): super().setup_class() success_str = ("Congratulations! Fuchsia controllers have been " "initialized successfully!") err_str = ("Sorry, please try verifying FuchsiaDevice is in your " "config file and try again.") if len(self.fuchsia_devices) > 0: self.log.info(success_str) else: raise signals.TestAbortClass("err_str")
def setup_class(self): super(BtOtaTest, self).setup_class() ota_updater.initialize(self.user_params, self.android_devices) self.dut = self.android_devices[0] self.pre_ota_name = self.dut.droid.bluetoothGetLocalName() self.pre_ota_address = self.dut.droid.bluetoothGetLocalAddress() self.sec_address = self.android_devices[ 1].droid.bluetoothGetLocalAddress() # Pairing devices if not pair_pri_to_sec(self.dut, self.android_devices[1]): raise signals.TestAbortClass( "Failed to bond devices prior to update") #Run OTA below, if ota fails then abort all tests try: ota_updater.update(self.dut) except Exception as err: raise signals.TestAbortClass( "Failed up apply OTA update. Aborting tests")
def setup_class(self): for ad in self.my_devices: sim_state = get_sim_state(ad) ad.log.info("Sim state is %s", sim_state) if sim_state in (SIM_STATE_ABSENT, SIM_STATE_UNKNOWN): ad.log.info("Device has no or unknown SIM in it, set as DUT") self.setup_dut(ad) return True self.log.error("No device meets SIM absent or unknown requirement") raise signals.TestAbortClass( "No device meets SIM absent or unknown requirement")
def setup_class(self): TelephonyBaseTest.setup_class(self) self.number_of_devices = 1 fake_number = self.user_params.get("fake_emergency_number", "411") self.fake_emergency_number = fake_number.strip("+").replace("-", "") self.my_devices = self.android_devices[:] for ad in self.android_devices: if not is_sim_lock_enabled(ad): self.setup_dut(ad) return True self.log.error("No device meets SIM READY or LOADED requirement") raise signals.TestAbortClass("No device meets SIM requirement")
def abort_class(reason, extras=None): """Abort all subsequent test cases within the same test class in one iteration. If one test class is requested multiple times in a test run, this can only abort one of the requested executions, NOT all. Args: reason: The reason to abort. extras: An optional field for extra information to be included in test result. Raises: signals.TestAbortClass is raised to abort all subsequent tests in a test class. """ raise signals.TestAbortClass(reason, extras)
def setup_class(self): super(WifiAutoUpdateTest, self).setup_class() ota_updater.initialize(self.user_params, self.android_devices) self.dut = self.android_devices[0] wutils.wifi_test_device_init(self.dut) req_params = [] opt_param = [ "open_network", "reference_networks", "iperf_server_address" ] self.unpack_userparams(req_param_names=req_params, opt_param_names=opt_param) if "AccessPoint" in self.user_params: self.legacy_configure_ap_and_start() asserts.assert_true( len(self.reference_networks) > 0, "Need at least two reference network with psk.") asserts.assert_true( len(self.open_network) > 0, "Need at least two open network with psk.") wutils.wifi_toggle_state(self.dut, True) self.wifi_config_list = [] # Disabling WiFi setup before OTA for debugging. # Setup WiFi and add few open and wpa networks before OTA. # self.add_network_and_enable(self.open_network[0]['2g']) # self.add_network_and_enable(self.reference_networks[0]['5g']) # Add few dummy networks to the list. # self.add_and_enable_dummy_networks() # Run OTA below, if ota fails then abort all tests. try: ota_updater.update(self.dut) except Exception as err: raise signals.TestAbortClass( "Failed up apply OTA update. Aborting tests")
def setup_class(self): super().setup_class() self.dut = self.android_devices[0] self.dut_client = self.android_devices[1] wutils.wifi_test_device_init(self.dut) wutils.wifi_test_device_init(self.dut_client) if not self.dut.is_apk_installed("com.google.mdstest"): raise signals.TestAbortClass("mdstest is not installed") req_params = ["dbs_supported_models", "stress_count"] opt_param = ["reference_networks"] self.unpack_userparams(req_param_names=req_params, opt_param_names=opt_param) if "AccessPoint" in self.user_params: self.legacy_configure_ap_and_start() asserts.assert_true( len(self.reference_networks) > 0, "Need at least one reference network with psk.") self.network = self.reference_networks[0]["2g"] self.ap_iface = 'wlan0' if self.dut.model in self.dbs_supported_models: self.ap_iface = 'wlan1'
def setup_class(self): super().setup_class() if len(self.fuchsia_devices) < 1: raise signals.TestAbortClass( "Sorry, please try verifying FuchsiaDevice is in your " "config file and try again.")
def _setup_device(self, ad, sim_conf_file, qxdm_log_mask_cfg=None): if self.user_params.get("enable_connectivity_metrics", True): enable_connectivity_metrics(ad) if self.user_params.get("build_id_override", False): build_postfix = self.user_params.get("build_id_postfix", "TEST") build_id_override(ad, new_build_id=self.user_params.get( "build_id_override_with", None), postfix=build_postfix) if self.enable_radio_log_on: enable_radio_log_on(ad) if "sdm" in ad.model: if ad.adb.getprop("persist.radio.multisim.config") != "ssss": ad.adb.shell("setprop persist.radio.multisim.config ssss") reboot_device(ad) stop_qxdm_logger(ad) ad.qxdm_log = getattr(ad, "qxdm_log", self.qxdm_log) if ad.qxdm_log: qxdm_log_mask = getattr(ad, "qxdm_log_mask", None) if qxdm_log_mask_cfg: qxdm_mask_path = self.user_params.get("qxdm_log_path", DEFAULT_QXDM_LOG_PATH) ad.adb.shell("mkdir %s" % qxdm_mask_path) ad.log.info("Push %s to %s", qxdm_log_mask_cfg, qxdm_mask_path) ad.adb.push("%s %s" % (qxdm_log_mask_cfg, qxdm_mask_path)) mask_file_name = os.path.split(qxdm_log_mask_cfg)[-1] qxdm_log_mask = os.path.join(qxdm_mask_path, mask_file_name) set_qxdm_logger_command(ad, mask=qxdm_log_mask) start_qxdm_logger(ad, utils.get_current_epoch_time()) else: disable_qxdm_logger(ad) if not unlock_sim(ad): raise signals.TestAbortClass("unable to unlock the SIM") if get_sim_state(ad) in (SIM_STATE_ABSENT, SIM_STATE_UNKNOWN): ad.log.info("Device has no or unknown SIM in it") ensure_phone_idle(self.log, ad) elif self.user_params.get("Attenuator"): ad.log.info("Device in chamber room") ensure_phone_idle(self.log, ad) setup_droid_properties(self.log, ad, sim_conf_file) else: if not wait_for_sim_ready_by_adb(self.log, ad): raise signals.TestAbortClass("unable to load the SIM") ensure_phone_default_state(self.log, ad) setup_droid_properties(self.log, ad, sim_conf_file) # Setup VoWiFi MDN for Verizon. b/33187374 if get_operator_name(self.log, ad) == "vzw" and ad.is_apk_installed( "com.google.android.wfcactivation"): ad.log.info("setup VoWiFi MDN per b/33187374") ad.adb.shell("setprop dbg.vzw.force_wfc_nv_enabled true") ad.adb.shell("am start --ei EXTRA_LAUNCH_CARRIER_APP 0 -n " "\"com.google.android.wfcactivation/" ".VzwEmergencyAddressActivity\"") # Sub ID setup initial_set_up_for_subid_infomation(self.log, ad) # If device is setup already, skip the following setup procedures if getattr(ad, "telephony_test_setup", None): return True if "enable_wifi_verbose_logging" in self.user_params: ad.droid.wifiEnableVerboseLogging(WIFI_VERBOSE_LOGGING_ENABLED) # Disable Emergency alerts # Set chrome browser start with no-first-run verification and # disable-fre. Give permission to read from and write to storage. for cmd in ("pm disable com.android.cellbroadcastreceiver", "pm grant com.android.chrome " "android.permission.READ_EXTERNAL_STORAGE", "pm grant com.android.chrome " "android.permission.WRITE_EXTERNAL_STORAGE", "rm /data/local/chrome-command-line", "am set-debug-app --persistent com.android.chrome", 'echo "chrome --no-default-browser-check --no-first-run ' '--disable-fre" > /data/local/tmp/chrome-command-line'): ad.adb.shell(cmd) # Curl for 2016/7 devices if not getattr(ad, "curl_capable", False): try: out = ad.adb.shell("/data/curl --version") if not out or "not found" in out: if int(ad.adb.getprop("ro.product.first_api_level")) >= 25: tel_data = self.user_params.get("tel_data", "tel_data") if isinstance(tel_data, list): tel_data = tel_data[0] curl_file_path = os.path.join(tel_data, "curl") if not os.path.isfile(curl_file_path): curl_file_path = os.path.join( self.user_params[Config.key_config_path], curl_file_path) if os.path.isfile(curl_file_path): ad.log.info("Pushing Curl to /data dir") ad.adb.push("%s /data" % (curl_file_path)) ad.adb.shell("chmod 777 /data/curl", ignore_status=True) else: setattr(ad, "curl_capable", True) except Exception: ad.log.info("Failed to push curl on this device") # Ensure that a test class starts from a consistent state that # improves chances of valid network selection and facilitates # logging. try: if not set_phone_screen_on(self.log, ad): self.log.error("Failed to set phone screen-on time.") return False if not set_phone_silent_mode(self.log, ad): self.log.error("Failed to set phone silent mode.") return False ad.droid.telephonyAdjustPreciseCallStateListenLevel( PRECISE_CALL_STATE_LISTEN_LEVEL_FOREGROUND, True) ad.droid.telephonyAdjustPreciseCallStateListenLevel( PRECISE_CALL_STATE_LISTEN_LEVEL_RINGING, True) ad.droid.telephonyAdjustPreciseCallStateListenLevel( PRECISE_CALL_STATE_LISTEN_LEVEL_BACKGROUND, True) except Exception as e: self.log.error("Failure with %s", e) setattr(ad, "telephony_test_setup", True) return True
def _setup_device(self, ad, sim_conf_file, qxdm_log_mask_cfg=None): ad.qxdm_log = getattr(ad, "qxdm_log", self.qxdm_log) ad.sdm_log = getattr(ad, "sdm_log", self.sdm_log) if self.user_params.get("enable_connectivity_metrics", False): enable_connectivity_metrics(ad) if self.user_params.get("build_id_override", False): build_postfix = self.user_params.get("build_id_postfix", "LAB_TEST") build_id_override( ad, new_build_id=self.user_params.get("build_id_override_with", None), postfix=build_postfix) if self.enable_radio_log_on: enable_radio_log_on(ad) list_of_models = ["sdm", "msm", "kon", "lit"] if any(model in ad.model for model in list_of_models): phone_mode = "ssss" if hasattr(ad, "mtp_dsds"): phone_mode = "dsds" if ad.adb.getprop("persist.radio.multisim.config") != phone_mode: ad.adb.shell("setprop persist.radio.multisim.config %s" \ % phone_mode) reboot_device(ad) stop_qxdm_logger(ad) if ad.qxdm_log: qxdm_log_mask = getattr(ad, "qxdm_log_mask", None) if qxdm_log_mask_cfg: qxdm_mask_path = self.user_params.get("qxdm_log_path", DEFAULT_QXDM_LOG_PATH) ad.adb.shell("mkdir %s" % qxdm_mask_path, ignore_status=True) ad.log.info("Push %s to %s", qxdm_log_mask_cfg, qxdm_mask_path) ad.adb.push("%s %s" % (qxdm_log_mask_cfg, qxdm_mask_path)) mask_file_name = os.path.split(qxdm_log_mask_cfg)[-1] qxdm_log_mask = os.path.join(qxdm_mask_path, mask_file_name) set_qxdm_logger_command(ad, mask=qxdm_log_mask) start_qxdm_logger(ad, utils.get_current_epoch_time()) elif ad.sdm_log: start_sdm_logger(ad) else: disable_qxdm_logger(ad) if not unlock_sim(ad): raise signals.TestAbortClass("unable to unlock the SIM") # If device is setup already, skip the following setup procedures if getattr(ad, "telephony_test_setup", None): return True # eSIM enablement if hasattr(ad, "fi_esim"): if not ensure_wifi_connected(self.log, ad, self.wifi_network_ssid, self.wifi_network_pass): ad.log.error("Failed to connect to wifi") if check_google_fi_activated(ad): ad.log.info("Google Fi is already Activated") else: install_googleaccountutil_apk(ad, self.account_util) add_google_account(ad) install_googlefi_apk(ad, self.fi_util) if not activate_google_fi_account(ad): ad.log.error("Failed to activate Fi") check_google_fi_activated(ad) if getattr(ad, 'dsds', False): sim_mode = ad.droid.telephonyGetPhoneCount() if sim_mode == 1: ad.log.info("Phone in Single SIM Mode") if not phone_switch_to_msim_mode(ad): ad.log.error("Failed to switch to Dual SIM Mode") return False elif sim_mode == 2: ad.log.info("Phone already in Dual SIM Mode") if get_sim_state(ad) in (SIM_STATE_ABSENT, SIM_STATE_UNKNOWN): ad.log.info("Device has no or unknown SIM in it") # eSIM needs activation activate_esim_using_suw(ad) ensure_phone_idle(self.log, ad) elif self.user_params.get("Attenuator"): ad.log.info("Device in chamber room") ensure_phone_idle(self.log, ad) setup_droid_properties(self.log, ad, sim_conf_file) else: self.wait_for_sim_ready(ad) ensure_phone_default_state(self.log, ad) setup_droid_properties(self.log, ad, sim_conf_file) if getattr(ad, 'dsds', False): default_slot = getattr(ad, "default_slot", 0) if get_subid_from_slot_index(ad.log, ad, default_slot) != INVALID_SUB_ID: ad.log.info("Slot %s is the default slot.", default_slot) set_default_sub_for_all_services(ad, default_slot) else: ad.log.warning("Slot %s is NOT a valid slot. Slot %s will be used by default.", default_slot, 1-default_slot) set_default_sub_for_all_services(ad, 1-default_slot) setattr(ad, "default_slot", 1-default_slot) # Activate WFC on Verizon, AT&T and Canada operators as per # b/33187374 & # b/122327716 activate_wfc_on_device(self.log, ad) # Sub ID setup initial_set_up_for_subid_infomation(self.log, ad) #try: # ad.droid.wifiEnableVerboseLogging(WIFI_VERBOSE_LOGGING_ENABLED) #except Exception: # pass # Disable Emergency alerts # Set chrome browser start with no-first-run verification and # disable-fre. Give permission to read from and write to storage. for cmd in ("pm disable com.android.cellbroadcastreceiver", "pm grant com.android.chrome " "android.permission.READ_EXTERNAL_STORAGE", "pm grant com.android.chrome " "android.permission.WRITE_EXTERNAL_STORAGE", "rm /data/local/chrome-command-line", "am set-debug-app --persistent com.android.chrome", 'echo "chrome --no-default-browser-check --no-first-run ' '--disable-fre" > /data/local/tmp/chrome-command-line'): ad.adb.shell(cmd, ignore_status=True) # Curl for 2016/7 devices if not getattr(ad, "curl_capable", False): try: out = ad.adb.shell("/data/curl --version") if not out or "not found" in out: if int(ad.adb.getprop("ro.product.first_api_level")) >= 25: tel_data = self.user_params.get("tel_data", "tel_data") if isinstance(tel_data, list): tel_data = tel_data[0] curl_file_path = os.path.join(tel_data, "curl") if not os.path.isfile(curl_file_path): curl_file_path = os.path.join( self.user_params[Config.key_config_path.value], curl_file_path) if os.path.isfile(curl_file_path): ad.log.info("Pushing Curl to /data dir") ad.adb.push("%s /data" % (curl_file_path)) ad.adb.shell( "chmod 777 /data/curl", ignore_status=True) else: setattr(ad, "curl_capable", True) except Exception: ad.log.info("Failed to push curl on this device") # Ensure that a test class starts from a consistent state that # improves chances of valid network selection and facilitates # logging. try: if not set_phone_screen_on(self.log, ad): self.log.error("Failed to set phone screen-on time.") return False if not set_phone_silent_mode(self.log, ad): self.log.error("Failed to set phone silent mode.") return False ad.droid.telephonyAdjustPreciseCallStateListenLevel( PRECISE_CALL_STATE_LISTEN_LEVEL_FOREGROUND, True) ad.droid.telephonyAdjustPreciseCallStateListenLevel( PRECISE_CALL_STATE_LISTEN_LEVEL_RINGING, True) ad.droid.telephonyAdjustPreciseCallStateListenLevel( PRECISE_CALL_STATE_LISTEN_LEVEL_BACKGROUND, True) except Exception as e: self.log.error("Failure with %s", e) setattr(ad, "telephony_test_setup", True) return True
def test_case(*_): raise signals.TestAbortClass('Abort All')