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
