| #!/usr/bin/env python3.4 |
| # |
| # Copyright 2021 - Google |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| """ |
| Test Script for IMS Settings |
| """ |
| |
| import time |
| |
| from acts import signals |
| from acts.test_decorators import test_tracker_info |
| from acts_contrib.test_utils.tel.TelephonyBaseTest import TelephonyBaseTest |
| from acts_contrib.test_utils.tel.tel_defines import CarrierConfigs |
| from acts_contrib.test_utils.tel.tel_defines import CAPABILITY_VOLTE |
| from acts_contrib.test_utils.tel.tel_defines import CAPABILITY_WFC |
| from acts_contrib.test_utils.tel.tel_defines import MAX_WAIT_TIME_WIFI_CONNECTION |
| from acts_contrib.test_utils.tel.tel_defines import NETWORK_SERVICE_DATA |
| from acts_contrib.test_utils.tel.tel_defines import MAX_WAIT_TIME_IMS_REGISTRATION |
| from acts_contrib.test_utils.tel.tel_defines import MAX_WAIT_TIME_WFC_ENABLED |
| from acts_contrib.test_utils.tel.tel_defines import RAT_FAMILY_WLAN |
| from acts_contrib.test_utils.tel.tel_defines import RAT_LTE |
| from acts_contrib.test_utils.tel.tel_defines import WFC_MODE_CELLULAR_PREFERRED |
| from acts_contrib.test_utils.tel.tel_defines import WFC_MODE_DISABLED |
| from acts_contrib.test_utils.tel.tel_defines import WFC_MODE_WIFI_PREFERRED |
| from acts_contrib.test_utils.tel.tel_bootloader_utils import fastboot_wipe |
| from acts_contrib.test_utils.tel.tel_data_utils import wait_for_wifi_data_connection |
| from acts_contrib.test_utils.tel.tel_ims_utils import set_wfc_mode |
| from acts_contrib.test_utils.tel.tel_ims_utils import toggle_volte |
| from acts_contrib.test_utils.tel.tel_ims_utils import wait_for_ims_registered |
| from acts_contrib.test_utils.tel.tel_ims_utils import wait_for_wfc_enabled |
| from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_setup_voice_3g |
| from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_setup_csfb |
| from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_setup_volte |
| from acts_contrib.test_utils.tel.tel_phone_setup_utils import wait_for_network_rat |
| from acts_contrib.test_utils.tel.tel_phone_setup_utils import wait_for_not_network_rat |
| from acts_contrib.test_utils.tel.tel_subscription_utils import get_outgoing_voice_sub_id |
| from acts_contrib.test_utils.tel.tel_test_utils import dumpsys_carrier_config |
| from acts_contrib.test_utils.tel.tel_test_utils import is_droid_in_rat_family |
| from acts_contrib.test_utils.tel.tel_test_utils import revert_default_telephony_setting |
| from acts_contrib.test_utils.tel.tel_test_utils import toggle_airplane_mode_by_adb |
| from acts_contrib.test_utils.tel.tel_test_utils import verify_default_telephony_setting |
| from acts_contrib.test_utils.tel.tel_test_utils import verify_internet_connection |
| from acts_contrib.test_utils.tel.tel_voice_utils import change_ims_setting |
| from acts_contrib.test_utils.tel.tel_voice_utils import verify_default_ims_setting |
| from acts_contrib.test_utils.tel.tel_wifi_utils import WIFI_SSID_KEY |
| from acts_contrib.test_utils.tel.tel_wifi_utils import WIFI_PWD_KEY |
| from acts_contrib.test_utils.tel.tel_wifi_utils import wifi_reset |
| from acts_contrib.test_utils.tel.tel_wifi_utils import wifi_toggle_state |
| |
| |
| class TelLiveImsSettingsTest(TelephonyBaseTest): |
| def setup_class(self): |
| TelephonyBaseTest.setup_class(self) |
| self.dut = self.android_devices[0] |
| self.dut_client = self.android_devices[1] |
| self.subid = get_outgoing_voice_sub_id(self.dut) |
| self.carrier_configs = dumpsys_carrier_config(self.dut)[self.subid] |
| self.dut_capabilities = self.dut.telephony["subscription"][ |
| self.subid].get("capabilities", []) |
| self.dut.log.info("DUT capabilities: %s", self.dut_capabilities) |
| if CAPABILITY_VOLTE not in self.dut_capabilities: |
| raise signals.TestAbortClass("VoLTE is not supported") |
| if CAPABILITY_WFC not in self.dut_capabilities: |
| raise signals.TestAbortClass("WFC is not supported") |
| |
| self.default_volte = (CAPABILITY_VOLTE in self.dut_capabilities) and ( |
| self.carrier_configs[CarrierConfigs. |
| ENHANCED_4G_LTE_ON_BY_DEFAULT_BOOL]) |
| self.default_wfc_enabled = ( |
| CAPABILITY_WFC in self.dut_capabilities |
| ) and ( |
| self.carrier_configs[CarrierConfigs.DEFAULT_WFC_IMS_ENABLED_BOOL]) |
| self.default_wfc_mode = self.carrier_configs.get( |
| CarrierConfigs.DEFAULT_WFC_IMS_MODE_INT, None) |
| self.dut_wfc_modes = self.dut.telephony[ |
| "subscription"][self.subid].get("wfc_modes", []) |
| |
| |
| @test_tracker_info(uuid="a3a680ba-d1e0-4770-a38c-4de8f15f9171") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_lte_volte_wifi_connected_toggle_wfc(self): |
| """Test for WiFi Calling settings: |
| LTE + VoLTE Enabled + WiFi Connected, Toggling WFC |
| |
| Steps: |
| 1. Setup DUT Idle, LTE network type, VoLTE enabled. |
| 2. Make sure DUT WiFi connected, WFC disabled. |
| 3. Set DUT WFC enabled (WiFi Preferred), verify DUT WFC available, |
| report iwlan rat. |
| 4. Set DUT WFC disabled, verify DUT WFC unavailable, |
| not report iwlan rat. |
| |
| Expected Results: |
| 3. DUT WiFi Calling feature bit return True, network rat is iwlan. |
| 4. DUT WiFi Calling feature bit return False, network rat is not iwlan. |
| """ |
| if not phone_setup_volte(self.log, self.dut): |
| self.log.error("Failed to setup VoLTE") |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=self.default_wfc_mode): |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=False, |
| nw_gen=RAT_LTE, |
| wfc_mode=None): |
| return False |
| return change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=None) |
| |
| @test_tracker_info(uuid="d3ffae75-ae4a-4ed8-9337-9155c413311d") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_lte_wifi_connected_toggle_wfc(self): |
| """Test for WiFi Calling settings: |
| LTE + VoLTE Disabled + WiFi Connected, Toggling WFC |
| |
| Steps: |
| 1. Setup DUT Idle, LTE network type, VoLTE disabled. |
| 2. Make sure DUT WiFi connected, WFC disabled. |
| 3. Set DUT WFC enabled (WiFi Preferred), verify DUT WFC available, |
| report iwlan rat. |
| 4. Set DUT WFC disabled, verify DUT WFC unavailable, |
| not report iwlan rat. |
| |
| Expected Results: |
| 3. DUT WiFi Calling feature bit return True, network rat is iwlan. |
| 4. DUT WiFi Calling feature bit return False, network rat is not iwlan. |
| """ |
| if not phone_setup_csfb(self.log, self.dut): |
| self.log.error("Failed to setup LTE") |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=self.default_wfc_mode): |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=False, |
| nw_gen=RAT_LTE, |
| wfc_mode=None): |
| return False |
| return change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=None) |
| |
| @test_tracker_info(uuid="29d2d7b7-1c31-4a2c-896a-3f6756c620ac") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_3g_wifi_connected_toggle_wfc(self): |
| """Test for WiFi Calling settings: |
| 3G + WiFi Connected, Toggling WFC |
| |
| Steps: |
| 1. Setup DUT Idle, 3G network type. |
| 2. Make sure DUT WiFi connected, WFC disabled. |
| 3. Set DUT WFC enabled (WiFi Preferred), verify DUT WFC available, |
| report iwlan rat. |
| 4. Set DUT WFC disabled, verify DUT WFC unavailable, |
| not report iwlan rat. |
| |
| Expected Results: |
| 3. DUT WiFi Calling feature bit return True, network rat is iwlan. |
| 4. DUT WiFi Calling feature bit return False, network rat is not iwlan. |
| """ |
| if not phone_setup_voice_3g(self.log, self.dut): |
| self.log.error("Failed to setup 3G") |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=self.default_wfc_mode): |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=False, |
| nw_gen=RAT_LTE, |
| wfc_mode=None): |
| return False |
| return change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=None) |
| |
| @test_tracker_info(uuid="ce2c0208-9ea0-4b31-91f4-d06a62cb927a") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_apm_wifi_connected_toggle_wfc(self): |
| """Test for WiFi Calling settings: |
| APM + WiFi Connected, Toggling WFC |
| |
| Steps: |
| 1. Setup DUT Idle, Airplane mode. |
| 2. Make sure DUT WiFi connected, WFC disabled. |
| 3. Set DUT WFC enabled (WiFi Preferred), verify DUT WFC available, |
| report iwlan rat. |
| 4. Set DUT WFC disabled, verify DUT WFC unavailable, |
| not report iwlan rat. |
| |
| Expected Results: |
| 3. DUT WiFi Calling feature bit return True, network rat is iwlan. |
| 4. DUT WiFi Calling feature bit return False, network rat is not iwlan. |
| """ |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=True, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=self.default_wfc_mode): |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=True, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=False, |
| nw_gen=RAT_LTE, |
| wfc_mode=None): |
| return False |
| return change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=True, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=None) |
| |
| @test_tracker_info(uuid="681e2448-32a2-434d-abd6-0bc2ab5afd9c") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_lte_volte_wfc_enabled_toggle_wifi(self): |
| """Test for WiFi Calling settings: |
| LTE + VoLTE Enabled + WFC enabled, Toggling WiFi |
| |
| Steps: |
| 1. Setup DUT Idle, LTE network type, VoLTE enabled. |
| 2. Make sure DUT WiFi disconnected, WFC enabled (WiFi Preferred). |
| 3. DUT connect WiFi, verify DUT WFC available, report iwlan rat. |
| 4. DUT disconnect WiFi,verify DUT WFC unavailable, not report iwlan rat. |
| |
| Expected Results: |
| 3. DUT WiFi Calling feature bit return True, network rat is iwlan. |
| 4. DUT WiFi Calling feature bit return False, network rat is not iwlan. |
| """ |
| if not phone_setup_volte(self.log, self.dut): |
| self.log.error("Failed to setup VoLTE") |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=self.default_wfc_mode): |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=False, |
| nw_gen=RAT_LTE, |
| wfc_mode=None): |
| return False |
| return change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=None) |
| |
| @test_tracker_info(uuid="63922066-9caa-42e6-bc9f-49f5ac01cbe2") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_lte_wfc_enabled_toggle_wifi(self): |
| """Test for WiFi Calling settings: |
| LTE + VoLTE Disabled + WFC enabled, Toggling WiFi |
| |
| Steps: |
| 1. Setup DUT Idle, LTE network type, VoLTE disabled. |
| 2. Make sure DUT WiFi disconnected, WFC enabled (WiFi Preferred). |
| 3. DUT connect WiFi, verify DUT WFC available, report iwlan rat. |
| 4. DUT disconnect WiFi,verify DUT WFC unavailable, not report iwlan rat. |
| |
| Expected Results: |
| 3. DUT WiFi Calling feature bit return True, network rat is iwlan. |
| 4. DUT WiFi Calling feature bit return False, network rat is not iwlan. |
| """ |
| if not phone_setup_csfb(self.log, self.dut): |
| self.log.error("Failed to setup CSFB") |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=self.default_wfc_mode): |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=False, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=None): |
| return False |
| return change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=None) |
| |
| @test_tracker_info(uuid="8a80a446-2116-4b19-b0ef-f771f30a6d15") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_3g_wfc_enabled_toggle_wifi(self): |
| """Test for WiFi Calling settings: |
| 3G + WFC enabled, Toggling WiFi |
| |
| Steps: |
| 1. Setup DUT Idle, 3G network type. |
| 2. Make sure DUT WiFi disconnected, WFC enabled (WiFi Preferred). |
| 3. DUT connect WiFi, verify DUT WFC available, report iwlan rat. |
| 4. DUT disconnect WiFi,verify DUT WFC unavailable, not report iwlan rat. |
| |
| Expected Results: |
| 3. DUT WiFi Calling feature bit return True, network rat is iwlan. |
| 4. DUT WiFi Calling feature bit return False, network rat is not iwlan. |
| """ |
| if not phone_setup_voice_3g(self.log, self.dut): |
| self.log.error("Failed to setup 3G") |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=self.default_wfc_mode): |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=False, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=None): |
| return False |
| return change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=None) |
| |
| @test_tracker_info(uuid="9889eebf-cde6-4f47-aec0-9cb204fdf2e5") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_apm_wfc_enabled_toggle_wifi(self): |
| """Test for WiFi Calling settings: |
| APM + WFC enabled, Toggling WiFi |
| |
| Steps: |
| 1. Setup DUT Idle, Airplane mode. |
| 2. Make sure DUT WiFi disconnected, WFC enabled (WiFi Preferred). |
| 3. DUT connect WiFi, verify DUT WFC available, report iwlan rat. |
| 4. DUT disconnect WiFi,verify DUT WFC unavailable, not report iwlan rat. |
| |
| Expected Results: |
| 3. DUT WiFi Calling feature bit return True, network rat is iwlan. |
| 4. DUT WiFi Calling feature bit return False, network rat is not iwlan. |
| """ |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=True, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=self.default_wfc_mode): |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=True, |
| wifi_enabled=False, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=None): |
| return False |
| return change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=True, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=None) |
| |
| @test_tracker_info(uuid="9b23e04b-4f70-4e73-88e7-6376262c739d") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_lte_wfc_enabled_wifi_connected_toggle_volte(self): |
| """Test for WiFi Calling settings: |
| LTE + VoLTE Enabled + WiFi Connected + WFC enabled, toggle VoLTE setting |
| |
| Steps: |
| 1. Setup DUT Idle, LTE network type, VoLTE enabled. |
| 2. Make sure DUT WiFi connected, WFC enabled (WiFi Preferred). |
| Verify DUT WFC available, report iwlan rat. |
| 3. Disable VoLTE on DUT, verify in 2 minutes period, |
| DUT does not lost WiFi Calling, DUT still report WFC available, |
| rat iwlan. |
| 4. Enable VoLTE on DUT, verify in 2 minutes period, |
| DUT does not lost WiFi Calling, DUT still report WFC available, |
| rat iwlan. |
| |
| Expected Results: |
| 2. DUT WiFi Calling feature bit return True, network rat is iwlan. |
| 3. DUT WiFi Calling feature bit return True, network rat is iwlan. |
| 4. DUT WiFi Calling feature bit return True, network rat is iwlan. |
| """ |
| if not phone_setup_volte(self.log, self.dut): |
| self.dut.log.error("Failed to setup VoLTE.") |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=self.default_wfc_mode): |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=None): |
| return False |
| return change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=None) |
| |
| @test_tracker_info(uuid="04bdfda4-06f7-41df-9352-a8534bc2a67a") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_lte_volte_wfc_wifi_preferred_to_cellular_preferred(self): |
| """Test for WiFi Calling settings: |
| LTE + VoLTE Enabled + WiFi Connected + WiFi Preferred, |
| change WFC to Cellular Preferred |
| |
| Steps: |
| 1. Setup DUT Idle, LTE network type, VoLTE enabled. |
| 2. Make sure DUT WiFi connected, WFC is set to WiFi Preferred. |
| Verify DUT WFC available, report iwlan rat. |
| 3. Change WFC setting to Cellular Preferred. |
| 4. Verify DUT report WFC not available. |
| |
| Expected Results: |
| 2. DUT WiFi Calling feature bit return True, network rat is iwlan. |
| 4. DUT WiFI Calling feature bit return False, network rat is not iwlan. |
| """ |
| if WFC_MODE_WIFI_PREFERRED not in self.dut_wfc_modes: |
| raise signals.TestSkip("WFC_MODE_WIFI_PREFERRED is not supported") |
| if WFC_MODE_CELLULAR_PREFERRED not in self.dut_wfc_modes: |
| raise signals.TestSkip( |
| "WFC_MODE_CELLULAR_PREFERRED is not supported") |
| if not phone_setup_volte(self.log, self.dut): |
| self.dut.log.error("Failed to setup VoLTE.") |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=WFC_MODE_WIFI_PREFERRED): |
| return False |
| return change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=WFC_MODE_CELLULAR_PREFERRED) |
| |
| @test_tracker_info(uuid="80d26bdb-992a-4b30-ad51-68308d5af168") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_lte_wfc_wifi_preferred_to_cellular_preferred(self): |
| """Test for WiFi Calling settings: |
| LTE + WiFi Connected + WiFi Preferred, change WFC to Cellular Preferred |
| |
| Steps: |
| 1. Setup DUT Idle, LTE network type, VoLTE disabled. |
| 2. Make sure DUT WiFi connected, WFC is set to WiFi Preferred. |
| Verify DUT WFC available, report iwlan rat. |
| 3. Change WFC setting to Cellular Preferred. |
| 4. Verify DUT report WFC not available. |
| |
| Expected Results: |
| 2. DUT WiFi Calling feature bit return True, network rat is iwlan. |
| 4. DUT WiFI Calling feature bit return False, network rat is not iwlan. |
| """ |
| if WFC_MODE_WIFI_PREFERRED not in self.dut_wfc_modes: |
| raise signals.TestSkip("WFC_MODE_WIFI_PREFERRED is not supported") |
| if WFC_MODE_CELLULAR_PREFERRED not in self.dut_wfc_modes: |
| raise signals.TestSkip( |
| "WFC_MODE_CELLULAR_PREFERRED is not supported") |
| if not phone_setup_csfb(self.log, self.dut): |
| self.dut.log.error("Failed to setup LTE.") |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=WFC_MODE_WIFI_PREFERRED): |
| return False |
| return change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=WFC_MODE_CELLULAR_PREFERRED) |
| |
| @test_tracker_info(uuid="d486c7e3-3d2b-4552-8af8-7b19f6347427") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_3g_wfc_wifi_preferred_to_cellular_preferred(self): |
| """Test for WiFi Calling settings: |
| 3G + WiFi Connected + WiFi Preferred, change WFC to Cellular Preferred |
| |
| Steps: |
| 1. Setup DUT Idle, 3G network type. |
| 2. Make sure DUT WiFi connected, WFC is set to WiFi Preferred. |
| Verify DUT WFC available, report iwlan rat. |
| 3. Change WFC setting to Cellular Preferred. |
| 4. Verify DUT report WFC not available. |
| |
| Expected Results: |
| 2. DUT WiFi Calling feature bit return True, network rat is iwlan. |
| 4. DUT WiFI Calling feature bit return False, network rat is not iwlan. |
| """ |
| if WFC_MODE_WIFI_PREFERRED not in self.dut_wfc_modes: |
| raise signals.TestSkip("WFC_MODE_WIFI_PREFERRED is not supported") |
| if WFC_MODE_CELLULAR_PREFERRED not in self.dut_wfc_modes: |
| raise signals.TestSkip( |
| "WFC_MODE_CELLULAR_PREFERRED is not supported") |
| if not phone_setup_voice_3g(self.dut.log, self.dut): |
| self.dut.log.error("Failed to setup 3G.") |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=WFC_MODE_WIFI_PREFERRED): |
| return False |
| return change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=WFC_MODE_CELLULAR_PREFERRED) |
| |
| @test_tracker_info(uuid="0feb0add-8e22-4c86-b13e-be68659cdd87") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_apm_wfc_wifi_preferred_to_cellular_preferred(self): |
| """Test for WiFi Calling settings: |
| APM + WiFi Connected + WiFi Preferred, change WFC to Cellular Preferred |
| |
| Steps: |
| 1. Setup DUT Idle, airplane mode. |
| 2. Make sure DUT WiFi connected, WFC is set to WiFi Preferred. |
| Verify DUT WFC available, report iwlan rat. |
| 3. Change WFC setting to Cellular Preferred. |
| 4. Verify DUT report WFC not available. |
| |
| Expected Results: |
| 2. DUT WiFi Calling feature bit return True, network rat is iwlan. |
| 4. DUT WiFI Calling feature bit return True, network rat is iwlan. |
| """ |
| if WFC_MODE_WIFI_PREFERRED not in self.dut_wfc_modes: |
| raise signals.TestSkip("WFC_MODE_WIFI_PREFERRED is not supported") |
| if WFC_MODE_CELLULAR_PREFERRED not in self.dut_wfc_modes: |
| raise signals.TestSkip( |
| "WFC_MODE_CELLULAR_PREFERRED is not supported") |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=True, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=WFC_MODE_WIFI_PREFERRED): |
| return False |
| return change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=True, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=WFC_MODE_CELLULAR_PREFERRED) |
| |
| @test_tracker_info(uuid="9c8f359f-a084-4413-b8a9-34771af166c5") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_lte_volte_wfc_cellular_preferred_to_wifi_preferred(self): |
| """Test for WiFi Calling settings: |
| LTE + VoLTE Enabled + WiFi Connected + Cellular Preferred, |
| change WFC to WiFi Preferred |
| |
| Steps: |
| 1. Setup DUT Idle, LTE network type, VoLTE enabled. |
| 2. Make sure DUT WiFi connected, WFC is set to Cellular Preferred. |
| Verify DUT WFC not available. |
| 3. Change WFC setting to WiFi Preferred. |
| 4. Verify DUT report WFC available. |
| |
| Expected Results: |
| 2. DUT WiFi Calling feature bit return False, network rat is not iwlan. |
| 4. DUT WiFI Calling feature bit return True, network rat is iwlan. |
| """ |
| if WFC_MODE_WIFI_PREFERRED not in self.dut_wfc_modes: |
| raise signals.TestSkip("WFC_MODE_WIFI_PREFERRED is not supported") |
| if WFC_MODE_CELLULAR_PREFERRED not in self.dut_wfc_modes: |
| raise signals.TestSkip( |
| "WFC_MODE_CELLULAR_PREFERRED is not supported") |
| if not phone_setup_volte(self.log, self.dut): |
| self.dut.log.error("Failed to setup VoLTE.") |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=WFC_MODE_CELLULAR_PREFERRED): |
| return False |
| return change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=WFC_MODE_WIFI_PREFERRED) |
| |
| @test_tracker_info(uuid="1894e685-63cf-43aa-91ed-938782ca35a9") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_lte_wfc_cellular_preferred_to_wifi_preferred(self): |
| """Test for WiFi Calling settings: |
| LTE + WiFi Connected + Cellular Preferred, change WFC to WiFi Preferred |
| |
| Steps: |
| 1. Setup DUT Idle, LTE network type, VoLTE disabled. |
| 2. Make sure DUT WiFi connected, WFC is set to Cellular Preferred. |
| Verify DUT WFC not available. |
| 3. Change WFC setting to WiFi Preferred. |
| 4. Verify DUT report WFC available. |
| |
| Expected Results: |
| 2. DUT WiFi Calling feature bit return False, network rat is not iwlan. |
| 4. DUT WiFI Calling feature bit return True, network rat is iwlan. |
| """ |
| if WFC_MODE_WIFI_PREFERRED not in self.dut_wfc_modes: |
| raise signals.TestSkip("WFC_MODE_WIFI_PREFERRED is not supported") |
| if WFC_MODE_CELLULAR_PREFERRED not in self.dut_wfc_modes: |
| raise signals.TestSkip( |
| "WFC_MODE_CELLULAR_PREFERRED is not supported") |
| if not phone_setup_csfb(self.log, self.dut): |
| self.dut.log.error("Failed to setup LTE.") |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=WFC_MODE_CELLULAR_PREFERRED): |
| return False |
| return change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=WFC_MODE_WIFI_PREFERRED) |
| |
| @test_tracker_info(uuid="e7fb6a6c-4672-44da-bca2-78b4d96dea9e") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_3g_wfc_cellular_preferred_to_wifi_preferred(self): |
| """Test for WiFi Calling settings: |
| 3G + WiFi Connected + Cellular Preferred, change WFC to WiFi Preferred |
| |
| Steps: |
| 1. Setup DUT Idle, 3G network type. |
| 2. Make sure DUT WiFi connected, WFC is set to Cellular Preferred. |
| Verify DUT WFC not available. |
| 3. Change WFC setting to WiFi Preferred. |
| 4. Verify DUT report WFC available. |
| |
| Expected Results: |
| 2. DUT WiFi Calling feature bit return False, network rat is not iwlan. |
| 4. DUT WiFI Calling feature bit return True, network rat is iwlan. |
| """ |
| if WFC_MODE_WIFI_PREFERRED not in self.dut_wfc_modes: |
| raise signals.TestSkip("WFC_MODE_WIFI_PREFERRED is not supported") |
| if WFC_MODE_CELLULAR_PREFERRED not in self.dut_wfc_modes: |
| raise signals.TestSkip( |
| "WFC_MODE_CELLULAR_PREFERRED is not supported") |
| if not phone_setup_voice_3g(self.log, self.dut): |
| self.dut.log.error("Failed to setup 3G.") |
| return False |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=WFC_MODE_CELLULAR_PREFERRED): |
| return False |
| return change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=WFC_MODE_WIFI_PREFERRED) |
| |
| @test_tracker_info(uuid="46262b2d-5de9-4984-87e8-42f44469289e") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_apm_wfc_cellular_preferred_to_wifi_preferred(self): |
| """Test for WiFi Calling settings: |
| APM + WiFi Connected + Cellular Preferred, change WFC to WiFi Preferred |
| |
| Steps: |
| 1. Setup DUT Idle, airplane mode. |
| 2. Make sure DUT WiFi connected, WFC is set to Cellular Preferred. |
| Verify DUT WFC not available. |
| 3. Change WFC setting to WiFi Preferred. |
| 4. Verify DUT report WFC available. |
| |
| Expected Results: |
| 2. DUT WiFi Calling feature bit return True, network rat is iwlan. |
| 4. DUT WiFI Calling feature bit return True, network rat is iwlan. |
| """ |
| if WFC_MODE_WIFI_PREFERRED not in self.dut_wfc_modes: |
| raise signals.TestSkip("WFC_MODE_WIFI_PREFERRED is not supported") |
| if WFC_MODE_CELLULAR_PREFERRED not in self.dut_wfc_modes: |
| raise signals.TestSkip( |
| "WFC_MODE_CELLULAR_PREFERRED is not supported") |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=True, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=WFC_MODE_CELLULAR_PREFERRED): |
| return False |
| return change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=True, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=WFC_MODE_WIFI_PREFERRED) |
| |
| @test_tracker_info(uuid="5b514f51-fed9-475e-99d3-17d2165e11a1") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_apm_wfc_wifi_preferred_turn_off_apm(self): |
| """Test for WiFi Calling settings: |
| APM + WiFi Connected + WiFi Preferred + turn off APM |
| |
| Steps: |
| 1. Setup DUT Idle in Airplane mode. |
| 2. Make sure DUT WiFi connected, set WFC mode to WiFi preferred. |
| 3. verify DUT WFC available, report iwlan rat. |
| 4. Turn off airplane mode. |
| 5. Verify DUT WFC still available, report iwlan rat |
| |
| Expected Results: |
| 3. DUT WiFi Calling feature bit return True, network rat is iwlan. |
| 5. DUT WiFI Calling feature bit return True, network rat is iwlan. |
| """ |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=True, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=WFC_MODE_WIFI_PREFERRED): |
| return False |
| return change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=None) |
| |
| @test_tracker_info(uuid="f328cff2-9dec-44b3-ba74-a662b76fcf2a") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_apm_wfc_cellular_preferred_turn_off_apm(self): |
| """Test for WiFi Calling settings: |
| APM + WiFi Connected + Cellular Preferred + turn off APM |
| |
| Steps: |
| 1. Setup DUT Idle in Airplane mode. |
| 2. Make sure DUT WiFi connected, set WFC mode to Cellular preferred. |
| 3. verify DUT WFC available, report iwlan rat. |
| 4. Turn off airplane mode. |
| 5. Verify DUT WFC not available, not report iwlan rat |
| |
| Expected Results: |
| 3. DUT WiFi Calling feature bit return True, network rat is iwlan. |
| 5. DUT WiFI Calling feature bit return False, network rat is not iwlan. |
| """ |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=True, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=WFC_MODE_CELLULAR_PREFERRED): |
| return False |
| return change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=False, |
| wifi_enabled=True, |
| volte_enabled=True, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=None) |
| |
| @test_tracker_info(uuid="7e30d219-42ee-4309-a95c-2b45b8831d26") |
| @TelephonyBaseTest.tel_test_wrap |
| 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 |
| |
| @test_tracker_info(uuid="135301ea-6d00-4233-98fd-cda706d61eb2") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_ims_factory_reset(self): |
| """Test VOLTE and WFC reset to factory default. |
| |
| Steps: |
| 1. Setup VoLTE, WFC, APM is various mode. |
| 2. Call IMS factory reset. |
| 3. Verify VoLTE and WFC are back to factory default. |
| 4. Verify VoLTE, WFC Voice call can be made successful if enabled. |
| |
| """ |
| result = True |
| wifi_enabled = True |
| for airplane_mode in (True, False): |
| for volte_enabled in (True, False): |
| for wfc_enabled in (True, False): |
| if wfc_enabled: |
| wfc_modes = self.dut_wfc_modes |
| else: |
| wfc_modes = [None] |
| for wfc_mode in wfc_modes: |
| if not change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=airplane_mode, |
| wifi_enabled=wifi_enabled, |
| volte_enabled=volte_enabled, |
| wfc_enabled=wfc_enabled, |
| nw_gen=RAT_LTE, |
| wfc_mode=wfc_mode): |
| result = False |
| self.dut.log.info("Call IMS factory reset") |
| self.dut.droid.telephonyFactoryReset() |
| if not verify_default_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| carrier_configs=self.carrier_configs, |
| default_wfc_enabled=self.default_wfc_enabled, |
| default_volte=self.default_volte, |
| wfc_mode=WFC_MODE_DISABLED): |
| result = False |
| return result |
| |
| @test_tracker_info(uuid="ce60740f-4d8e-4013-a7cf-65589e8a0893") |
| @TelephonyBaseTest.tel_test_wrap |
| def test_factory_reset_by_fastboot_wipe(self): |
| """Verify the network setting after factory reset by wipe. |
| |
| Steps: |
| 1. Config VoLTE, WFC, APM, data_roamingn, mobile_data, |
| preferred_network_mode to non-factory default. |
| 2. Factory reset by fastboot wipe. |
| 3. Verify network configs back to factory default. |
| |
| """ |
| self.dut.log.info("Set VoLTE off, WFC wifi preferred, APM on") |
| toggle_volte(self.log, self.dut, False) |
| revert_default_telephony_setting(self.dut) |
| change_ims_setting(log=self.log, |
| ad=self.dut, |
| dut_client= self.dut_client, |
| wifi_network_ssid=self.wifi_network_ssid, |
| wifi_network_pass=self.wifi_network_pass, |
| dut_capabilities=self.dut_capabilities, |
| subid=self.subid, |
| airplane_mode=True, |
| wifi_enabled=True, |
| volte_enabled=False, |
| wfc_enabled=True, |
| nw_gen=RAT_LTE, |
| wfc_mode=WFC_MODE_WIFI_PREFERRED) |
| self.dut.log.info("Wipe in fastboot") |
| fastboot_wipe(self.dut) |
| return verify_default_telephony_setting( |
| self.dut) and (self.verify_default_ims_setting(WFC_MODE_DISABLED)) |
| |
| |
