#!/usr/bin/env python3
#
#   Copyright 2016 - The Android Open Source Project
#
#   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.
"""
Sanity tests for voice tests in telephony
"""
import time

from acts.controllers.anritsu_lib._anritsu_utils import AnritsuError
from acts.controllers.anritsu_lib.md8475a import CsfbType
from acts.controllers.anritsu_lib.md8475a import MD8475A
from acts.controllers.anritsu_lib.md8475a import VirtualPhoneAutoAnswer
from acts_contrib.test_utils.tel.anritsu_utils import WAIT_TIME_ANRITSU_REG_AND_CALL
from acts_contrib.test_utils.tel.anritsu_utils import call_mo_setup_teardown
from acts_contrib.test_utils.tel.anritsu_utils import ims_call_cs_teardown
from acts_contrib.test_utils.tel.anritsu_utils import call_mt_setup_teardown
from acts_contrib.test_utils.tel.anritsu_utils import set_system_model_1x
from acts_contrib.test_utils.tel.anritsu_utils import set_system_model_1x_evdo
from acts_contrib.test_utils.tel.anritsu_utils import set_system_model_gsm
from acts_contrib.test_utils.tel.anritsu_utils import set_system_model_lte
from acts_contrib.test_utils.tel.anritsu_utils import set_system_model_lte_1x
from acts_contrib.test_utils.tel.anritsu_utils import set_system_model_lte_wcdma
from acts_contrib.test_utils.tel.anritsu_utils import set_system_model_lte_gsm
from acts_contrib.test_utils.tel.anritsu_utils import set_system_model_wcdma
from acts_contrib.test_utils.tel.anritsu_utils import set_usim_parameters
from acts_contrib.test_utils.tel.anritsu_utils import set_post_sim_params
from acts_contrib.test_utils.tel.tel_defines import CALL_TEARDOWN_PHONE
from acts_contrib.test_utils.tel.tel_defines import DEFAULT_EMERGENCY_CALL_NUMBER
from acts_contrib.test_utils.tel.tel_defines import EMERGENCY_CALL_NUMBERS
from acts_contrib.test_utils.tel.tel_defines import RAT_FAMILY_CDMA2000
from acts_contrib.test_utils.tel.tel_defines import RAT_FAMILY_GSM
from acts_contrib.test_utils.tel.tel_defines import RAT_FAMILY_LTE
from acts_contrib.test_utils.tel.tel_defines import RAT_FAMILY_UMTS
from acts_contrib.test_utils.tel.tel_defines import RAT_1XRTT
from acts_contrib.test_utils.tel.tel_defines import NETWORK_MODE_CDMA
from acts_contrib.test_utils.tel.tel_defines import NETWORK_MODE_GSM_ONLY
from acts_contrib.test_utils.tel.tel_defines import NETWORK_MODE_GSM_UMTS
from acts_contrib.test_utils.tel.tel_defines import NETWORK_MODE_LTE_CDMA_EVDO
from acts_contrib.test_utils.tel.tel_defines import NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA
from acts_contrib.test_utils.tel.tel_defines import NETWORK_MODE_LTE_GSM_WCDMA
from acts_contrib.test_utils.tel.tel_defines import WAIT_TIME_IN_CALL
from acts_contrib.test_utils.tel.tel_defines import WAIT_TIME_IN_CALL_FOR_IMS
from acts_contrib.test_utils.tel.tel_ims_utils import toggle_volte
from acts_contrib.test_utils.tel.tel_logging_utils import start_qxdm_loggers
from acts_contrib.test_utils.tel.tel_phone_setup_utils import ensure_network_rat
from acts_contrib.test_utils.tel.tel_phone_setup_utils import ensure_phone_default_state
from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_idle_volte
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 check_apm_mode_on_by_serial
from acts_contrib.test_utils.tel.tel_test_utils import set_apm_mode_on_by_serial
from acts_contrib.test_utils.tel.tel_test_utils import set_preferred_apn_by_adb
from acts_contrib.test_utils.tel.TelephonyBaseTest import TelephonyBaseTest
from acts.test_decorators import test_tracker_info
from acts.utils import exe_cmd


