def test_bt_on_toggle_airplane_mode_on_then_off(self): """Test that toggles airplane mode both on and off Turning airplane mode on should toggle Bluetooth off successfully. Turning airplane mode off should toggle Bluetooth back on. Steps: 1. Verify that Bluetooth state is on 2. Turn airplane mode on 3. Verify that Bluetooth state is off 4. Turn airplane mode off 5. Verify that Bluetooth state is on Expected Result: Bluetooth should toggle off successfully. Returns: Pass if True Fail if False TAGS: Bluetooth, Airplane Priority: 3 """ if not bluetooth_enabled_check(self.dut): self.log.error("Failed to set Bluetooth state to enabled") return False if not toggle_airplane_mode_by_adb(self.log, self.dut, True): self.log.error("Failed to toggle airplane mode on") return False if not toggle_airplane_mode_by_adb(self.log, self.dut, False): self.log.error("Failed to toggle airplane mode off") return False time.sleep(self.WAIT_TIME_ANDROID_STATE_SETTLING) return self.dut.droid.bluetoothCheckState()
def _account_registration(self, ad): toggle_airplane_mode_by_adb(self.log, ad, new_state=False) for cmd in _TYCHO_VERBOSE_LOGGING_CMDS: ad.adb.shell(cmd) if hasattr(ad, "user_account"): if self.check_project_fi_activated(ad, retries=2): ad.log.info("Project Fi is activated already") return True ad.exit_setup_wizard() if not ad.is_apk_installed("com.google.android.tradefed.account" ) and self.user_params.get( "account_util"): for _ in range(2): if self._install_account_util(ad): break else: ad.log.error( "Fail to install com.google.android.tradefed.account") return False ad.force_stop_apk(_TYCHO_PKG) if not ensure_wifi_connected(self.log, ad, self.wifi_network_ssid, self.wifi_network_pass): ad.log.error("Failed to connect to wifi") return False ad.log.info("Add google account") if not self._add_google_account(ad): ad.log.error("Failed to add google account") return False ad.adb.shell( 'am instrument -w -e account "*****@*****.**" -e password ' '"%s" -e sync true -e wait-for-checkin false ' 'com.google.android.tradefed.account/.AddAccount' % (ad.user_account, ad.user_password)) ad.log.info("Enable and activate tycho apk") if not ad.is_apk_installed(_TYCHO_PKG): ad.log.info("%s is not installed", _TYCHO_PKG) return False ad.adb.shell('pm enable %s' % _TYCHO_PKG) #ad.adb.shell(_TYCHO_SERVER_LAB_OVERRIDE_CMD) for i in range(1, self.activation_attemps + 1): if i == self.activation_attemps: ad.log.info("Reboot and try Fi activation again") reboot_device(ad) self.activate_fi_account(ad) if not self.check_project_fi_activated(ad): ad.log.error("Fail to activate Fi account on attempt-%s", i) if i == self.activation_attemps: return False else: ad.log.info("Fi account is activated successfully") break elif "Fi Network" in ad.adb.getprop("gsm.sim.operator.alpha"): ad.log.error("Google account is not provided for Fi Network") return False if not ensure_phone_subscription(self.log, ad): ad.log.error("Unable to find a valid subscription!") return False refresh_droid_config(self.log, ad) return True
def check_normal_call(self): result = True if "wfc" not in self.test_name: toggle_airplane_mode_by_adb(self.log, self.dut, False) self.dut.ensure_screen_on() self.dut.exit_setup_wizard() reset_device_password(self.dut, None) begin_time = get_current_epoch_time() if not call_setup_teardown( self.log, self.android_devices[1], self.dut, ad_hangup=self.android_devices[1]): self.dut.log.error("Regular MT phone call fails") self.dut.log.info("call_info = %s", dumpsys_last_call_info( self.dut)) result = False if not call_setup_teardown( self.log, self.dut, self.android_devices[1], ad_hangup=self.dut): self.dut.log.error("Regular MO phone call fails") self.dut.log.info("call_info = %s", dumpsys_last_call_info( self.dut)) result = False return result
def test_fake_emergency_call_in_screen_lock_apm(self): """Test emergency call with emergency dialer in screen lock phase. Enable device password and then reboot upto password query window. Change system emergency number list to "611". Use the emergency dialer to call "611". Verify DUT has in call activity. Returns: True if success. False if failed. """ try: toggle_airplane_mode_by_adb(self.log, self.dut, True) if not self.dut.device_password and getattr(self.dut, "droid"): self.dut.droid.setDevicePassword("1111") self.dut.reboot(stop_at_lock_screen=True) if self.fake_emergency_call_test(): return True else: return False finally: toggle_airplane_mode_by_adb(self.log, self.dut, False) if not self.dut.ensure_screen_on(): self.dut.log.error("User screen cannot come up") return False self.dut.start_services(self.dut.skip_sl4a) if not self.dut.device_password: self.dut.droid.disableDevicePassword()
def setup_test(self): ensure_phone_default_state(self.log, self.ad, check_subscription=False) toggle_airplane_mode_by_adb(self.log, self.ad, True) self.ad.adb.shell("setprop net.lte.ims.volte.provisioned 1", ignore_status=True) # get a handle to virtual phone self.virtualPhoneHandle = self.anritsu.get_VirtualPhone() return True
def setup_test(self): for dut in self.android_devices: toggle_airplane_mode_by_adb(self.log, dut, False) if not bt_test_utils.connect_pri_to_sec( self.MCE, self.MSE, set([BtEnum.BluetoothProfile.MAP_MCE.value])): return False # Grace time for connection to complete. time.sleep(3)
def setup_test(self): try: self.ad.droid.telephonyFactoryReset() except Exception as e: self.ad.log.error(e) toggle_airplane_mode_by_adb(self.log, self.ad, True) self.ad.adb.shell("setprop net.lte.ims.volte.provisioned 1", ignore_status=True) # get a handle to virtual phone self.virtualPhoneHandle = self.anritsu.get_VirtualPhone() return True
def setup_test(self): try: if getattr(self, "qxdm_log", True): start_qxdm_loggers(self.log, self.android_devices) self.ad.droid.telephonyFactoryReset() if self.ad.sim_card == "VzW12349": self.ad.droid.imsSetVolteProvisioning(True) except Exception as e: self.ad.log.error(e) toggle_airplane_mode_by_adb(self.log, self.ad, True) # get a handle to virtual phone self.virtualPhoneHandle = self.anritsu.get_VirtualPhone() return True
def setup_test(self): if getattr(self, "qxdm_log", True): start_qxdm_loggers(self.log, self.android_devices) ensure_phone_default_state(self.log, self.ad, check_subscription=False) toggle_airplane_mode_by_adb(self.log, self.ad, True) try: if self.ad.sim_card == "VzW12349": self.ad.droid.imsSetVolteProvisioning(True) except Exception as e: self.ad.log.error(e) # get a handle to virtual phone self.virtualPhoneHandle = self.anritsu.get_VirtualPhone() return True
def test_fake_emergency_call_by_emergency_dialer_no_sim(self): """Test fake emergency call with emergency dialer in user account. Add fake emergency number to system emergency number list. Use the emergency dialer to call storyline. Verify DUT has in call activity. Returns: True if success. False if failed. """ toggle_airplane_mode_by_adb(self.log, self.dut, False) return self.fake_emergency_call_test()
def test_fake_emergency_call_in_apm_no_sim(self): """Test emergency call with emergency dialer in airplane mode. Enable airplane mode. Add storyline number to system emergency number list. Use the emergency dialer to call storyline. Verify DUT has in call activity. Returns: True if success. False if failed. """ toggle_airplane_mode_by_adb(self.log, self.dut, True) return self.fake_emergency_call_test()
def test_fake_emergency_call_by_emergency_dialer_ecbm(self): """Test emergency call with emergency dialer in user account. Add system emergency number list with fake emergency number. Configure allow_non_emergency_calls_in_ecm_bool true. Use the emergency dialer to call fake emergency number and hung up before connected. Verify DUT voice and data in ecbm mode. Returns: True if success. False if failed. """ toggle_airplane_mode_by_adb(self.log, self.dut, False) return self.check_emergency_call_back_mode()
def test_fake_emergency_call_by_emergency_dialer(self): """Test emergency call with emergency dialer in user account. Add system emergency number list with fake emergency number. Use the emergency dialer to call fake emergency number. Verify DUT has in call activity. Hung up fake emergency call in ringing. Bring DUT to normal state and make regular call. Returns: True if success. False if failed. """ toggle_airplane_mode_by_adb(self.log, self.dut, False) return self.fake_emergency_call_test() and self.check_normal_call()
def test_fake_emergency_call_in_apm(self): """Test emergency call with emergency dialer in airplane mode. Enable airplane mode. Add system emergency number list with fake emergency number. Use the emergency dialer to call fake emergency number. Verify DUT has in call activity. Bring DUT to normal state and make regular call. Returns: True if success. False if failed. """ toggle_airplane_mode_by_adb(self.log, self.dut, True) return self.fake_emergency_call_test() and self.check_normal_call()
def test_fake_emergency_call_in_screen_lock_apm_no_sim(self): """Test emergency call with emergency dialer in screen lock phase. Enable device password and then reboot upto password query window. Add storyline number to system emergency number list. Use the emergency dialer to call storyline. Verify DUT has in call activity. Returns: True if success. False if failed. """ toggle_airplane_mode_by_adb(self.log, self.dut, True) reset_device_password(self.dut, DEFAULT_DEVICE_PASSWORD) self.dut.reboot(stop_at_lock_screen=True) return self.fake_emergency_call_test()
def test_send_message_failure_no_cellular(self): if not toggle_airplane_mode_by_adb(self.log, self.MSE, True): return False bt_test_utils.reset_bluetooth([self.MSE]) bt_test_utils.connect_pri_to_sec( self.MCE, self.MSE, set([BtEnum.BluetoothProfile.MAP_MCE.value])) return not self.send_message([self.REMOTE])
def setup_test(self): super(BluetoothBaseTest, self).setup_test() # Ensure testcase starts with Airplane mode off if not toggle_airplane_mode_by_adb(self.log, self.dut, False): return False time.sleep(self.WAIT_TIME_ANDROID_STATE_SETTLING) return True
def test_bt_on_toggle_airplane_mode_on(self): """Test that toggles airplane mode on while BT on Turning airplane mode on should toggle Bluetooth off successfully. Steps: 1. Verify that Bluetooth state is on 2. Turn airplane mode on 3. Verify that Bluetooth state is off Expected Result: Bluetooth should toggle off successfully. Returns: Pass if True Fail if False TAGS: Bluetooth, Airplane Priority: 3 """ if not bluetooth_enabled_check(self.dut): self.log.error("Failed to set Bluetooth state to enabled") return False if not toggle_airplane_mode_by_adb(self.log, self.dut, True): self.log.error("Failed to toggle airplane mode on") return False return not self.dut.droid.bluetoothCheckState()
def test_bt_on_toggle_airplane_mode_on_bt_remains_off(self): """Test that verifies BT remains off after airplane mode toggles Turning airplane mode on should toggle Bluetooth off successfully and Bluetooth state should remain off. For this test we will use 60 seconds as a baseline. Steps: 1. Verify that Bluetooth state is on 2. Turn airplane mode on 3. Verify that Bluetooth state is off 3. Verify tat Bluetooth state remains off for 60 seconds Expected Result: Bluetooth should remain toggled off. Returns: Pass if True Fail if False TAGS: Bluetooth, Airplane Priority: 3 """ if not bluetooth_enabled_check(self.dut): self.log.error("Failed to set Bluetooth state to enabled") return False if not toggle_airplane_mode_by_adb(self.log, self.dut, True): self.log.error("Failed to toggle airplane mode on") return False toggle_timeout = 60 self.log.info( "Waiting {} seconds until verifying Bluetooth state.".format( toggle_timeout)) time.sleep(toggle_timeout) return not self.dut.droid.bluetoothCheckState()
def test_fake_emergency_call_in_apm_with_ecbm_call_block(self): """Test emergency call with emergency dialer in airplane mode. Enable airplane mode. Add system emergency number list with fake emergency number. Configure allow_non_emergency_calls_in_ecm_bool false. Call fake emergency number and hung up before connected. Verify DUT cannot make call in ecbm mode. Verify DUT can make call out of ecbm mode. Returns: True if success. False if failed. """ toggle_airplane_mode_by_adb(self.log, self.dut, True) return self.check_emergency_call_back_mode( non_emergency_call_allowed=False)
def test_send_message_failure_no_bluetooth(self): if not toggle_airplane_mode_by_adb(self.log, self.MSE, True): return False try: bt_test_utils.connect_pri_to_sec( self.MCE, self.MSE, set([BtEnum.BluetoothProfile.MAP_MCE.value])) except acts.controllers.android.SL4AAPIError: self.MCE.log.info("Failed to connect as expected") return not self.send_message([self.REMOTE])
def test_fake_emergency_call_in_apm(self): """Test emergency call with emergency dialer in airplane mode. Enable airplane mode. Change system emergency number list to "611". Use the emergency dialer to call "611". Verify DUT has in call activity. Returns: True if success. False if failed. """ try: toggle_airplane_mode_by_adb(self.log, self.dut, True) if self.fake_emergency_call_test(): return True else: return False finally: toggle_airplane_mode_by_adb(self.log, self.dut, False)
def test_fake_emergency_call_in_screen_lock_apm(self): """Test emergency call with emergency dialer in screen lock phase. Enable device password and then reboot upto password query window. Add system emergency number list with fake emergency number. Use the emergency dialer to call fake emergency number. Verify DUT has in call activity. Bring DUT to normal state and make regular call. Returns: True if success. False if failed. """ toggle_airplane_mode_by_adb(self.log, self.dut, True) reset_device_password(self.dut, DEFAULT_DEVICE_PASSWORD) self.dut.reboot(stop_at_lock_screen=True) if not wait_for_sim_ready_by_adb(self.log, self.dut): self.dut.log.error("SIM is not ready") return False return self.fake_emergency_call_test() and self.check_normal_call()
def test_fake_emergency_call_in_screen_lock_apm_ecbm(self): """Test emergency call with emergency dialer in screen lock phase. Enable device password and then reboot upto password query window. Add system emergency number list with fake emergency number. Configure allow_non_emergency_calls_in_ecm_bool true. Call fake emergency number and hung up before connected. Verify DUT call and data activity in ecbm mode. Returns: True if success. False if failed. """ toggle_airplane_mode_by_adb(self.log, self.dut, True) reset_device_password(self.dut, DEFAULT_DEVICE_PASSWORD) self.dut.reboot(stop_at_lock_screen=True) if not wait_for_sim_ready_by_adb(self.log, self.dut): self.dut.log.error("SIM is not ready") return False return self.check_emergency_call_back_mode()
def disable_location_scanning(self): """Utility to disable location services from scanning. Unless the device is in airplane mode, even if WiFi is disabled the DUT will still perform occasional scans. This will greatly impact the power numbers. Returns: True if airplane mode is disabled and Bluetooth is enabled; False otherwise. """ self.ad.log.info("DUT phone Airplane is ON") if not toggle_airplane_mode_by_adb(self.log, self.android_devices[0], True): self.log.error("FAILED to toggle Airplane on") return False self.ad.log.info("DUT phone Bluetooth is ON") if not bluetooth_enabled_check(self.android_devices[0]): self.log.error("FAILED to enable Bluetooth on") return False return True
def orchestrate_and_verify_pan_connection(pan_dut, panu_dut): """Setups up a PAN conenction between two android devices. Args: pan_dut: the Android device providing tethering services panu_dut: the Android device using the internet connection from the pan_dut Returns: True if PAN connection and verification is successful, false if unsuccessful. """ if not toggle_airplane_mode_by_adb(log, panu_dut, True): panu_dut.log.error("Failed to toggle airplane mode on") return False if not bluetooth_enabled_check(panu_dut): return False if not bluetooth_enabled_check(pan_dut): return False pan_dut.droid.bluetoothPanSetBluetoothTethering(True) if not (pair_pri_to_sec(pan_dut, panu_dut)): return False if not pan_dut.droid.bluetoothPanIsTetheringOn(): pan_dut.log.error("Failed to enable Bluetooth tethering.") return False # Magic sleep needed to give the stack time in between bonding and # connecting the PAN profile. time.sleep(pan_connect_timeout) panu_dut.droid.bluetoothConnectBonded( pan_dut.droid.bluetoothGetLocalAddress()) if not verify_http_connection(log, panu_dut): panu_dut.log.error("Can't verify http connection on PANU device.") if not verify_http_connection(log, pan_dut): pan_dut.log.info( "Can't verify http connection on PAN service device") return False return True
def teardown_test(self): self.log.info("Stopping Simulation") self.anritsu.stop_simulation() toggle_airplane_mode_by_adb(self.log, self.ad, True) return True
def _phone_disable_airplane_mode(self, ad): return toggle_airplane_mode_by_adb(self.log, ad, False)
def _phone_setup_volte_airplane_mode(self, ad): toggle_volte(self.log, ad, True) return toggle_airplane_mode_by_adb(self.log, ad, True)
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