def test_wifi_cell_irat_stress_ping(self): """Test for data switch between WiFi and Cell. DUT go in and out WiFi coverage for multiple times. Steps: 1. Set WiFi and Cellular signal to good (attenuation value to MIN). 2. Make sure DUT get Cell data coverage (LTE) and WiFi connected. 3. Set WiFi RSSI to MAX (WiFi attenuator value to MIN). 4. Verify DUT report WiFi connected and Internet access OK. 5. Set WiFi RSSI to MIN (WiFi attenuator value to MAX). 6. Verify DUT report Cellular Data connected and Internet access OK. 7. Repeat Step 3~6 for stress number. Expected Results: 4. DUT report WiFi connected and Internet access OK. 6. DUT report Cellular Data connected and Internet access OK. 7. Stress test should pass. Returns: True if Pass. False if fail. """ ad = self.android_devices[0] if not self._basic_connectivity_check(): self.log.error("Basic Connectivity Check Failed") return False total_iteration = self.stress_test_number self.log.info("Stress test. Total iteration = %d.", total_iteration) current_iteration = 1 while (current_iteration <= total_iteration): self.log.info(">----Current iteration = %d/%d----<", current_iteration, total_iteration) self._atten_setup_wifi_cell() if (not wait_for_wifi_data_connection(self.log, ad, True) or not verify_internet_connection(self.log, ad)): ad.log.error("Data not on WiFi") get_telephony_signal_strength(ad) get_wifi_signal_strength(ad) break self._atten_setup_cell_only() if (not wait_for_cell_data_connection(self.log, ad, True) or not verify_internet_connection(self.log, ad)): ad.log.error("Data not on Cell") get_telephony_signal_strength(ad) get_wifi_signal_strength(ad) break self.log.info(">----Iteration : %d/%d succeed.----<", current_iteration, total_iteration) current_iteration += 1 if current_iteration <= total_iteration: self.log.info(">----Iteration : %d/%d failed.----<", current_iteration, total_iteration) return False else: return True
def test_lte_only_http_dl(self): """Test for 1GB file download on WiFi Only Steps: 1. Set WiFi atten to MIN and Cellular to MAX 2. Start downloading 1GB file from net 3. Verify is the download is successfull Expected Results: 1. File should download over WiFi Returns: True if Pass. False if fail. """ ad = self.android_devices[0] if not self._basic_connectivity_check(): self.log.error("Basic Connectivity Check Failed") return False self._atten_setup_lte_only() if (not wait_for_cell_data_connection(self.log, ad, True) or not verify_internet_connection(self.log, ad)): ad.log.error("Data not on LTE") get_telephony_signal_strength(ad) get_wifi_signal_strength(ad) return False ad.on_mobile_data = True if not active_file_download_test(self.log, ad, "512MB"): ad.log.error("HTTP file download failed on LTE") get_telephony_signal_strength(ad) get_wifi_signal_strength(ad) return False return True
def _check_lte_data(self): if not is_droid_in_network_generation(self.log, self.dut, GEN_4G, NETWORK_SERVICE_DATA): self.dut.log.error("Data is not on 4G network") return False if not verify_internet_connection(self.log, self.dut): self.log.error("Data not available on cell.") return False return True
def setup_test(self): get_baseband_and_gms_version(self.ad) if self.collect_logs: clear_logd_gnss_qxdm_log(self.ad) set_attenuator_gnss_signal(self.ad, self.attenuators, self.default_gnss_signal_attenuation) if not verify_internet_connection( self.ad.log, self.ad, retries=3, expected_state=True): raise signals.TestFailure("Fail to connect to LTE network.")
def setup_class(self): self.dut = self.android_devices[0] req_params = ['wifi_network', 'receiver_number', 'ping_count'] self.unpack_userparams(req_param_names=req_params) self.ssid_map = {} for network in self.wifi_network: SSID = network['SSID'].replace('-', '_') self.ssid_map[SSID] = network self.dut.droid.setMobileDataEnabled() if not tutils.verify_internet_connection( self.dut.log, self.dut, retries=3): tutils.abort_all_tests(self.dut.log, 'Internet connection Failed.')
def _check_csfb_enabled(self): if not call_setup_teardown(self.log, self.dut, self.ad_reference, self.dut, is_phone_in_call_csfb): self.log.error("CSFB Call Failed.") return False if not wait_for_network_generation( self.log, self.dut, GEN_4G, voice_or_data=NETWORK_SERVICE_DATA): self.dut.log.error("Data service failed to camp to 4G") return False if not verify_internet_connection(self.log, self.dut): self.log.error("Data not available on cell.") return False return True
def tethering_check_internet_connection(log, provider, client_list, check_interval, check_iteration): """During tethering test, check client(s) and provider Internet connection. Do the following for <check_iteration> times: Delay <check_interval> seconds. Check Tethering provider's Internet connection. Check each client's Internet connection. Args: log: log object. provider: android object provide WiFi tethering. client_list: a list of clients using tethered WiFi. check_interval: delay time between each around of Internet connection check. check_iteration: check Internet connection for how many times in total. Returns: True if no error happened. False otherwise. """ for i in range(1, check_iteration + 1): result = True time.sleep(check_interval) provider.log.info( "Provider check Internet connection after %s seconds.", check_interval * i) if not verify_internet_connection(log, provider): result = False continue for client in client_list: client.log.info( "Client check Internet connection after %s seconds.", check_interval * i) if not verify_internet_connection(log, client): result = False break if result: return result return False
def _wifi_cell_irat_task(self, ad, irat_wait_time=60): """ Atten only WiFi to MIN and MAX WiFi --> Cellular """ self._atten_setup_wifi_cell() if (not wait_for_wifi_data_connection(self.log, ad, True, irat_wait_time) or not verify_internet_connection(self.log, ad)): ad.log.error("Data not on WiFi") get_telephony_signal_strength(ad) get_wifi_signal_strength(ad) return False ad.log.info("Triggering WiFi to Cellular IRAT") self._atten_setup_cell_only() if (not wait_for_cell_data_connection(self.log, ad, True, irat_wait_time) or not verify_internet_connection(self.log, ad)): ad.log.error("Data not on Cell") get_telephony_signal_strength(ad) get_wifi_signal_strength(ad) return False return True
def test_check_environment(self): ad = self.android_devices[0] # Check WiFi environment. # 1. Connect to WiFi. # 2. Check WiFi have Internet access. try: if not ensure_wifi_connected(self.log, ad, self.wifi_network_ssid, self.wifi_network_pass): abort_all_tests(ad.log, "WiFi connect fail") if (not wait_for_wifi_data_connection(self.log, ad, True) or not verify_internet_connection(self.log, ad)): abort_all_tests(ad.log, "Data not available on WiFi") finally: wifi_toggle_state(self.log, ad, False) # TODO: add more environment check here. return True
def _check_3g(self): self.log.info("Check 3G data and CS call") if not phone_setup_voice_3g(self.log, self.dut): self.log.error("Failed to setup 3G") return False if not verify_internet_connection(self.log, self.dut): self.log.error("Data not available on cell.") return False if not call_setup_teardown(self.log, self.dut, self.ad_reference, self.dut, is_phone_in_call_3g): self.log.error("WFC Call Failed.") return False if not sms_send_receive_verify(self.log, self.dut, self.ad_reference, [rand_ascii_str(50)]): self.log.error("SMS failed in 3G") return False return True
def test_lte_oos_lte_camping(self): """Test for Out Of Service Scenarios Steps: 1. Set WiFi and Cell available 2. Setup Attenuator as No Service Scenario 3. Verify there is no LTE or WiFi Signal 4. Wait for 2 mins 5. Setup Attenuator as Cellular only service 6. Verify Data Connection Expected Results: 1. Device should camp back on LTE after OOS 2. Data should be in working state Returns: True if Pass. False if fail. """ ad = self.android_devices[0] if not self._basic_connectivity_check(): self.log.error("Basic Connectivity Check Failed") return False self._atten_setup_no_service() ad.log.info("Waiting for 1 min") time.sleep(60) if (wait_for_cell_data_connection(self.log, ad, True) or wait_for_wifi_data_connection(self.log, ad, True)): ad.log.error("Data is available, Expecting no Cellular/WiFi Signal") get_telephony_signal_strength(ad) get_wifi_signal_strength(ad) return False ad.log.info("Waiting for 2 mins") time.sleep(120) self._atten_setup_lte_only() ad.on_mobile_data = True if (not wait_for_cell_data_connection(self.log, ad, True) or not verify_internet_connection(self.log, ad)): ad.log.error("Data not on LTE") get_telephony_signal_strength(ad) get_wifi_signal_strength(ad) return False return True
def change_data_sim_and_verify_data(log, ad, sim_slot): """Change Data SIM and verify Data attach and Internet access Args: log: log object. ad: android device object. sim_slot: SIM slot index. Returns: Data SIM changed successfully, data attached and Internet access is OK. """ sub_id = get_subid_from_slot_index(log, ad, sim_slot) ad.log.info("Change Data to subId: %s, SIM slot: %s", sub_id, sim_slot) set_subid_for_data(ad, sub_id) if not wait_for_data_attach_for_subscription(log, ad, sub_id, MAX_WAIT_TIME_NW_SELECTION): ad.log.error("Failed to attach data on subId:%s", sub_id) return False if not verify_internet_connection(log, ad): ad.log.error("No Internet access after changing Data SIM.") return False return True
def check_emergency_call_back_mode(self, by_emergency_dialer=True, non_emergency_call_allowed=True, attemps=3): state = "true" if non_emergency_call_allowed else "false" self.set_allow_non_emergency_call(state) result = True for _ in range(attemps): if not self.change_emergency_number_list(): self.dut.log.error("Unable to add number to ril.ecclist") return False last_call_number = dumpsys_last_call_number(self.dut) self.dut.log.info("Hung up fake emergency call in ringing") if by_emergency_dialer: initiate_emergency_dialer_call_by_adb( self.log, self.dut, self.fake_emergency_number, timeout=0) else: callee = "+%s" % self.fake_emergency_number self.dut.droid.telecomCallNumber(callee) time.sleep(3) hangup_call_by_adb(self.dut) ecclist = self.dut.adb.getprop("ril.ecclist") self.dut.log.info("ril.ecclist = %s", ecclist) if self.fake_emergency_number in ecclist: break call_info = dumpsys_new_call_info(self.dut, last_call_number) if not call_info: return False call_tech = call_info.get("callTechnologies", "") if "CDMA" in call_tech: expected_ecbm = True expected_data = False expected_call = non_emergency_call_allowed elif "GSM" in call_tech: expected_ecbm = True expected_data = True expected_call = True else: expected_ecbm = False expected_data = True expected_call = True last_call_number = dumpsys_last_call_number(self.dut) begin_time = get_current_epoch_time() self.dut.ensure_screen_on() self.dut.exit_setup_wizard() reset_device_password(self.dut, None) call_check = call_setup_teardown(self.log, self.dut, self.android_devices[1], ad_hangup=self.dut) if call_check != expected_call: self.dut.log.error("Regular phone call is %s, expecting %s", call_check, expected_call) result = False call_info = dumpsys_new_call_info(self.dut, last_call_number) if not call_info: self.dut.log.error("New call is not in dumpsys telecom") return False if expected_ecbm: if "ecbm" in call_info["callProperties"]: self.dut.log.info("New call is in ecbm.") else: self.dut.log.error( "New call is not in emergency call back mode.") result = False else: if "ecbm" in call_info["callProperties"]: self.dut.log.error("New call is in emergency call back mode") result = False if not expected_data: if self.dut.droid.telephonyGetDataConnectionState(): self.dut.log.info( "Data connection is off as expected in ECB mode") self.dut.log.info("Wait for getting out of ecbm") if not wait_for_cell_data_connection(self.log, self.dut, True, 400): self.dut.log.error( "Data connection didn't come back after 5 minutes") result = False #if not self.dut.droid.telephonyGetDataConnectionState(): # self.dut.log.error( # "Data connection is not coming back") # result = False elif not verify_internet_connection(self.log, self.dut): self.dut.log.error( "Internet connection check failed after getting out of ECB" ) result = False else: self.dut.log.error("Data connection is not off in ECB mode") if not verify_internet_connection(self.log, self.dut, False): self.dut.log.error("Internet connection is not off") result = False else: if self.dut.droid.telephonyGetDataConnectionState(): self.dut.log.info("Data connection is on as expected") if not verify_internet_connection(self.log, self.dut): self.dut.log.error("Internet connection check failed") result = False else: self.dut.log.error("Data connection is off, expecting on") result = False if expected_call: return result elapsed_time = (get_current_epoch_time() - begin_time) / 1000 if elapsed_time < BLOCK_DURATION: time.sleep(BLOCK_DURATION - elapsed_time + 10) if not call_setup_teardown( self.log, self.dut, self.android_devices[1], ad_hangup=self.dut): self.dut.log.error("Regular phone call failed after out of ecbm") result = False return result
def airplane_mode_test(log, ad, retries=3): """ Test airplane mode basic on Phone and Live SIM. Ensure phone attach, data on, WiFi off and verify Internet. Turn on airplane mode to make sure detach. Turn off airplane mode to make sure attach. Verify Internet connection. Args: log: log object. ad: android object. Returns: True if pass; False if fail. """ if not ensure_phones_idle(log, [ad]): log.error("Failed to return phones to idle.") return False try: ad.droid.telephonyToggleDataConnection(True) wifi_toggle_state(log, ad, False) log.info("Step1: ensure attach") if not toggle_airplane_mode(log, ad, False): ad.log.error("Failed initial attach") return False for i in range(retries): if verify_internet_connection(log, ad): ad.log.info("Data available on cell.") break elif i == retries - 1: ad.log.error("Data not available on cell.") return False else: ad.log.warning("Attempt %d Data not available on cell" % (i + 1)) log.info("Step2: enable airplane mode and ensure detach") if not toggle_airplane_mode(log, ad, True): ad.log.error("Failed to enable Airplane Mode") return False if not wait_for_cell_data_connection(log, ad, False): ad.log.error("Failed to disable cell data connection") return False if verify_internet_connection(log, ad): ad.log.error("Data available in airplane mode.") return False log.info("Step3: disable airplane mode and ensure attach") if not toggle_airplane_mode(log, ad, False): ad.log.error("Failed to disable Airplane Mode") return False if not wait_for_cell_data_connection(log, ad, True): ad.log.error("Failed to enable cell data connection") return False time.sleep(WAIT_TIME_ANDROID_STATE_SETTLING) log.info("Step4 verify internet") for i in range(retries): if verify_internet_connection(log, ad): ad.log.info("Data available on cell.") break elif i == retries - 1: ad.log.error("Data not available on cell.") return False else: ad.log.warning("Attempt %d Data not available on cell" % (i + 1)) return True finally: toggle_airplane_mode(log, ad, False)
def test_wfc_setup_timing(self): """ Measures the time delay in enabling WiFi calling Steps: 1. Make sure DUT idle. 2. Turn on Airplane Mode, Set WiFi Calling to WiFi_Preferred. 3. Turn on WiFi, connect to WiFi AP and measure time delay. 4. Wait for WiFi connected, verify Internet and measure time delay. 5. Wait for rat to be reported as iwlan and measure time delay. 6. Wait for ims registered and measure time delay. 7. Wait for WiFi Calling feature bit to be True and measure time delay. Expected results: Time Delay in each step should be within pre-defined limit. Returns: Currently always return True. """ # TODO: b/26338119 Set pass/fail criteria time_values = { 'start': 0, 'wifi_enabled': 0, 'wifi_connected': 0, 'wifi_data': 0, 'iwlan_rat': 0, 'ims_registered': 0, 'wfc_enabled': 0, 'mo_call_success': 0 } wifi_reset(self.log, self.dut) toggle_airplane_mode_by_adb(self.log, self.dut, True) set_wfc_mode(self.log, self.dut, WFC_MODE_WIFI_PREFERRED) time_values['start'] = time.time() self.dut.log.info("Start Time %ss", time_values['start']) wifi_toggle_state(self.log, self.dut, True) time_values['wifi_enabled'] = time.time() self.dut.log.info("WiFi Enabled After %ss", time_values['wifi_enabled'] - time_values['start']) network = {WIFI_SSID_KEY: self.wifi_network_ssid} if self.wifi_network_pass: network[WIFI_PWD_KEY] = self.wifi_network_pass try: self.dut.droid.wifiConnectByConfig(network) except Exception: self.dut.log.info("Connecting to wifi by RPC wifiConnect instead") self.dut.droid.wifiConnect(network) self.dut.droid.wakeUpNow() if not wait_for_wifi_data_connection(self.log, self.dut, True, MAX_WAIT_TIME_WIFI_CONNECTION): self.dut.log.error("Failed WiFi connection, aborting!") return False time_values['wifi_connected'] = time.time() self.dut.log.info( "WiFi Connected After %ss", time_values['wifi_connected'] - time_values['wifi_enabled']) if not verify_internet_connection(self.log, self.dut, retries=3): self.dut.log.error("Failed to get user-plane traffic, aborting!") return False time_values['wifi_data'] = time.time() self.dut.log.info( "WifiData After %ss", time_values['wifi_data'] - time_values['wifi_connected']) if not wait_for_network_rat( self.log, self.dut, RAT_FAMILY_WLAN, voice_or_data=NETWORK_SERVICE_DATA): self.dut.log.error("Failed to set-up iwlan, aborting!") if is_droid_in_rat_family(self.log, self.dut, RAT_FAMILY_WLAN, NETWORK_SERVICE_DATA): self.dut.log.error( "Never received the event, but droid in iwlan") else: return False time_values['iwlan_rat'] = time.time() self.dut.log.info("iWLAN Reported After %ss", time_values['iwlan_rat'] - time_values['wifi_data']) if not wait_for_ims_registered(self.log, self.dut, MAX_WAIT_TIME_IMS_REGISTRATION): self.dut.log.error("Never received IMS registered, aborting") return False time_values['ims_registered'] = time.time() self.dut.log.info( "Ims Registered After %ss", time_values['ims_registered'] - time_values['iwlan_rat']) if not wait_for_wfc_enabled(self.log, self.dut, MAX_WAIT_TIME_WFC_ENABLED): self.dut.log.error("Never received WFC feature, aborting") return False time_values['wfc_enabled'] = time.time() self.dut.log.info( "Wifi Calling Feature Enabled After %ss", time_values['wfc_enabled'] - time_values['ims_registered']) set_wfc_mode(self.log, self.dut, WFC_MODE_DISABLED) wait_for_not_network_rat( self.log, self.dut, RAT_FAMILY_WLAN, voice_or_data=NETWORK_SERVICE_DATA) self.dut.log.info("\n\n------------------summary-----------------") self.dut.log.info("WiFi Enabled After %.2f seconds", time_values['wifi_enabled'] - time_values['start']) self.dut.log.info( "WiFi Connected After %.2f seconds", time_values['wifi_connected'] - time_values['wifi_enabled']) self.dut.log.info( "WifiData After %.2f s", time_values['wifi_data'] - time_values['wifi_connected']) self.dut.log.info("iWLAN Reported After %.2f seconds", time_values['iwlan_rat'] - time_values['wifi_data']) self.dut.log.info( "Ims Registered After %.2f seconds", time_values['ims_registered'] - time_values['iwlan_rat']) self.dut.log.info( "Wifi Calling Feature Enabled After %.2f seconds", time_values['wfc_enabled'] - time_values['ims_registered']) self.dut.log.info("\n\n") return True
def airplane_mode_test(log, ad, retries=3): """ Test airplane mode basic on Phone and Live SIM. Ensure phone attach, data on, WiFi off and verify Internet. Turn on airplane mode to make sure detach. Turn off airplane mode to make sure attach. Verify Internet connection. Args: log: log object. ad: android object. Returns: True if pass; False if fail. """ if not ensure_phones_idle(log, [ad]): log.error("Failed to return phones to idle.") return False try: ad.droid.telephonyToggleDataConnection(True) wifi_toggle_state(log, ad, False) ad.log.info("Step1: disable airplane mode and ensure attach") if not toggle_airplane_mode(log, ad, False): ad.log.error("Failed initial attach") return False if not wait_for_cell_data_connection(log, ad, True): ad.log.error("Failed to enable data connection.") return False if not verify_internet_connection(log, ad, retries=3): ad.log.error("Data not available on cell.") return False log.info("Step2: enable airplane mode and ensure detach") if not toggle_airplane_mode(log, ad, True): ad.log.error("Failed to enable Airplane Mode") return False if not wait_for_cell_data_connection(log, ad, False): ad.log.error("Failed to disable cell data connection") return False if not verify_internet_connection(log, ad, expected_state=False): ad.log.error("Data available in airplane mode.") return False log.info("Step3: disable airplane mode and ensure attach") if not toggle_airplane_mode(log, ad, False): ad.log.error("Failed to disable Airplane Mode") return False if not wait_for_cell_data_connection(log, ad, True): ad.log.error("Failed to enable cell data connection") return False if not verify_internet_connection(log, ad, retries=3): ad.log.warning("Data not available on cell") return False return True finally: toggle_airplane_mode(log, ad, False)
def wifi_tethering_setup_teardown(log, provider, client_list, ap_band=WIFI_CONFIG_APBAND_2G, check_interval=30, check_iteration=4, do_cleanup=True, ssid=None, password=None): """Test WiFi Tethering. Turn off WiFi on clients. Turn off data and reset WiFi on clients. Verify no Internet access on clients. Turn on WiFi tethering on provider. Clients connect to provider's WiFI. Verify Internet on provider and clients. Tear down WiFi tethering setup and clean up. Args: log: log object. provider: android object provide WiFi tethering. client_list: a list of clients using tethered WiFi. ap_band: setup WiFi tethering on 2G or 5G. This is optional, default value is WIFI_CONFIG_APBAND_2G check_interval: delay time between each around of Internet connection check. This is optional, default value is 30 (seconds). check_iteration: check Internet connection for how many times in total. This is optional, default value is 4 (4 times). do_cleanup: after WiFi tethering test, do clean up to tear down tethering setup or not. This is optional, default value is True. ssid: use this string as WiFi SSID to setup tethered WiFi network. This is optional. Default value is None. If it's None, a random string will be generated. password: use this string as WiFi password to setup tethered WiFi network. This is optional. Default value is None. If it's None, a random string will be generated. Returns: True if no error happened. False otherwise. """ log.info("--->Start wifi_tethering_setup_teardown<---") log.info("Provider: {}".format(provider.serial)) if not provider.droid.connectivityIsTetheringSupported(): provider.log.error( "Provider does not support tethering. Stop tethering test.") return False if ssid is None: ssid = rand_ascii_str(10) if password is None: password = rand_ascii_str(8) # No password if password == "": password = None try: for client in client_list: log.info("Client: {}".format(client.serial)) wifi_toggle_state(log, client, False) client.droid.telephonyToggleDataConnection(False) log.info("WiFI Tethering: Verify client have no Internet access.") for client in client_list: if not verify_internet_connection( log, client, expected_state=False): client.log.error("Turn off Data on client fail") return False provider.log.info( "Provider turn on WiFi tethering. SSID: %s, password: %s", ssid, password) if not start_wifi_tethering(log, provider, ssid, password, ap_band): provider.log.error("Provider start WiFi tethering failed.") return False time.sleep(WAIT_TIME_ANDROID_STATE_SETTLING) provider.log.info("Provider check Internet connection.") if not verify_internet_connection(log, provider): return False for client in client_list: client.log.info( "Client connect to WiFi and verify AP band correct.") if not ensure_wifi_connected(log, client, ssid, password): client.log.error("Client connect to WiFi failed.") return False wifi_info = client.droid.wifiGetConnectionInfo() if ap_band == WIFI_CONFIG_APBAND_5G: if wifi_info["is_24ghz"]: client.log.error("Expected 5g network. WiFi Info: %s", wifi_info) return False else: if wifi_info["is_5ghz"]: client.log.error("Expected 2g network. WiFi Info: %s", wifi_info) return False client.log.info("Client check Internet connection.") if (not wait_for_wifi_data_connection(log, client, True) or not verify_internet_connection(log, client)): client.log.error("No WiFi Data on client") return False if not tethering_check_internet_connection( log, provider, client_list, check_interval, check_iteration): return False finally: if (do_cleanup and (not wifi_tethering_cleanup(log, provider, client_list))): return False return True
def data_connectivity_single_bearer(log, ad, nw_gen): """Test data connection: single-bearer (no voice). Turn off airplane mode, enable Cellular Data. Ensure phone data generation is expected. Verify Internet. Disable Cellular Data, verify Internet is inaccessible. Enable Cellular Data, verify Internet. Args: log: log object. ad: android object. nw_gen: network generation the phone should on. Returns: True if success. False if failed. """ ensure_phones_idle(log, [ad]) wait_time = MAX_WAIT_TIME_NW_SELECTION if getattr(ad, 'roaming', False): wait_time = 2 * wait_time if not ensure_network_generation_for_subscription( log, ad, get_default_data_sub_id(ad), nw_gen, MAX_WAIT_TIME_NW_SELECTION, NETWORK_SERVICE_DATA): ad.log.error("Device failed to connect to %s in %s seconds.", nw_gen, wait_time) return False try: log.info("Step1 Airplane Off, Data On.") toggle_airplane_mode(log, ad, False) ad.droid.telephonyToggleDataConnection(True) if not wait_for_cell_data_connection( log, ad, True, timeout_value=wait_time): ad.log.error("Failed to enable data connection.") return False log.info("Step2 Verify internet") if not verify_internet_connection(log, ad, retries=3): ad.log.error("Data not available on cell.") return False log.info("Step3 Turn off data and verify not connected.") ad.droid.telephonyToggleDataConnection(False) if not wait_for_cell_data_connection(log, ad, False): ad.log.error("Step3 Failed to disable data connection.") return False if not verify_internet_connection(log, ad, expected_state=False): ad.log.error("Step3 Data still available when disabled.") return False log.info("Step4 Re-enable data.") ad.droid.telephonyToggleDataConnection(True) if not wait_for_cell_data_connection( log, ad, True, timeout_value=wait_time): ad.log.error("Step4 failed to re-enable data.") return False if not verify_internet_connection(log, ad, retries=3): ad.log.error("Data not available on cell.") return False if not is_droid_in_network_generation_for_subscription( log, ad, get_default_data_sub_id(ad), nw_gen, NETWORK_SERVICE_DATA): ad.log.error("Failed: droid is no longer on correct network") ad.log.info( "Expected:%s, Current:%s", nw_gen, rat_generation_from_rat( get_network_rat_for_subscription( log, ad, get_default_data_sub_id(ad), NETWORK_SERVICE_DATA))) return False return True finally: ad.droid.telephonyToggleDataConnection(True)
def airplane_mode_test(log, ad, retries=3): """ Test airplane mode basic on Phone and Live SIM. Ensure phone attach, data on, WiFi off and verify Internet. Turn on airplane mode to make sure detach. Turn off airplane mode to make sure attach. Verify Internet connection. Args: log: log object. ad: android object. Returns: True if pass; False if fail. """ if not ensure_phones_idle(log, [ad]): log.error("Failed to return phones to idle.") return False try: ad.droid.telephonyToggleDataConnection(True) wifi_toggle_state(log, ad, False) ad.log.info("Step1: disable airplane mode and ensure attach") if not toggle_airplane_mode(log, ad, False): ad.log.error("Failed initial attach") return False if not wait_for_state(get_service_state_by_adb, "IN_SERVICE", MAX_WAIT_TIME_FOR_STATE_CHANGE, WAIT_TIME_BETWEEN_STATE_CHECK, log, ad): ad.log.error("Current service state is not 'IN_SERVICE'.") return False time.sleep(30) if not ad.droid.connectivityNetworkIsConnected(): ad.log.error("Network is NOT connected!") return False if not wait_for_cell_data_connection(log, ad, True): ad.log.error("Failed to enable data connection.") return False if not verify_internet_connection(log, ad, retries=3): ad.log.error("Data not available on cell.") return False log.info("Step2: enable airplane mode and ensure detach") if not toggle_airplane_mode(log, ad, True): ad.log.error("Failed to enable Airplane Mode") return False if not wait_for_cell_data_connection(log, ad, False): ad.log.error("Failed to disable cell data connection") return False if not verify_internet_connection(log, ad, expected_state=False): ad.log.error("Data available in airplane mode.") return False log.info("Step3: disable airplane mode and ensure attach") if not toggle_airplane_mode(log, ad, False): ad.log.error("Failed to disable Airplane Mode") return False if not wait_for_state(get_service_state_by_adb, "IN_SERVICE", MAX_WAIT_TIME_FOR_STATE_CHANGE, WAIT_TIME_BETWEEN_STATE_CHECK, log, ad): ad.log.error("Current service state is not 'IN_SERVICE'.") return False time.sleep(30) if not ad.droid.connectivityNetworkIsConnected(): ad.log.warning("Network is NOT connected!") if not wait_for_cell_data_connection(log, ad, True): ad.log.error("Failed to enable cell data connection") return False if not verify_internet_connection(log, ad, retries=3): ad.log.warning("Data not available on cell") return False return True finally: toggle_airplane_mode(log, ad, False)
def wifi_cell_switching(log, ad, wifi_network_ssid, wifi_network_pass, nw_gen): """Test data connection network switching when phone on <nw_gen>. Ensure phone is on <nw_gen> Ensure WiFi can connect to live network, Airplane mode is off, data connection is on, WiFi is on. Turn off WiFi, verify data is on cell and browse to google.com is OK. Turn on WiFi, verify data is on WiFi and browse to google.com is OK. Turn off WiFi, verify data is on cell and browse to google.com is OK. Args: log: log object. ad: android object. wifi_network_ssid: ssid for live wifi network. wifi_network_pass: password for live wifi network. nw_gen: network generation the phone should be camped on. Returns: True if pass. """ try: if not ensure_network_generation_for_subscription( log, ad, get_default_data_sub_id(ad), nw_gen, MAX_WAIT_TIME_NW_SELECTION, NETWORK_SERVICE_DATA): ad.log.error("Device failed to register in %s", nw_gen) return False start_youtube_video(ad) # Ensure WiFi can connect to live network ad.log.info("Make sure phone can connect to live network by WIFI") if not ensure_wifi_connected(log, ad, wifi_network_ssid, wifi_network_pass): ad.log.error("WiFi connect fail.") return False log.info("Phone connected to WIFI.") log.info("Step1 Airplane Off, WiFi On, Data On.") toggle_airplane_mode(log, ad, False) wifi_toggle_state(log, ad, True) ad.droid.telephonyToggleDataConnection(True) if (not wait_for_wifi_data_connection(log, ad, True) or not verify_internet_connection(log, ad)): ad.log.error("Data is not on WiFi") return False log.info("Step2 WiFi is Off, Data is on Cell.") wifi_toggle_state(log, ad, False) if (not wait_for_cell_data_connection(log, ad, True) or not verify_internet_connection(log, ad)): ad.log.error("Data did not return to cell") return False log.info("Step3 WiFi is On, Data is on WiFi.") wifi_toggle_state(log, ad, True) if (not wait_for_wifi_data_connection(log, ad, True) or not verify_internet_connection(log, ad)): ad.log.error("Data did not return to WiFi") return False log.info("Step4 WiFi is Off, Data is on Cell.") wifi_toggle_state(log, ad, False) if (not wait_for_cell_data_connection(log, ad, True) or not verify_internet_connection(log, ad)): ad.log.error("Data did not return to cell") return False return True finally: ad.force_stop_apk("com.google.android.youtube") wifi_toggle_state(log, ad, False)
def _check_data(self): if not verify_internet_connection(self.log, self.dut): self.dut.log.error("Data connection is not available.") return False return True