class TelLabEmergencyCallTest(TelephonyBaseTest):
    def setup_class(self):
        super().setup_class()
        try:
            self.stress_test_number = int(
                self.user_params["stress_test_number"])
            self.log.info("Executing {} calls per test in stress test mode".
                          format(self.stress_test_number))
        except KeyError:
            self.stress_test_number = 0
            self.log.info(
                "No 'stress_test_number' defined: running single iteration tests"
            )

        self.ad = self.android_devices[0]
        self.ad.sim_card = getattr(self.ad, "sim_card", None)
        self.md8475a_ip_address = self.user_params[
            "anritsu_md8475a_ip_address"]
        self.wlan_option = self.user_params.get("anritsu_wlan_option", False)
        self.md8475_version = self.user_params.get("md8475", "A")

        setattr(self, 'emergency_call_number', DEFAULT_EMERGENCY_CALL_NUMBER)
        if 'emergency_call_number' in self.user_params:
            self.emergency_call_number = self.user_params[
                'emergency_call_number']
            self.log.info("Using provided emergency call number: {}".format(
                self.emergency_call_number))
        if not self.emergency_call_number in EMERGENCY_CALL_NUMBERS:
            self.log.warning("Unknown Emergency Number {}".format(
                self.emergency_call_number))

        # Check for all adb devices on the linux machine, and set APM ON
        cmd = "|".join(("adb devices", "grep -i device$", "cut -f1"))
        output = exe_cmd(cmd)
        list_of_devices = output.decode("utf-8").split("\n")
        if len(list_of_devices) > 1:
            for i in range(len(list_of_devices) - 1):
                self.log.info("Serial %s", list_of_devices[i])
                if check_apm_mode_on_by_serial(self.ad, list_of_devices[i]):
                    self.log.info("Device is already in APM ON")
                else:
                    self.log.info("Device is not in APM, turning it ON")
                    set_apm_mode_on_by_serial(self.ad, list_of_devices[i])
                    if check_apm_mode_on_by_serial(self.ad,
                                                   list_of_devices[i]):
                        self.log.info("Device is now in APM ON")

        if self.ad.sim_card == "VzW12349":
            set_preferred_apn_by_adb(self.ad, "VZWINTERNET")

        try:
            self.anritsu = MD8475A(self.md8475a_ip_address, self.wlan_option,
                                   self.md8475_version)
        except AnritsuError:
            self.log.error("Error in connecting to Anritsu Simulator")
            return False
        return True

    def setup_test(self):
        if getattr(self, "qxdm_log", True):
            start_qxdm_loggers(self.log, self.android_devices)
        ensure_phone_default_state(self.log, self.ad, check_subscription=False)
        toggle_airplane_mode_by_adb(self.log, self.ad, True)
        try:
            if self.ad.sim_card == "VzW12349":
                self.ad.droid.imsSetVolteProvisioning(True)
        except Exception as e:
            self.ad.log.error(e)
        # get a handle to virtual phone
        self.virtualPhoneHandle = self.anritsu.get_VirtualPhone()
        return True

    def teardown_test(self):
        self.log.info("Stopping Simulation")
        self.anritsu.stop_simulation()
        toggle_airplane_mode_by_adb(self.log, self.ad, True)
        return True

    def teardown_class(self):
        self.anritsu.disconnect()
        return True

    def _setup_emergency_call(self,
                              set_simulation_func,
                              phone_setup_func,
                              phone_idle_func_after_registration=None,
                              is_ims_call=False,
                              is_wait_for_registration=True,
                              csfb_type=None,
                              srlte_csfb=None,
                              srvcc=None,
                              emergency_number=DEFAULT_EMERGENCY_CALL_NUMBER,
                              teardown_side=CALL_TEARDOWN_PHONE,
                              wait_time_in_call=WAIT_TIME_IN_CALL):
        try:
            set_simulation_func(self.anritsu, self.user_params,
                                self.ad.sim_card)
            set_usim_parameters(self.anritsu, self.ad.sim_card)
            if is_ims_call or srvcc or csfb_type:
                set_post_sim_params(self.anritsu, self.user_params,
                                    self.ad.sim_card)
            self.virtualPhoneHandle.auto_answer = (VirtualPhoneAutoAnswer.ON,
                                                   2)
            if csfb_type:
                self.anritsu.csfb_type = csfb_type
            if srlte_csfb == "lte_call_failure":
                self.anritsu.send_command("IMSPSAPAUTOANSWER 1,DISABLE")
                self.anritsu.start_simulation()
                self.anritsu.send_command("IMSSTARTVN 1")
                check_ims_reg = True
                check_ims_calling = True
            elif srlte_csfb == "ims_unregistered":
                self.anritsu.start_simulation()
                self.anritsu.send_command("IMSSTARTVN 1")
                self.anritsu.send_command(
                    "IMSCSCFBEHAVIOR 1,SENDERRORRESPONSE603")
                check_ims_reg = False
                check_ims_calling = False
            elif srlte_csfb == "ps911_unsupported":
                self.anritsu.send_command("EMCBS NOTSUPPORT,BTS1")
                self.anritsu.start_simulation()
                self.anritsu.send_command("IMSSTARTVN 1")
                check_ims_reg = True
                check_ims_calling = False
            elif srlte_csfb == "emc_barred":
                self.anritsu.send_command("ACBARRED USERSPECIFIC,BTS1")
                self.anritsu.send_command("LTEEMERGENCYACBARRED BARRED,BTS1")
                self.anritsu.start_simulation()
                self.anritsu.send_command("IMSSTARTVN 1")
                check_ims_reg = True
                check_ims_calling = False
            elif srvcc == "InCall":
                self.anritsu.start_simulation()
                self.anritsu.send_command("IMSSTARTVN 1")
                self.anritsu.send_command("IMSSTARTVN 2")
                self.anritsu.send_command("IMSSTARTVN 3")
                check_ims_reg = True
                check_ims_calling = True
            else:
                self.anritsu.start_simulation()
            if is_ims_call or csfb_type:
                self.anritsu.send_command("IMSSTARTVN 1")
                self.anritsu.send_command("IMSSTARTVN 2")
                self.anritsu.send_command("IMSSTARTVN 3")

            iterations = 1
            if self.stress_test_number > 0:
                iterations = self.stress_test_number
            successes = 0
            for i in range(1, iterations + 1):
                if self.stress_test_number:
                    self.log.info(
                        "Running iteration {} of {}".format(i, iterations))
                # FIXME: There's no good reason why this must be true;
                # I can only assume this was done to work around a problem
                self.ad.droid.telephonyToggleDataConnection(False)

                # turn off all other BTS to ensure UE registers on BTS1
                sim_model = (self.anritsu.get_simulation_model()).split(",")
                no_of_bts = len(sim_model)
                for i in range(2, no_of_bts + 1):
                    self.anritsu.send_command(
                        "OUTOFSERVICE OUT,BTS{}".format(i))

                if phone_setup_func is not None:
                    if not phone_setup_func(self.ad):
                        self.log.warning(
                            "phone_setup_func failed. Rebooting UE")
                        self.ad.reboot()
                        time.sleep(30)
                        if self.ad.sim_card == "VzW12349":
                            set_preferred_apn_by_adb(self.ad, "VZWINTERNET")
                        if not phone_setup_func(self.ad):
                            self.log.error("phone_setup_func failed.")
                            continue

                if is_wait_for_registration:
                    self.anritsu.wait_for_registration_state()

                if phone_idle_func_after_registration:
                    if not phone_idle_func_after_registration(self.log,
                                                              self.ad):
                        continue

                for i in range(2, no_of_bts + 1):
                    self.anritsu.send_command(
                        "OUTOFSERVICE IN,BTS{}".format(i))

                time.sleep(WAIT_TIME_ANRITSU_REG_AND_CALL)
                if srlte_csfb or srvcc:
                    if not ims_call_cs_teardown(
                            self.log, self.ad, self.anritsu, emergency_number,
                            CALL_TEARDOWN_PHONE, True, check_ims_reg,
                            check_ims_calling, srvcc,
                            WAIT_TIME_IN_CALL_FOR_IMS, WAIT_TIME_IN_CALL):
                        self.log.error(
                            "Phone {} Failed to make emergency call to {}"
                            .format(self.ad.serial, emergency_number))
                        continue
                else:
                    if not call_mo_setup_teardown(
                            self.log, self.ad, self.anritsu, emergency_number,
                            CALL_TEARDOWN_PHONE, True, WAIT_TIME_IN_CALL,
                            is_ims_call):
                        self.log.error(
                            "Phone {} Failed to make emergency call to {}"
                            .format(self.ad.serial, emergency_number))
                        continue
                successes += 1
                if self.stress_test_number:
                    self.log.info("Passed iteration {}".format(i))
            if self.stress_test_number:
                self.log.info("Total of {} successes out of {} attempts".
                              format(successes, iterations))
            return True if successes == iterations else False

        except AnritsuError as e:
            self.log.error("Error in connection with Anritsu Simulator: " +
                           str(e))
            return False
        except Exception as e:
            self.log.error("Exception during emergency call procedure: " + str(
                e))
            return False
        return True

    def _phone_setup_lte_wcdma(self, ad):
        toggle_volte(self.log, ad, False)
        return ensure_network_rat(
            self.log,
            ad,
            NETWORK_MODE_LTE_GSM_WCDMA,
            RAT_FAMILY_LTE,
            toggle_apm_after_setting=True)

    def _phone_setup_lte_1x(self, ad):
        return ensure_network_rat(
            self.log,
            ad,
            NETWORK_MODE_LTE_CDMA_EVDO,
            RAT_FAMILY_LTE,
            toggle_apm_after_setting=True)

    def _phone_setup_wcdma(self, ad):
        return ensure_network_rat(
            self.log,
            ad,
            NETWORK_MODE_GSM_UMTS,
            RAT_FAMILY_UMTS,
            toggle_apm_after_setting=True)

    def _phone_setup_gsm(self, ad):
        return ensure_network_rat(
            self.log,
            ad,
            NETWORK_MODE_GSM_ONLY,
            RAT_FAMILY_GSM,
            toggle_apm_after_setting=True)

    def _phone_setup_1x(self, ad):
        return ensure_network_rat(
            self.log,
            ad,
            NETWORK_MODE_CDMA,
            RAT_FAMILY_CDMA2000,
            toggle_apm_after_setting=True)

    def _phone_setup_airplane_mode(self, ad):
        return toggle_airplane_mode_by_adb(self.log, ad, True)

    def _phone_disable_airplane_mode(self, ad):
        return toggle_airplane_mode_by_adb(self.log, ad, False)

    def _phone_setup_volte_airplane_mode(self, ad):
        toggle_volte(self.log, ad, True)
        return toggle_airplane_mode_by_adb(self.log, ad, True)

    def _phone_setup_volte(self, ad):
        ad.droid.telephonyToggleDataConnection(True)
        toggle_volte(self.log, ad, True)
        return ensure_network_rat(
            self.log,
            ad,
            NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA,
            RAT_FAMILY_LTE,
            toggle_apm_after_setting=True)

    """ Tests Begin """

    @test_tracker_info(uuid="f5c93228-3b43-48a3-b509-796d41625171")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_lte_wcdma_csfb_redirection(self):
        """ Test Emergency call functionality on LTE.
            CSFB type is REDIRECTION

        Steps:
        1. Setup CallBox on LTE and WCDMA network, make sure DUT register on LTE network.
        2. Make an emergency call to 911. Make sure DUT does not CSFB to WCDMA.
        3. Make sure Anritsu receives the call and accept.
        4. Tear down the call.

        Expected Results:
        2. Emergency call succeed. DUT does not CSFB to WCDMA.
        3. Anritsu can accept the call.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_lte_wcdma,
            self._phone_setup_lte_wcdma,
            emergency_number=self.emergency_call_number,
            csfb_type=CsfbType.CSFB_TYPE_REDIRECTION,
            is_ims_call=True)

    @test_tracker_info(uuid="8deb6b21-2cb0-4241-bcad-6cd62a340b07")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_lte_wcdma_csfb_handover(self):
        """ Test Emergency call functionality on LTE.
            CSFB type is HANDOVER

        Steps:
        1. Setup CallBox on LTE and WCDMA network, make sure DUT register on LTE network.
        2. Make an emergency call to 911. Make sure DUT does not CSFB to WCDMA.
        3. Make sure Anritsu receives the call and accept.
        4. Tear down the call.

        Expected Results:
        2. Emergency call succeed. DUT does not CSFB to WCDMA.
        3. Anritsu can accept the call.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_lte_wcdma,
            self._phone_setup_lte_wcdma,
            emergency_number=self.emergency_call_number,
            csfb_type=CsfbType.CSFB_TYPE_HANDOVER,
            is_ims_call=True)

    @test_tracker_info(uuid="52b6b783-de77-497d-87e0-63c930e6c9bb")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_lte_1x_csfb(self):
        """ Test Emergency call functionality on LTE (CSFB to 1x).

        Steps:
        1. Setup CallBox on LTE and CDMA 1X network, make sure DUT register on LTE network.
        2. Make an emergency call to 911. Make sure DUT CSFB to 1x.
        3. Make sure Anritsu receives the call and accept.
        4. Tear down the call.

        Expected Results:
        2. Emergency call succeed. DUT CSFB to 1x.
        3. Anritsu can accept the call.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_lte_1x,
            self._phone_setup_lte_1x,
            emergency_number=self.emergency_call_number)

    @test_tracker_info(uuid="fcdd5a4f-fdf2-44dc-b1b2-44ab175791ce")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_wcdma(self):
        """ Test Emergency call functionality on WCDMA

        Steps:
        1. Setup CallBox on WCDMA network, make sure DUT register on WCDMA network.
        2. Make an emergency call to 911.
        3. Make sure Anritsu receives the call and accept.
        4. Tear down the call.

        Expected Results:
        2. Emergency call succeed.
        3. Anritsu can accept the call.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_wcdma,
            self._phone_setup_wcdma,
            emergency_number=self.emergency_call_number)

    @test_tracker_info(uuid="295c3188-24e2-4c53-80c6-3d3001e2ff16")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_gsm(self):
        """ Test Emergency call functionality on GSM

        Steps:
        1. Setup CallBox on GSM network, make sure DUT register on GSM network.
        2. Make an emergency call to 911.
        3. Make sure Anritsu receives the call and accept.
        4. Tear down the call.

        Expected Results:
        2. Emergency call succeed.
        3. Anritsu can accept the call.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_gsm,
            self._phone_setup_gsm,
            emergency_number=self.emergency_call_number)

    @test_tracker_info(uuid="4f21bfc0-a0a9-43b8-9285-dcfb131a3a04")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_1x(self):
        """ Test Emergency call functionality on CDMA 1X

        Steps:
        1. Setup CallBox on 1x network, make sure DUT register on 1x network.
        2. Make an emergency call to 911.
        3. Make sure Anritsu receives the call and accept.
        4. Tear down the call.

        Expected Results:
        2. Emergency call succeed.
        3. Anritsu can accept the call.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_1x,
            self._phone_setup_1x,
            emergency_number=self.emergency_call_number)

    @test_tracker_info(uuid="6dfd3e1d-7faa-426f-811a-ebd5e54f9c9a")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_1x_evdo(self):
        """ Test Emergency call functionality on CDMA 1X with EVDO

        Steps:
        1. Setup CallBox on 1x and EVDO network, make sure DUT register on 1x network.
        2. Make an emergency call to 911.
        3. Make sure Anritsu receives the call and accept.
        4. Tear down the call.

        Expected Results:
        2. Emergency call succeed.
        3. Anritsu can accept the call.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_1x_evdo,
            self._phone_setup_1x,
            emergency_number=self.emergency_call_number)

    @test_tracker_info(uuid="40f9897e-4924-4896-9f2c-0b4f45331251")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_1x_apm(self):
        """ Test Emergency call functionality on Airplane mode

        Steps:
        1. Setup CallBox on 1x network.
        2. Turn on Airplane mode on DUT. Make an emergency call to 911.
        3. Make sure Anritsu receives the call and accept.
        4. Tear down the call.

        Expected Results:
        2. Emergency call succeed.
        3. Anritsu can accept the call.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_1x,
            self._phone_setup_airplane_mode,
            is_wait_for_registration=False,
            emergency_number=self.emergency_call_number)

    @test_tracker_info(uuid="5997c004-449b-4a5e-816e-2ff0c0eb928d")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_wcdma_apm(self):
        """ Test Emergency call functionality on Airplane mode

        Steps:
        1. Setup CallBox on WCDMA network.
        2. Make an emergency call to 911.
        3. Make sure Anritsu receives the call and accept.
        4. Tear down the call.

        Expected Results:
        2. Emergency call succeed.
        3. Anritsu can accept the call.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_wcdma,
            self._phone_setup_airplane_mode,
            is_wait_for_registration=False,
            emergency_number=self.emergency_call_number)

    @test_tracker_info(uuid="9afde8d3-bdf0-41d9-af8c-2a8f36aae169")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_volte_wcdma_srvcc(self):
        """ Test Emergency call functionality,
        VoLTE to WCDMA SRVCC
        Steps:
        1. Setup CallBox on VoLTE network with WCDMA.
        2. Turn on DUT and enable VoLTE. Make an emergency call to 911.
        3. Check if VoLTE emergency call connected successfully.
        4. Handover the call to WCDMA and check if the call is still up.
        5. Tear down the call.

        Expected Results:
        1. VoLTE Emergency call is made successfully.
        2. After SRVCC, the 911 call is not dropped.
        3. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_lte_wcdma,
            self._phone_setup_volte,
            phone_idle_volte,
            srvcc="InCall",
            emergency_number=self.emergency_call_number,
            wait_time_in_call=WAIT_TIME_IN_CALL_FOR_IMS)

    @test_tracker_info(uuid="2e454f11-e77d-452a-bcac-7271378953ed")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_volte_gsm_srvcc(self):
        """ Test Emergency call functionality,
        VoLTE to GSM SRVCC
        Steps:
        1. Setup CallBox on VoLTE network with GSM.
        2. Turn on DUT and enable VoLTE. Make an emergency call to 911.
        3. Check if VoLTE emergency call connected successfully.
        4. Handover the call to GSM and check if the call is still up.
        5. Tear down the call.

        Expected Results:
        1. VoLTE Emergency call is made successfully.
        2. After SRVCC, the 911 call is not dropped.
        3. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_lte_gsm,
            self._phone_setup_volte,
            phone_idle_volte,
            srvcc="InCall",
            emergency_number=self.emergency_call_number,
            wait_time_in_call=WAIT_TIME_IN_CALL_FOR_IMS)

    @test_tracker_info(uuid="4dae7e62-b73e-4ba1-92ee-ecc121b898b3")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_csfb_1x_lte_call_failure(self):
        """ Test Emergency call functionality,
        CSFB to CDMA1x after VoLTE call failure
        Ref: VzW LTE E911 test plan, 2.23, VZ_TC_LTEE911_7481
        Steps:
        1. Setup CallBox on VoLTE network with CDMA1x.
        2. Turn on DUT and enable VoLTE. Make an emergency call to 911.
        3. Make sure Anritsu IMS server does not answer the call
        4. The DUT requests CSFB to 1XCDMA and Anritsu accepts the call.
        5. Tear down the call.

        Expected Results:
        1. VoLTE Emergency call is made.
        2. Anritsu receive the call but does not answer.
        3. The 911 call CSFB to CDMA1x and answered successfully.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_lte_1x,
            self._phone_setup_volte,
            phone_idle_volte,
            srlte_csfb="lte_call_failure",
            emergency_number=self.emergency_call_number,
            wait_time_in_call=WAIT_TIME_IN_CALL_FOR_IMS)

    @test_tracker_info(uuid="e98c9101-1ab6-497e-9d67-a4ff62d28fea")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_csfb_1x_ims_unregistered(self):
        """ Test Emergency call functionality,
        CSFB to CDMA1x because ims registration delcined
        Ref: VzW LTE E911 test plan, 2.25, VZ_TC_LTEE911_7483
        Steps:
        1. Setup CallBox on VoLTE network with CDMA1x.
        2. Setup Anritsu IMS server to decline IMS registration
        3. Turn on DUT and enable VoLTE. Make an emergency call to 911.
        4. The DUT requests CSFB to 1XCDMA and Anritsu accepts the call.
        5. Tear down the call.

        Expected Results:
        1. Phone registers on LTE network with VoLTE enabled.
        2. When Emergency call is made, phone request CSFB to CDMA1x.
        3. The 911 call on CDMA1x is answered successfully.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_lte_1x,
            self._phone_setup_volte,
            None,
            srlte_csfb="ims_unregistered",
            emergency_number=self.emergency_call_number,
            wait_time_in_call=WAIT_TIME_IN_CALL_FOR_IMS)

    @test_tracker_info(uuid="d96e1b9b-2f6d-49f3-a203-f4277056869e")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_csfb_1x_ps911_unsupported(self):
        """ Test Emergency call functionality,
        CSFB to CDMA1x because MME does not support PS911, by setting
        Emergency Bearer Service not supported in EPS network feature
        Ref: VzW LTE E911 test plan, 2.26, VZ_TC_LTEE911_8357
        Steps:
        1. Setup CallBox on VoLTE network with CDMA1x.
        2. Setup Emergency Bearer Service not supported in EPS network feature
        3. Turn on DUT and enable VoLTE. Make an emergency call to 911.
        4. The DUT requests CSFB to 1XCDMA and Anritsu accepts the call.
        5. Tear down the call.

        Expected Results:
        1. Phone registers on LTE network with VoLTE enabled.
        2. When Emergency call is made, phone request CSFB to CDMA1x.
        3. The 911 call on CDMA1x is answered successfully.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_lte_1x,
            self._phone_setup_volte,
            phone_idle_volte,
            srlte_csfb="ps911_unsupported",
            emergency_number=self.emergency_call_number,
            wait_time_in_call=WAIT_TIME_IN_CALL_FOR_IMS)

    @test_tracker_info(uuid="f7d48841-b8ef-4031-99de-28534aaf4c44")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_csfb_1x_emc_barred(self):
        """ Test Emergency call functionality,
        CSFB to CDMA1x because SIB2 Emergency Barred,
        by setting Access Class Barred for Emergency
        Ref: VzW LTE E911 test plan, 2.27, VZ_TC_LTEE911_8358
        Steps:
        1. Setup CallBox on VoLTE network with CDMA1x.
        2. Set Access Class Barred for Emergency in SIB2
        3. Turn on DUT and enable VoLTE. Make an emergency call to 911.
        4. The DUT requests CSFB to 1XCDMA and Anritsu accepts the call.
        5. Tear down the call.

        Expected Results:
        1. Phone registers on LTE network with VoLTE enabled.
        2. When Emergency call is made, phone request CSFB to CDMA1x.
        3. The 911 call on CDMA1x is answered successfully.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_lte_1x,
            self._phone_setup_volte,
            phone_idle_volte,
            srlte_csfb="emc_barred",
            emergency_number=self.emergency_call_number,
            wait_time_in_call=WAIT_TIME_IN_CALL_FOR_IMS)

    @test_tracker_info(uuid="5bbbecec-0fef-430b-acbd-01ef7c7055c0")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_volte_1x(self):
        """ Test Emergency call functionality on VoLTE with CDMA1x
        Ref: VzW LTE E911 test plan, 2.24, VZ_TC_LTEE911_7482
        Steps:
        1. Setup CallBox on VoLTE network with CDMA1x.
        2. Turn on DUT and enable VoLTE. Make an emergency call to 911.
        3. Make sure Anritsu receives the call and accept.
        4. Tear down the call.

        Expected Results:
        2. Emergency call succeed.
        3. Anritsu can accept the call.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_lte_1x,
            self._phone_setup_volte,
            phone_idle_volte,
            is_ims_call=True,
            emergency_number=self.emergency_call_number,
            wait_time_in_call=WAIT_TIME_IN_CALL_FOR_IMS)

    @test_tracker_info(uuid="e32862e0-ec11-4de8-8b9a-851bab9feb29")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_volte(self):
        """ Test Emergency call functionality on VoLTE

        Steps:
        1. Setup CallBox on VoLTE network.
        2. Turn on DUT and enable VoLTE. Make an emergency call to 911.
        3. Make sure Anritsu receives the call and accept.
        4. Tear down the call.

        Expected Results:
        2. Emergency call succeed.
        3. Anritsu can accept the call.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_lte,
            self._phone_setup_volte,
            phone_idle_volte,
            is_ims_call=True,
            emergency_number=self.emergency_call_number,
            wait_time_in_call=WAIT_TIME_IN_CALL_FOR_IMS)

    @test_tracker_info(uuid="fa5b4e52-c249-42ec-a9d3-9523336f88f7")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_volte_apm(self):
        """ Test Emergency call functionality on VoLTE

        Steps:
        1. Setup CallBox on VoLTE network.
        2. Turn on Airplane mode on DUT. Make an emergency call to 911.
        3. Make sure Anritsu receives the call and accept.
        4. Tear down the call.

        Expected Results:
        2. Emergency call succeed.
        3. Anritsu can accept the call.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_lte,
            self._phone_setup_volte_airplane_mode,
            is_ims_call=True,
            is_wait_for_registration=False,
            emergency_number=self.emergency_call_number,
            wait_time_in_call=WAIT_TIME_IN_CALL_FOR_IMS)

    @test_tracker_info(uuid="260e4892-fdae-4d49-bfc6-04fe72a5a715")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_no_sim_wcdma(self):
        """ Test Emergency call functionality with no SIM.

        Steps:
        1. Setup CallBox on WCDMA network.
        2. Make an emergency call to 911.
        3. Make sure Anritsu receives the call and accept.
        4. Tear down the call.

        Expected Results:
        2. Emergency call succeed.
        3. Anritsu can accept the call.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_wcdma,
            self._phone_disable_airplane_mode,
            emergency_number=self.emergency_call_number,
            is_wait_for_registration=False)

    @test_tracker_info(uuid="2dbbbde5-c298-4a2d-ae65-b739d1dd1445")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_no_sim_1x(self):
        """ Test Emergency call functionality with no SIM.

        Steps:
        1. Setup CallBox on 1x network.
        2. Make an emergency call to 911.
        3. Make sure Anritsu receives the call and accept.
        4. Tear down the call.

        Expected Results:
        2. Emergency call succeed.
        3. Anritsu can accept the call.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_1x,
            self._phone_disable_airplane_mode,
            emergency_number=self.emergency_call_number,
            is_wait_for_registration=False)

    @test_tracker_info(uuid="fa77dee2-3235-42e0-b24d-c8fdb3fbef2f")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_no_sim_gsm(self):
        """ Test Emergency call functionality with no SIM.

        Steps:
        1. Setup CallBox on GSM network.
        2. Make an emergency call to 911.
        3. Make sure Anritsu receives the call and accept.
        4. Tear down the call.

        Expected Results:
        2. Emergency call succeed.
        3. Anritsu can accept the call.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_gsm,
            self._phone_disable_airplane_mode,
            emergency_number=self.emergency_call_number,
            is_wait_for_registration=False)

    @test_tracker_info(uuid="9ead5c6a-b4cb-40d5-80b0-54d3c7ad31ff")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_no_sim_volte(self):
        """ Test Emergency call functionality with no SIM.

        Steps:
        1. Setup CallBox on VoLTE network.
        2. Make an emergency call to 911.
        3. Make sure Anritsu receives the call and accept.
        4. Tear down the call.

        Expected Results:
        2. Emergency call succeed.
        3. Anritsu can accept the call.
        4. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        return self._setup_emergency_call(
            set_system_model_lte,
            self._phone_disable_airplane_mode,
            is_wait_for_registration=False,
            is_ims_call=True,
            emergency_number=self.emergency_call_number,
            wait_time_in_call=WAIT_TIME_IN_CALL_FOR_IMS)

    @test_tracker_info(uuid="d6bdc1d7-0a08-4e6e-9de8-4084abb48bad")
    @TelephonyBaseTest.tel_test_wrap
    def test_emergency_call_no_sim_1x_ecbm(self):
        """ Test Emergency call functionality with no SIM.

        Steps:
        1. Setup CallBox on 1x network.
        2. Make an emergency call to 911.
        3. Make sure Anritsu receives the call and accept.
        4. Tear down the call.
        5. Make a call from Callbox to DUT.
        6. Verify DUT receive the incoming call.
        7. Answer on DUT, verify DUT can answer the call correctly.
        8. Hangup the call on DUT.

        Expected Results:
        2. Emergency call succeed.
        3. Anritsu can accept the call.
        4. Tear down call succeed.
        6. DUT receive incoming call.
        7. DUT answer the call correctly.
        8. Tear down call succeed.

        Returns:
            True if pass; False if fail
        """
        if not self._setup_emergency_call(
                set_system_model_1x,
                self._phone_disable_airplane_mode,
                emergency_number=self.emergency_call_number,
                is_wait_for_registration=False):
            self.log.error("Failed to make 911 call.")
            return False
        return call_mt_setup_teardown(self.log, self.ad,
                                      self.anritsu.get_VirtualPhone(), None,
                                      CALL_TEARDOWN_PHONE, RAT_1XRTT)

    """ Tests End """