#!/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))