#!/usr/bin/env python3.4
#
#   Copyright 2022 - 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 Telephony Pre Check In Sanity
"""

import time

from acts import signals
from acts.test_decorators import test_tracker_info
from acts_contrib.test_utils.tel.loggers.protos.telephony_metric_pb2 import TelephonyVoiceTestResult
from acts_contrib.test_utils.tel.loggers.telephony_metric_logger import TelephonyMetricLogger
from acts_contrib.test_utils.tel.TelephonyBaseTest import TelephonyBaseTest
from acts_contrib.test_utils.tel.tel_data_utils import get_mobile_data_usage
from acts_contrib.test_utils.tel.tel_data_utils import remove_mobile_data_usage_limit
from acts_contrib.test_utils.tel.tel_data_utils import set_mobile_data_usage_limit
from acts_contrib.test_utils.tel.tel_data_utils import test_call_setup_in_active_data_transfer
from acts_contrib.test_utils.tel.tel_data_utils import test_call_setup_in_active_youtube_video
from acts_contrib.test_utils.tel.tel_data_utils import call_epdg_to_epdg_wfc
from acts_contrib.test_utils.tel.tel_data_utils import test_wifi_cell_switching_in_call
from acts_contrib.test_utils.tel.tel_defines import CARRIER_VZW
from acts_contrib.test_utils.tel.tel_defines import DIRECTION_MOBILE_ORIGINATED
from acts_contrib.test_utils.tel.tel_defines import DIRECTION_MOBILE_TERMINATED
from acts_contrib.test_utils.tel.tel_defines import GEN_2G
from acts_contrib.test_utils.tel.tel_defines import GEN_4G
from acts_contrib.test_utils.tel.tel_defines import GEN_3G
from acts_contrib.test_utils.tel.tel_defines import PHONE_TYPE_CDMA
from acts_contrib.test_utils.tel.tel_defines import PHONE_TYPE_GSM
from acts_contrib.test_utils.tel.tel_defines import TOTAL_LONG_CALL_DURATION
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_defines import WAIT_TIME_ANDROID_STATE_SETTLING
from acts_contrib.test_utils.tel.tel_defines import WFC_MODE_CELLULAR_PREFERRED
from acts_contrib.test_utils.tel.tel_defines import WFC_MODE_WIFI_ONLY
from acts_contrib.test_utils.tel.tel_defines import WFC_MODE_WIFI_PREFERRED
from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_idle_2g
from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_idle_3g
from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_idle_csfb
from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_idle_iwlan
from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_idle_volte
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_iwlan
from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_setup_iwlan_cellular_preferred
from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_setup_voice_2g
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_voice_general
from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_setup_volte
from acts_contrib.test_utils.tel.tel_subscription_utils import get_incoming_voice_sub_id
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 get_phone_number
from acts_contrib.test_utils.tel.tel_test_utils import install_dialer_apk
from acts_contrib.test_utils.tel.tel_test_utils import num_active_calls
from acts_contrib.test_utils.tel.tel_test_utils import STORY_LINE
from acts_contrib.test_utils.tel.tel_voice_utils import hangup_call
from acts_contrib.test_utils.tel.tel_voice_utils import hold_unhold_test
from acts_contrib.test_utils.tel.tel_voice_utils import initiate_call
from acts_contrib.test_utils.tel.tel_voice_utils import is_phone_in_call
from acts_contrib.test_utils.tel.tel_voice_utils import is_phone_in_call_1x
from acts_contrib.test_utils.tel.tel_voice_utils import is_phone_in_call_2g
from acts_contrib.test_utils.tel.tel_voice_utils import is_phone_in_call_3g
from acts_contrib.test_utils.tel.tel_voice_utils import is_phone_in_call_csfb
from acts_contrib.test_utils.tel.tel_voice_utils import is_phone_in_call_iwlan
from acts_contrib.test_utils.tel.tel_voice_utils import is_phone_in_call_not_iwlan
from acts_contrib.test_utils.tel.tel_voice_utils import is_phone_in_call_wcdma
from acts_contrib.test_utils.tel.tel_voice_utils import is_phone_in_call_volte
from acts_contrib.test_utils.tel.tel_voice_utils import _test_call_long_duration
from acts_contrib.test_utils.tel.tel_voice_utils import call_setup_teardown
from acts_contrib.test_utils.tel.tel_voice_utils import call_voicemail_erase_all_pending_voicemail
from acts_contrib.test_utils.tel.tel_voice_utils import two_phone_call_leave_voice_mail
from acts_contrib.test_utils.tel.tel_voice_utils import two_phone_call_long_seq
from acts_contrib.test_utils.tel.tel_voice_utils import two_phone_call_short_seq
from acts_contrib.test_utils.tel.tel_voice_utils import wait_and_answer_call
from acts_contrib.test_utils.tel.tel_voice_utils import wait_for_in_call_active
from acts_contrib.test_utils.tel.tel_voice_utils import wait_for_ringing_call
from acts_contrib.test_utils.tel.tel_wifi_utils import set_wifi_to_default
from acts_contrib.test_utils.tel.tel_wifi_utils import wifi_toggle_state
from acts.libs.utils.multithread import multithread_func

DEFAULT_PING_DURATION = 120  # in seconds

CallResult = TelephonyVoiceTestResult.CallResult.Value


class TelLiveVoiceTest(TelephonyBaseTest):
    def setup_class(self):
        super().setup_class()

        self.stress_test_number = self.get_stress_test_number()
        self.long_call_duration = self.user_params.get(
            "long_call_duration",
            TOTAL_LONG_CALL_DURATION)
        self.number_of_devices = 2
        self.call_server_number = self.user_params.get(
                "call_server_number", STORY_LINE)
        self.tel_logger = TelephonyMetricLogger.for_test_case()
        self.dialer_util = self.user_params.get("dialer_apk", None)
        if isinstance(self.dialer_util, list):
            self.dialer_util = self.dialer_util[0]

        if self.dialer_util:
            ads = self.android_devices
            for ad in ads:
                install_dialer_apk(ad, self.dialer_util)

    def get_carrier_name(self, ad):
        return ad.adb.getprop("gsm.sim.operator.alpha")

    def check_band_support(self,ad):
        carrier = ad.adb.getprop("gsm.sim.operator.alpha")

        if int(ad.adb.getprop("ro.product.first_api_level")) > 30 and (
                carrier == CARRIER_VZW):
            raise signals.TestSkip(
                "Device Doesn't Support 2g/3G Band.")

    def _is_phone_in_call_not_iwlan(self):
        return is_phone_in_call_not_iwlan(self.log, self.android_devices[0])

    def _is_phone_in_call_iwlan(self):
        return is_phone_in_call_iwlan(self.log, self.android_devices[0])


    """ Tests Begin """

    @TelephonyBaseTest.tel_test_wrap
    @test_tracker_info(uuid="c5009f8c-eb1d-4cd9-85ce-604298bbeb3e")
    def test_call_to_answering_machine(self):
        """ Voice call to an answering machine.

        1. Make Sure PhoneA attached to voice network.
        2. Call from PhoneA to Storyline
        3. Verify call is in ACTIVE state
        4. Hangup Call from PhoneA

        Raises:
            TestFailure if not success.
        """
        ad = self.android_devices[0]

        if not phone_setup_voice_general(ad.log, ad):
            ad.log.error("Phone Failed to Set Up Properly for Voice.")
            return False
        for iteration in range(3):
            result = True
            ad.log.info("Attempt %d", iteration + 1)
            if not initiate_call(ad.log, ad, self.call_server_number):
                ad.log.error("Call Failed to Initiate")
                result = False
                continue
            if not wait_for_in_call_active(ad, 60, 3):
                ad.log.error("Waiting for Call in Active Failed")
                result = False
            time.sleep(WAIT_TIME_IN_CALL)
            if not is_phone_in_call(ad.log, ad):
                ad.log.error("Call Dropped")
                result = False
            if not hangup_call(ad.log, ad):
                ad.log.error("Call Failed to Hangup")
                result = False
            if result:
                ad.log.info("Call test PASS in iteration %d", iteration + 1)
                return True
            time.sleep(WAIT_TIME_ANDROID_STATE_SETTLING)
        ad.log.info("Call test FAIL in all 3 iterations")
        return False


    @TelephonyBaseTest.tel_test_wrap
    @test_tracker_info(uuid="fca3f9e1-447a-416f-9a9c-50b7161981bf")
    def test_call_mo_voice_general(self):
        """ General voice to voice call.

        1. Make Sure PhoneA attached to voice network.
        2. Make Sure PhoneB attached to voice network.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices

        tasks = [(phone_setup_voice_general, (self.log, ads[0])),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(self.log, ads[0], None, None, ads[1],
                                        None, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @TelephonyBaseTest.tel_test_wrap
    @test_tracker_info(uuid="69faeb84-3830-47c0-ad80-dc657381a83b")
    def test_call_mt_voice_general(self):
        """ General voice to voice call.

        1. Make Sure PhoneA attached to voice network.
        2. Make Sure PhoneB attached to voice network.
        3. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        4. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices

        tasks = [(phone_setup_voice_general, (self.log, ads[0])),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(self.log, ads[1], None, None, ads[0],
                                        None, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="b2de097b-70e1-4242-b555-c1aa0a5acd8c")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_volte_to_volte(self):
        """ VoLTE to VoLTE call test

        1. Make Sure PhoneA is in LTE mode (with VoLTE).
        2. Make Sure PhoneB is in LTE mode (with VoLTE).
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices

        tasks = [(phone_setup_volte, (self.log, ads[0])), (phone_setup_volte,
                                                           (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(
            self.log, ads[0], phone_idle_volte, is_phone_in_call_volte, ads[1],
            phone_idle_volte, is_phone_in_call_volte, None,
            WAIT_TIME_IN_CALL_FOR_IMS)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="3c7f5a09-0177-4469-9994-cd5e7dd7c7fe")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_volte_to_volte_7_digit_dialing(self):
        """ VoLTE to VoLTE call test, dial with 7 digit number

        1. Make Sure PhoneA is in LTE mode (with VoLTE).
        2. Make Sure PhoneB is in LTE mode (with VoLTE).
        3. Call from PhoneA to PhoneB by 7-digit phone number, accept on PhoneB.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices
        if ads[0].droid.telephonyGetSimCountryIso() == "ca":
            raise signals.TestSkip("7 digit dialing not supported")
        tasks = [(phone_setup_volte, (self.log, ads[0])), (phone_setup_volte,
                                                           (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        return call_setup_teardown(
            self.log,
            ads[0],
            ads[1],
            ads[0],
            is_phone_in_call_volte,
            is_phone_in_call_volte,
            WAIT_TIME_IN_CALL_FOR_IMS,
            dialing_number_length=7)

    @test_tracker_info(uuid="721ef935-a03c-4d0f-85b9-4753d857162f")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_volte_to_volte_10_digit_dialing(self):
        """ VoLTE to VoLTE call test, dial with 10 digit number

        1. Make Sure PhoneA is in LTE mode (with VoLTE).
        2. Make Sure PhoneB is in LTE mode (with VoLTE).
        3. Call from PhoneA to PhoneB by 10-digit phone number, accept on PhoneB.

        Returns:
            True if pass; False if fail.
        """
        if self.android_devices[0].droid.telephonyGetSimCountryIso() == "ca":
            raise signals.TestSkip("10 digit dialing not supported")

        ads = self.android_devices

        tasks = [(phone_setup_volte, (self.log, ads[0])), (phone_setup_volte,
                                                           (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        if not call_setup_teardown(
            self.log,
            ads[0],
            ads[1],
            ads[0],
            is_phone_in_call_volte,
            is_phone_in_call_volte,
            WAIT_TIME_IN_CALL_FOR_IMS,
            dialing_number_length=10):
            return False

        return True

    @test_tracker_info(uuid="4fd3aa62-2398-4cee-994e-7fc5cadbcbc1")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_volte_to_volte_11_digit_dialing(self):
        """ VoLTE to VoLTE call test, dial with 11 digit number

        1. Make Sure PhoneA is in LTE mode (with VoLTE).
        2. Make Sure PhoneB is in LTE mode (with VoLTE).
        3. Call from PhoneA to PhoneB by 11-digit phone number, accept on PhoneB.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_volte, (self.log, ads[0])), (phone_setup_volte,
                                                           (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        return call_setup_teardown(
            self.log,
            ads[0],
            ads[1],
            ads[0],
            is_phone_in_call_volte,
            is_phone_in_call_volte,
            WAIT_TIME_IN_CALL_FOR_IMS,
            dialing_number_length=11)

    @test_tracker_info(uuid="969abdac-6a57-442a-9c40-48199bd8d556")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_volte_to_volte_12_digit_dialing(self):
        """ VoLTE to VoLTE call test, dial with 12 digit number

        1. Make Sure PhoneA is in LTE mode (with VoLTE).
        2. Make Sure PhoneB is in LTE mode (with VoLTE).
        3. Call from PhoneA to PhoneB by 12-digit phone number, accept on PhoneB.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_volte, (self.log, ads[0])), (phone_setup_volte,
                                                           (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        return call_setup_teardown(
            self.log,
            ads[0],
            ads[1],
            ads[0],
            is_phone_in_call_volte,
            is_phone_in_call_volte,
            WAIT_TIME_IN_CALL_FOR_IMS,
            dialing_number_length=12)

    @test_tracker_info(uuid="6b13a03d-c9ff-43d7-9798-adbead7688a4")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_volte_to_csfb_3g(self):
        """ VoLTE to CSFB 3G call test

        1. Make Sure PhoneA is in LTE mode (with VoLTE).
        2. Make Sure PhoneB is in LTE mode (without VoLTE).
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])

        tasks = [(phone_setup_volte, (self.log, ads[0])), (phone_setup_csfb,
                                                           (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(
            self.log, ads[0], phone_idle_volte, is_phone_in_call_volte, ads[1],
            phone_idle_csfb, is_phone_in_call_csfb, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="38096fdb-324a-4ce0-8836-8bbe713cffc2")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_volte_to_csfb_for_tmo(self):
        """ VoLTE to CSFB 3G call test for TMobile

        1. Make Sure PhoneA is in LTE mode (with VoLTE).
        2. Make Sure PhoneB is in LTE mode (without VoLTE, CSFB to WCDMA/GSM).
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])

        tasks = [(phone_setup_volte, (self.log, ads[0])), (phone_setup_csfb,
                                                           (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(self.log, ads[0], phone_idle_volte,
                                        None, ads[1], phone_idle_csfb,
                                        is_phone_in_call_csfb, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="82f9515d-a52b-4dec-93a5-997ffdbca76c")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_volte_to_csfb_1x_long(self):
        """ VoLTE to CSFB 1x call test

        1. Make Sure PhoneA is in LTE mode (with VoLTE).
        2. Make Sure PhoneB is in LTE mode (without VoLTE, CSFB to 1x).
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.
        5. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        6. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        # Make Sure PhoneB is CDMA phone.
        if ads[1].droid.telephonyGetPhoneType() != PHONE_TYPE_CDMA:
            self.log.error(
                "PhoneB not cdma phone, can not csfb 1x. Stop test.")
            self.tel_logger.set_result(CallResult("UNAVAILABLE_NETWORK_TYPE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "PhoneB not cdma, cannot csfb 1x."})

        tasks = [(phone_setup_volte, (self.log, ads[0])), (phone_setup_csfb,
                                                           (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_long_seq(
            self.log, ads[0], phone_idle_volte, is_phone_in_call_volte, ads[1],
            phone_idle_csfb, is_phone_in_call_1x, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="2e57fad6-5eaf-4e7d-8353-8aa6f4c52776")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_volte_to_csfb_long(self):
        """ VoLTE to CSFB WCDMA call test

        1. Make Sure PhoneA is in LTE mode (with VoLTE).
        2. Make Sure PhoneB is in LTE mode (without VoLTE, CSFB to WCDMA/GSM).
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.
        5. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        6. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        # Make Sure PhoneB is GSM phone.
        if ads[1].droid.telephonyGetPhoneType() != PHONE_TYPE_GSM:
            self.log.error(
                "PhoneB not gsm phone, can not csfb wcdma. Stop test.")
            self.tel_logger.set_result(CallResult("UNAVAILABLE_NETWORK_TYPE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "PhoneB not gsm, cannot csfb wcdma."})

        tasks = [(phone_setup_volte, (self.log, ads[0])), (phone_setup_csfb,
                                                           (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Setup Properly")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Setup Properly"})

        result = two_phone_call_long_seq(
            self.log, ads[0], phone_idle_volte, is_phone_in_call_volte, ads[1],
            phone_idle_csfb, is_phone_in_call_csfb, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="4bab759f-7610-4cec-893c-0a8aed95f70c")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_volte_to_3g(self):
        """ VoLTE to 3G call test

        1. Make Sure PhoneA is in LTE mode (with VoLTE).
        2. Make Sure PhoneB is in 3G mode.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])

        tasks = [(phone_setup_volte, (self.log, ads[0])),
                 (phone_setup_voice_3g, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

        result = two_phone_call_short_seq(
            self.log, ads[0], phone_idle_volte, is_phone_in_call_volte, ads[1],
            phone_idle_3g, is_phone_in_call_3g, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="b394cdc5-d88d-4659-8a26-0e58fde69974")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_volte_to_3g_1x_long(self):
        """ VoLTE to 3G 1x call test

        1. Make Sure PhoneA is in LTE mode (with VoLTE).
        2. Make Sure PhoneB is in 3G 1x mode.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.
        5. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        6. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])
        # Make Sure PhoneB is CDMA phone.
        if ads[1].droid.telephonyGetPhoneType() != PHONE_TYPE_CDMA:
            self.log.error("PhoneB not cdma phone, can not 3g 1x. Stop test.")
            self.tel_logger.set_result(CallResult("UNAVAILABLE_NETWORK_TYPE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "PhoneB not cdma phone, can not 3g 1x."})

        tasks = [(phone_setup_volte, (self.log, ads[0])),
                 (phone_setup_voice_3g, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_long_seq(
            self.log, ads[0], phone_idle_volte, is_phone_in_call_volte, ads[1],
            phone_idle_3g, is_phone_in_call_1x, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="b39a74a9-2a89-4c0b-ac4e-71ed9317bd75")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_volte_to_3g_wcdma_long(self):
        """ VoLTE to 3G WCDMA call test

        1. Make Sure PhoneA is in LTE mode (with VoLTE).
        2. Make Sure PhoneB is in 3G WCDMA mode.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.
        5. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        6. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])
        # Make Sure PhoneB is GSM phone.
        if ads[1].droid.telephonyGetPhoneType() != PHONE_TYPE_GSM:
            self.log.error(
                "PhoneB not gsm phone, can not 3g wcdma. Stop test.")
            self.tel_logger.set_result(CallResult('UNAVAILABLE_NETWORK_TYPE'))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "PhoneB not gsm phone, can not 3g wcdma."})

        tasks = [(phone_setup_volte, (self.log, ads[0])),
                 (phone_setup_voice_3g, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "PhoneB not gsm phone, can not 3g wcdma."})

        result = two_phone_call_long_seq(
            self.log, ads[0], phone_idle_volte, is_phone_in_call_volte, ads[1],
            phone_idle_3g, is_phone_in_call_wcdma, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="573bbcf1-6cbd-4084-9cb7-e14fb6c9521e")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_volte_to_2g(self):
        """ VoLTE to 2G call test

        1. Make Sure PhoneA is in LTE mode (with VoLTE).
        2. Make Sure PhoneB is in 2G mode.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])

        tasks = [(phone_setup_volte, (self.log, ads[0])),
                 (phone_setup_voice_2g, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(
            self.log, ads[0], phone_idle_volte, is_phone_in_call_volte, ads[1],
            phone_idle_2g, is_phone_in_call_2g, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="a4a043c0-f4ba-4405-9262-42c752cc4487")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_epdg_wfc_wifi_only(self):
        """ WiFi Only, WiFi calling to WiFi Calling test

        1. Setup PhoneA WFC mode: WIFI_ONLY.
        2. Setup PhoneB WFC mode: WIFI_ONLY.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Returns:
            True if pass; False if fail.
        """
        return call_epdg_to_epdg_wfc(self.log,
                                     self.android_devices,
                                     False,
                                     WFC_MODE_WIFI_ONLY,
                                     self.wifi_network_ssid,
                                     self.wifi_network_pass)

    @test_tracker_info(uuid="ae171d58-d4c1-43f7-aa93-4860b4b28d53")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_epdg_wfc_wifi_preferred(self):
        """ WiFi Preferred, WiFi calling to WiFi Calling test

        1. Setup PhoneA WFC mode: WIFI_PREFERRED.
        2. Setup PhoneB WFC mode: WIFI_PREFERRED.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Returns:
            True if pass; False if fail.
        """
        return call_epdg_to_epdg_wfc(self.log,
                                     self.android_devices,
                                     False,
                                     WFC_MODE_WIFI_PREFERRED,
                                     self.wifi_network_ssid,
                                     self.wifi_network_pass)

    @test_tracker_info(uuid="ece58857-fedc-49a9-bf10-b76bd78a51f2")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_epdg_wfc_cellular_preferred(self):
        """ Cellular Preferred, WiFi calling to WiFi Calling test

        1. Setup PhoneA WFC mode: CELLULAR_PREFERRED.
        2. Setup PhoneB WFC mode: CELLULAR_PREFERRED.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = [self.android_devices[0], self.android_devices[1]]
        tasks = [(phone_setup_iwlan_cellular_preferred,
                  (self.log, ads[0], self.wifi_network_ssid,
                   self.wifi_network_pass)),
                 (phone_setup_iwlan_cellular_preferred,
                  (self.log, ads[1], self.wifi_network_ssid,
                   self.wifi_network_pass))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(
            self.log, ads[0], None, is_phone_in_call_not_iwlan, ads[1], None,
            is_phone_in_call_not_iwlan, None, WAIT_TIME_IN_CALL_FOR_IMS)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="0d63c250-d9e7-490c-8c48-0a6afbad5f88")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_epdg_apm_wfc_wifi_only(self):
        """ Airplane + WiFi Only, WiFi calling to WiFi Calling test

        1. Setup PhoneA in airplane mode, WFC mode: WIFI_ONLY.
        2. Setup PhoneB in airplane mode, WFC mode: WIFI_ONLY.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Returns:
            True if pass; False if fail.
        """
        return call_epdg_to_epdg_wfc(self.log,
                                     self.android_devices,
                                     True,
                                     WFC_MODE_WIFI_ONLY,
                                     self.wifi_network_ssid,
                                     self.wifi_network_pass)

    @test_tracker_info(uuid="7678e4ee-29c6-4319-93ab-d555501d1876")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_epdg_apm_wfc_wifi_preferred(self):
        """ Airplane + WiFi Preferred, WiFi calling to WiFi Calling test

        1. Setup PhoneA in airplane mode, WFC mode: WIFI_PREFERRED.
        2. Setup PhoneB in airplane mode, WFC mode: WIFI_PREFERRED.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Returns:
            True if pass; False if fail.
        """
        return call_epdg_to_epdg_wfc(self.log,
                                     self.android_devices,
                                     True,
                                     WFC_MODE_WIFI_PREFERRED,
                                     self.wifi_network_ssid,
                                     self.wifi_network_pass)

    @test_tracker_info(uuid="8f5c637e-683a-448d-9443-b2b39626ab19")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_epdg_apm_wfc_cellular_preferred(self):
        """ Airplane + Cellular Preferred, WiFi calling to WiFi Calling test

        1. Setup PhoneA in airplane mode, WFC mode: CELLULAR_PREFERRED.
        2. Setup PhoneB in airplane mode, WFC mode: CELLULAR_PREFERRED.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Returns:
            True if pass; False if fail.
        """
        return call_epdg_to_epdg_wfc(self.log,
                                     self.android_devices,
                                     True,
                                     WFC_MODE_CELLULAR_PREFERRED,
                                     self.wifi_network_ssid,
                                     self.wifi_network_pass)

    @test_tracker_info(uuid="0b51666e-c83c-40b5-ba0f-737e64bc82a2")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_volte_wfc_wifi_only(self):
        """ WiFi Only, WiFi calling to VoLTE test

        1. Setup PhoneA WFC mode: WIFI_ONLY.
        2. Make Sure PhoneB is in LTE mode (with VoLTE enabled).
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], False, WFC_MODE_WIFI_ONLY,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_volte, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(
            self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
            phone_idle_volte, is_phone_in_call_volte, None,
            WAIT_TIME_IN_CALL_FOR_IMS)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="6e0630a9-63b2-4ea1-8ec9-6560f001905c")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_volte_wfc_wifi_preferred(self):
        """ WiFi Preferred, WiFi calling to VoLTE test

        1. Setup PhoneA WFC mode: WIFI_PREFERRED.
        2. Make Sure PhoneB is in LTE mode (with VoLTE enabled).
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_volte, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(
            self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
            phone_idle_volte, is_phone_in_call_volte, None,
            WAIT_TIME_IN_CALL_FOR_IMS)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="51077985-2229-491f-9a54-1ff53871758c")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_volte_apm_wfc_wifi_only(self):
        """ Airplane + WiFi Only, WiFi calling to VoLTE test

        1. Setup PhoneA in airplane mode, WFC mode: WIFI_ONLY.
        2. Make Sure PhoneB is in LTE mode (with VoLTE enabled).
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], True, WFC_MODE_WIFI_ONLY,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_volte, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(
            self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
            phone_idle_volte, is_phone_in_call_volte, None,
            WAIT_TIME_IN_CALL_FOR_IMS)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="fff9edcd-1ace-4f2d-a09b-06f3eea56cca")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_volte_apm_wfc_wifi_preferred(self):
        """ Airplane + WiFi Preferred, WiFi calling to VoLTE test

        1. Setup PhoneA in airplane mode, WFC mode: WIFI_PREFERRED.
        2. Make Sure PhoneB is in LTE mode (with VoLTE enabled).
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_volte, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(
            self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
            phone_idle_volte, is_phone_in_call_volte, None,
            WAIT_TIME_IN_CALL_FOR_IMS)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="8591554e-4e38-406c-97bf-8921d5329c47")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_csfb_3g_wfc_wifi_only(self):
        """ WiFi Only, WiFi calling to CSFB 3G test

        1. Setup PhoneA WFC mode: WIFI_ONLY.
        2. Make Sure PhoneB is in LTE mode (with VoLTE disabled).
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
             TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])
        # Turn OFF WiFi for Phone B
        set_wifi_to_default(self.log, ads[1])
        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], False, WFC_MODE_WIFI_ONLY,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_csfb, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(
            self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
            phone_idle_csfb, is_phone_in_call_csfb, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="9711888d-5b1e-4d05-86e9-98f94f46098b")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_csfb_3g_wfc_wifi_preferred(self):
        """ WiFi Preferred, WiFi calling to CSFB 3G test

        1. Setup PhoneA WFC mode: WIFI_PREFERRED.
        2. Make Sure PhoneB is in LTE mode (with VoLTE disabled).
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])
        # Turn OFF WiFi for Phone B
        set_wifi_to_default(self.log, ads[1])
        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_csfb, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(
            self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
            phone_idle_csfb, is_phone_in_call_csfb, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="902c96a4-858f-43ff-bd56-6d7d27004320")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_csfb_3g_apm_wfc_wifi_only(self):
        """ Airplane + WiFi Only, WiFi calling to CSFB 3G test

        1. Setup PhoneA in airplane mode, WFC mode: WIFI_ONLY.
        2. Make Sure PhoneB is in LTE mode (with VoLTE disabled).
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])
        # Turn OFF WiFi for Phone B
        set_wifi_to_default(self.log, ads[1])
        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], True, WFC_MODE_WIFI_ONLY,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_csfb, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(
            self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
            phone_idle_csfb, is_phone_in_call_csfb, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="362a5396-ebda-4706-a73a-d805e5028fd7")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_csfb_3g_apm_wfc_wifi_preferred(self):
        """ Airplane + WiFi Preferred, WiFi calling to CSFB 3G test

        1. Setup PhoneA in airplane mode, WFC mode: WIFI_PREFERRED.
        2. Make Sure PhoneB is in LTE mode (with VoLTE disabled).
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])
        # Turn OFF WiFi for Phone B
        set_wifi_to_default(self.log, ads[1])
        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_csfb, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(
            self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
            phone_idle_csfb, is_phone_in_call_csfb, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="647bb859-46bc-4e3e-b6ab-7944d3bbcc26")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_3g_wfc_wifi_only(self):
        """ WiFi Only, WiFi calling to 3G test

        1. Setup PhoneA WFC mode: WIFI_ONLY.
        2. Make Sure PhoneB is in 3G mode.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])
        # Turn OFF WiFi for Phone B
        set_wifi_to_default(self.log, ads[1])
        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], False, WFC_MODE_WIFI_ONLY,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_voice_3g, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(
            self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
            phone_idle_3g, is_phone_in_call_3g, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="3688ea1f-a52d-4a35-9df4-d5ed0985e49b")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_3g_wfc_wifi_preferred(self):
        """ WiFi Preferred, WiFi calling to 3G test

        1. Setup PhoneA WFC mode: WIFI_PREFERRED.
        2. Make Sure PhoneB is in 3G mode.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])
        # Turn OFF WiFi for Phone B
        set_wifi_to_default(self.log, ads[1])
        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_voice_3g, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(
            self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
            phone_idle_3g, is_phone_in_call_3g, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="f4efc821-fbaf-4ec2-b89b-5a47354344f0")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_3g_apm_wfc_wifi_only(self):
        """ Airplane + WiFi Only, WiFi calling to 3G test

        1. Setup PhoneA in airplane mode, WFC mode: WIFI_ONLY.
        2. Make Sure PhoneB is in 3G mode.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])
        # Turn OFF WiFi for Phone B
        set_wifi_to_default(self.log, ads[1])
        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], True, WFC_MODE_WIFI_ONLY,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_voice_3g, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(
            self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
            phone_idle_3g, is_phone_in_call_3g, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="2b1345b7-3b62-44bd-91ad-9c5a4925b0e1")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_3g_apm_wfc_wifi_preferred(self):
        """ Airplane + WiFi Preferred, WiFi calling to 3G test

        1. Setup PhoneA in airplane mode, WFC mode: WIFI_PREFERRED.
        2. Make Sure PhoneB is in 3G mode.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])
        # Turn OFF WiFi for Phone B
        set_wifi_to_default(self.log, ads[1])
        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_voice_3g, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(
            self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
            phone_idle_3g, is_phone_in_call_3g, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="7b3fea22-114a-442e-aa12-dde3b6001681")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_csfb_3g_to_csfb_3g(self):
        """ CSFB 3G to CSFB 3G call test

        1. Make Sure PhoneA is in LTE mode, VoLTE disabled.
        2. Make Sure PhoneB is in LTE mode, VoLTE disabled.
        3. Call from PhoneA to PhoneB, accept on PhoneA, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneA, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])
        # Turn OFF WiFi for Phone B
        set_wifi_to_default(self.log, ads[1])
        tasks = [(phone_setup_csfb, (self.log, ads[0])), (phone_setup_csfb,
                                                          (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(
            self.log, ads[0], phone_idle_csfb, is_phone_in_call_csfb, ads[1],
            phone_idle_csfb, is_phone_in_call_csfb, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="91d751ea-40c8-4ffc-b9d3-03d0ad0902bd")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_3g_to_3g(self):
        """ 3G to 3G call test

        1. Make Sure PhoneA is in 3G mode.
        2. Make Sure PhoneB is in 3G mode.
        3. Call from PhoneA to PhoneB, accept on PhoneA, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneA, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])
        # Turn OFF WiFi for Phone B
        set_wifi_to_default(self.log, ads[1])
        tasks = [(phone_setup_voice_3g, (self.log, ads[0])),
                 (phone_setup_voice_3g, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(
            self.log, ads[0], phone_idle_3g, is_phone_in_call_3g, ads[1],
            phone_idle_3g, is_phone_in_call_3g, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="df57c481-010a-4d21-a5c1-5116917871b2")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_volte_to_volte_long(self):
        """ VoLTE to VoLTE call test

        1. Make Sure PhoneA is in LTE mode (with VoLTE).
        2. Make Sure PhoneB is in LTE mode (with VoLTE).
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.
        5. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        6. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices

        tasks = [(phone_setup_volte, (self.log, ads[0])), (phone_setup_volte,
                                                           (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_long_seq(
            self.log, ads[0], phone_idle_volte, is_phone_in_call_volte, ads[1],
            phone_idle_volte, is_phone_in_call_volte, None,
            WAIT_TIME_IN_CALL_FOR_IMS)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="b0712d8a-71cf-405f-910c-8592da082660")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_epdg_long_wfc_wifi_only(self):
        """ WiFi Only, WiFi calling to WiFi Calling test

        1. Setup PhoneA WFC mode: WIFI_ONLY.
        2. Setup PhoneB WFC mode: WIFI_ONLY.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.
        5. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        6. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices

        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], False, WFC_MODE_WIFI_ONLY,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_iwlan,
                  (self.log, ads[1], False, WFC_MODE_WIFI_ONLY,
                   self.wifi_network_ssid, self.wifi_network_pass))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_long_seq(
            self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
            phone_idle_iwlan, is_phone_in_call_iwlan, None,
            WAIT_TIME_IN_CALL_FOR_IMS)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="a7293d6c-0fdb-4842-984a-e4c6395fd41d")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_epdg_long_wfc_wifi_preferred(self):
        """ WiFi Preferred, WiFi calling to WiFi Calling test

        1. Setup PhoneA WFC mode: WIFI_PREFERRED.
        2. Setup PhoneB WFC mode: WIFI_PREFERRED.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.
        5. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        6. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices

        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_iwlan,
                  (self.log, ads[1], False, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_long_seq(
            self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
            phone_idle_iwlan, is_phone_in_call_iwlan, None,
            WAIT_TIME_IN_CALL_FOR_IMS)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="029af2a7-aba4-406b-9095-b32da57a7cdb")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_epdg_long_apm_wfc_wifi_only(self):
        """ Airplane + WiFi Only, WiFi calling to WiFi Calling test

        1. Setup PhoneA in airplane mode, WFC mode: WIFI_ONLY.
        2. Setup PhoneB in airplane mode, WFC mode: WIFI_ONLY.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.
        5. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        6. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices

        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], True, WFC_MODE_WIFI_ONLY,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_iwlan,
                  (self.log, ads[1], True, WFC_MODE_WIFI_ONLY,
                   self.wifi_network_ssid, self.wifi_network_pass))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_long_seq(
            self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
            phone_idle_iwlan, is_phone_in_call_iwlan, None,
            WAIT_TIME_IN_CALL_FOR_IMS)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="3c751d79-7159-4407-a63c-96f835dd6cb0")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_epdg_long_apm_wfc_wifi_preferred(self):
        """ Airplane + WiFi Preferred, WiFi calling to WiFi Calling test

        1. Setup PhoneA in airplane mode, WFC mode: WIFI_PREFERRED.
        2. Setup PhoneB in airplane mode, WFC mode: WIFI_PREFERRED.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.
        5. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        6. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices

        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_iwlan,
                  (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_long_seq(
            self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
            phone_idle_iwlan, is_phone_in_call_iwlan, None,
            WAIT_TIME_IN_CALL_FOR_IMS)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="9deab765-e2da-4826-bae8-ba8755551a1b")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_csfb_3g_to_csfb_3g_long(self):
        """ CSFB 3G to CSFB 3G call test

        1. Make Sure PhoneA is in LTE mode, VoLTE disabled.
        2. Make Sure PhoneB is in LTE mode, VoLTE disabled.
        3. Call from PhoneA to PhoneB, accept on PhoneA, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneA, hang up on PhoneB.
        5. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        6. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])
        # Turn OFF WiFi for Phone B
        set_wifi_to_default(self.log, ads[1])
        tasks = [(phone_setup_csfb, (self.log, ads[0])), (phone_setup_csfb,
                                                          (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_long_seq(
            self.log, ads[0], phone_idle_csfb, is_phone_in_call_csfb, ads[1],
            phone_idle_csfb, is_phone_in_call_csfb, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="54768178-818f-4126-9e50-4f49e43a6fd3")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_3g_to_3g_long(self):
        """ 3G to 3G call test

        1. Make Sure PhoneA is in 3G mode.
        2. Make Sure PhoneB is in 3G mode.
        3. Call from PhoneA to PhoneB, accept on PhoneA, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneA, hang up on PhoneB.
        5. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        6. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])
        # Turn OFF WiFi for Phone B
        set_wifi_to_default(self.log, ads[1])
        tasks = [(phone_setup_voice_3g, (self.log, ads[0])),
                 (phone_setup_voice_3g, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_long_seq(
            self.log, ads[0], phone_idle_3g, is_phone_in_call_3g, ads[1],
            phone_idle_3g, is_phone_in_call_3g, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_volte_to_volte_loop(self):
        """ Stress test: VoLTE to VoLTE call test

        1. Make Sure PhoneA is in LTE mode (with VoLTE).
        2. Make Sure PhoneB is in LTE mode (with VoLTE).
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.
        5. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        6. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.
        7. Repeat step 3~6.

        Returns:
            True if pass; False if fail.
        """

        # TODO: b/26338422 Make this a parameter
        MINIMUM_SUCCESS_RATE = .95
        ads = self.android_devices

        tasks = [(phone_setup_volte, (self.log, ads[0])), (phone_setup_volte,
                                                           (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        success_count = 0
        fail_count = 0

        for i in range(1, self.stress_test_number + 1):

            if two_phone_call_long_seq(
                    self.log, ads[0], phone_idle_volte, is_phone_in_call_volte,
                    ads[1], phone_idle_volte, is_phone_in_call_volte, None,
                    WAIT_TIME_IN_CALL_FOR_IMS):
                success_count += 1
                result_str = "Succeeded"

            else:
                fail_count += 1
                result_str = "Failed"

            self.log.info("Iteration %s %s. Current: %s / %s passed.", i,
                          result_str, success_count, self.stress_test_number)

        self.log.info("Final Count - Success: %s, Failure: %s - %s%",
                      success_count, fail_count,
                      str(100 * success_count / (success_count + fail_count)))
        if success_count / (
                success_count + fail_count) >= MINIMUM_SUCCESS_RATE:
            return True
        else:
            return False

    @test_tracker_info(uuid="dfa2c1a7-0e9a-42f2-b3ba-7e196df87e1b")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_epdg_loop_wfc_wifi_only(self):
        """ Stress test: WiFi Only, WiFi calling to WiFi Calling test

        1. Setup PhoneA WFC mode: WIFI_ONLY.
        2. Setup PhoneB WFC mode: WIFI_ONLY.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.
        5. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        6. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.
        7. Repeat step 3~6.

        Returns:
            True if pass; False if fail.
        """

        # TODO: b/26338422 Make this a parameter
        MINIMUM_SUCCESS_RATE = .95
        ads = self.android_devices

        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], False, WFC_MODE_WIFI_ONLY,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_iwlan,
                  (self.log, ads[1], False, WFC_MODE_WIFI_ONLY,
                   self.wifi_network_ssid, self.wifi_network_pass))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        success_count = 0
        fail_count = 0

        for i in range(1, self.stress_test_number + 1):

            if two_phone_call_long_seq(
                    self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan,
                    ads[1], phone_idle_iwlan, is_phone_in_call_iwlan, None,
                    WAIT_TIME_IN_CALL_FOR_IMS):
                success_count += 1
                result_str = "Succeeded"

            else:
                fail_count += 1
                result_str = "Failed"

            self.log.info("Iteration %s %s. Current: %s / %s passed.", i,
                          result_str, success_count, self.stress_test_number)

        self.log.info("Final Count - Success: %s, Failure: %s - %s%",
                      success_count, fail_count,
                      str(100 * success_count / (success_count + fail_count)))
        if success_count / (
                success_count + fail_count) >= MINIMUM_SUCCESS_RATE:
            return True
        else:
            return False

    @test_tracker_info(uuid="382f97ad-65d4-4ebb-a31b-aa243e01bce4")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_epdg_loop_wfc_wifi_preferred(self):
        """ Stress test: WiFi Preferred, WiFi Calling to WiFi Calling test

        1. Setup PhoneA WFC mode: WIFI_PREFERRED.
        2. Setup PhoneB WFC mode: WIFI_PREFERRED.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.
        5. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        6. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.
        7. Repeat step 3~6.

        Returns:
            True if pass; False if fail.
        """

        # TODO: b/26338422 Make this a parameter
        MINIMUM_SUCCESS_RATE = .95
        ads = self.android_devices

        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_iwlan,
                  (self.log, ads[1], False, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        success_count = 0
        fail_count = 0

        for i in range(1, self.stress_test_number + 1):

            if two_phone_call_long_seq(
                    self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan,
                    ads[1], phone_idle_iwlan, is_phone_in_call_iwlan, None,
                    WAIT_TIME_IN_CALL_FOR_IMS):
                success_count += 1
                result_str = "Succeeded"

            else:
                fail_count += 1
                result_str = "Failed"

            self.log.info("Iteration %s %s. Current: %s / %s passed.", i,
                          result_str, success_count, self.stress_test_number)

        self.log.info("Final Count - Success: %s, Failure: %s - %s%",
                      success_count, fail_count,
                      str(100 * success_count / (success_count + fail_count)))
        if success_count / (
                success_count + fail_count) >= MINIMUM_SUCCESS_RATE:
            return True
        else:
            return False

    @test_tracker_info(uuid="c820e2ea-8a14-421c-b608-9074b716f7dd")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_epdg_loop_apm_wfc_wifi_only(self):
        """ Stress test: Airplane + WiFi Only, WiFi Calling to WiFi Calling test

        1. Setup PhoneA in airplane mode, WFC mode: WIFI_ONLY.
        2. Setup PhoneB in airplane mode, WFC mode: WIFI_ONLY.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.
        5. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        6. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.
        7. Repeat step 3~6.

        Returns:
            True if pass; False if fail.
        """

        # TODO: b/26338422 Make this a parameter
        MINIMUM_SUCCESS_RATE = .95
        ads = self.android_devices

        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], True, WFC_MODE_WIFI_ONLY,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_iwlan,
                  (self.log, ads[1], True, WFC_MODE_WIFI_ONLY,
                   self.wifi_network_ssid, self.wifi_network_pass))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        success_count = 0
        fail_count = 0

        for i in range(1, self.stress_test_number + 1):

            if two_phone_call_long_seq(
                    self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan,
                    ads[1], phone_idle_iwlan, is_phone_in_call_iwlan, None,
                    WAIT_TIME_IN_CALL_FOR_IMS):
                success_count += 1
                result_str = "Succeeded"

            else:
                fail_count += 1
                result_str = "Failed"

            self.log.info("Iteration %s %s. Current: %s / %s passed.", i,
                          result_str, success_count, self.stress_test_number)

        self.log.info("Final Count - Success: %s, Failure: %s - %s%",
                      success_count, fail_count,
                      str(100 * success_count / (success_count + fail_count)))
        if success_count / (
                success_count + fail_count) >= MINIMUM_SUCCESS_RATE:
            return True
        else:
            return False

    @test_tracker_info(uuid="3b8cb344-1551-4244-845d-b864501f2fb4")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_to_epdg_loop_apm_wfc_wifi_preferred(self):
        """ Stress test: Airplane + WiFi Preferred, WiFi Calling to WiFi Calling test

        1. Setup PhoneA in airplane mode, WFC mode: WIFI_PREFERRED.
        2. Setup PhoneB in airplane mode, WFC mode: WIFI_PREFERRED.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.
        5. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        6. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.
        7. Repeat step 3~6.

        Returns:
            True if pass; False if fail.
        """

        # TODO: b/26338422 Make this a parameter
        MINIMUM_SUCCESS_RATE = .95
        ads = self.android_devices

        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_iwlan,
                  (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        success_count = 0
        fail_count = 0

        for i in range(1, self.stress_test_number + 1):

            if two_phone_call_long_seq(
                    self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan,
                    ads[1], phone_idle_iwlan, is_phone_in_call_iwlan, None,
                    WAIT_TIME_IN_CALL_FOR_IMS):
                success_count += 1
                result_str = "Succeeded"

            else:
                fail_count += 1
                result_str = "Failed"

            self.log.info("Iteration %s %s. Current: %s / %s passed.", i,
                          result_str, success_count, self.stress_test_number)

        self.log.info("Final Count - Success: %s, Failure: %s - %s%",
                      success_count, fail_count,
                      str(100 * success_count / (success_count + fail_count)))
        if success_count / (
                success_count + fail_count) >= MINIMUM_SUCCESS_RATE:
            return True
        else:
            return False

    @test_tracker_info(uuid="")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_csfb_3g_to_csfb_3g_loop(self):
        """ Stress test: CSFB 3G to CSFB 3G call test

        1. Make Sure PhoneA is in LTE mode, VoLTE disabled.
        2. Make Sure PhoneB is in LTE mode, VoLTE disabled.
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.
        5. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        6. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.
        7. Repeat step 3~6.

        Returns:
            True if pass; False if fail.
        """

        # TODO: b/26338422 Make this a parameter
        MINIMUM_SUCCESS_RATE = .95
        ads = self.android_devices
        self.check_band_support(ads[0])

        tasks = [(phone_setup_csfb, (self.log, ads[0])), (phone_setup_csfb,
                                                          (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        success_count = 0
        fail_count = 0

        for i in range(1, self.stress_test_number + 1):

            if two_phone_call_long_seq(
                    self.log, ads[0], phone_idle_csfb, is_phone_in_call_csfb,
                    ads[1], phone_idle_csfb, is_phone_in_call_csfb, None):
                success_count += 1
                result_str = "Succeeded"

            else:
                fail_count += 1
                result_str = "Failed"

            self.log.info("Iteration %s %s. Current: %s / %s passed.", i,
                          result_str, success_count, self.stress_test_number)

        self.log.info("Final Count - Success: %s, Failure: %s", success_count,
                      fail_count)
        if success_count / (
                success_count + fail_count) >= MINIMUM_SUCCESS_RATE:
            return True
        else:
            return False

    @test_tracker_info(uuid="")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_3g_to_3g_loop(self):
        """ Stress test: 3G to 3G call test

        1. Make Sure PhoneA is in 3G mode
        2. Make Sure PhoneB is in 3G mode
        3. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.
        5. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        6. Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.
        7. Repeat step 3~6.

        Returns:
            True if pass; False if fail.
        """

        # TODO: b/26338422 Make this a parameter
        MINIMUM_SUCCESS_RATE = .95
        ads = self.android_devices
        self.check_band_support(ads[0])

        tasks = [(phone_setup_voice_3g, (self.log, ads[0])),
                 (phone_setup_voice_3g, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        success_count = 0
        fail_count = 0

        for i in range(1, self.stress_test_number + 1):

            if two_phone_call_long_seq(
                    self.log, ads[0], phone_idle_3g, is_phone_in_call_3g,
                    ads[1], phone_idle_3g, is_phone_in_call_3g, None):
                success_count += 1
                result_str = "Succeeded"

            else:
                fail_count += 1
                result_str = "Failed"

            self.log.info("Iteration %s %s. Current: %s / %s passed.", i,
                          result_str, success_count, self.stress_test_number)

        self.log.info("Final Count - Success: %s, Failure: %s", success_count,
                      fail_count)
        if success_count / (
                success_count + fail_count) >= MINIMUM_SUCCESS_RATE:
            return True
        else:
            return False

    @test_tracker_info(uuid="4043c68a-c5d4-4e1d-9010-ef65b205cab1")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_mo_hold_unhold_wfc_wifi_only(self):
        """ WiFi Only, WiFi calling MO call hold/unhold test

        1. Setup PhoneA WFC mode: WIFI_ONLY.
        2. Make sure PhoneB can make/receive voice call.
        3. Call from PhoneA to PhoneB, accept on PhoneB.
        4. Hold and unhold on PhoneA.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], False, WFC_MODE_WIFI_ONLY,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        ads[0].droid.telecomCallClearCallList()
        if num_active_calls(self.log, ads[0]) != 0:
            ads[0].log.error("Call List is not empty.")
            return False

        self.log.info("Begin MO Call Hold/Unhold Test.")
        if not call_setup_teardown(
                self.log,
                ads[0],
                ads[1],
                ad_hangup=None,
                verify_caller_func=is_phone_in_call_iwlan,
                verify_callee_func=None):
            return False

        if not hold_unhold_test(ads[0].log, ads)[0]:
            self.log.error("Hold/Unhold test fail.")
            return False

        if not hangup_call(self.log, ads[0]):
            self.log.error("Call Hangup Failed")
            return False

        return True

    @test_tracker_info(uuid="0667535e-dcad-49f0-9b4b-fa45d6c75f5b")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_mo_hold_unhold_wfc_wifi_preferred(self):
        """ WiFi Preferred, WiFi calling MO call hold/unhold test

        1. Setup PhoneA WFC mode: WIFI_PREFERRED.
        2. Make sure PhoneB can make/receive voice call.
        3. Call from PhoneA to PhoneB, accept on PhoneB.
        4. Hold and unhold on PhoneA.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        ads[0].droid.telecomCallClearCallList()
        if num_active_calls(self.log, ads[0]) != 0:
            ads[0].log.error("Call List is not empty.")
            return False

        self.log.info("Begin MO Call Hold/Unhold Test.")
        if not call_setup_teardown(
                self.log,
                ads[0],
                ads[1],
                ad_hangup=None,
                verify_caller_func=is_phone_in_call_iwlan,
                verify_callee_func=None):
            return False

        if not hold_unhold_test(ads[0].log, ads)[0]:
            self.log.error("Hold/Unhold test fail.")
            return False

        if not hangup_call(self.log, ads[0]):
            self.log.error("Call Hangup Failed")
            return False

        return True

    @test_tracker_info(uuid="cf318b4c-c920-4e80-b73f-2f092c03a144")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_mo_hold_unhold_apm_wfc_wifi_only(self):
        """ Airplane + WiFi Only, WiFi calling MO call hold/unhold test

        1. Setup PhoneA in airplane mode, WFC mode: WIFI_ONLY.
        2. Make sure PhoneB can make/receive voice call.
        3. Call from PhoneA to PhoneB, accept on PhoneB.
        4. Hold and unhold on PhoneA.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], True, WFC_MODE_WIFI_ONLY,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        ads[0].droid.telecomCallClearCallList()
        if num_active_calls(self.log, ads[0]) != 0:
            ads[0].log.error("Call List is not empty.")
            return False

        self.log.info("Begin MO Call Hold/Unhold Test.")
        if not call_setup_teardown(
                self.log,
                ads[0],
                ads[1],
                ad_hangup=None,
                verify_caller_func=is_phone_in_call_iwlan,
                verify_callee_func=None):
            return False

        if not hold_unhold_test(ads[0].log, ads)[0]:
            self.log.error("Hold/Unhold test fail.")
            return False

        if not hangup_call(self.log, ads[0]):
            self.log.error("Call Hangup Failed")
            return False

        return True

    @test_tracker_info(uuid="ace36801-1e7b-4f06-aa0b-17affc8df069")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_mo_hold_unhold_apm_wfc_wifi_preferred(self):
        """ Airplane + WiFi Preferred, WiFi calling MO call hold/unhold test

        1. Setup PhoneA in airplane mode, WFC mode: WIFI_PREFERRED.
        2. Make sure PhoneB can make/receive voice call.
        3. Call from PhoneA to PhoneB, accept on PhoneB.
        4. Hold and unhold on PhoneA.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        ads[0].droid.telecomCallClearCallList()
        if num_active_calls(self.log, ads[0]) != 0:
            ads[0].log.error("Call List is not empty.")
            return False

        self.log.info("Begin MO Call Hold/Unhold Test.")
        if not call_setup_teardown(
                self.log,
                ads[0],
                ads[1],
                ad_hangup=None,
                verify_caller_func=is_phone_in_call_iwlan,
                verify_callee_func=None):
            return False

        if not hold_unhold_test(ads[0].log, ads)[0]:
            self.log.error("Hold/Unhold test fail.")
            return False

        if not hangup_call(self.log, ads[0]):
            self.log.error("Call Hangup Failed")
            return False

        return True

    @test_tracker_info(uuid="2ad32874-0d39-4475-8ae3-d6dccda675f5")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_mt_hold_unhold_wfc_wifi_only(self):
        """ WiFi Only, WiFi calling MT call hold/unhold test

        1. Setup PhoneA WFC mode: WIFI_ONLY.
        2. Make sure PhoneB can make/receive voice call.
        3. Call from PhoneB to PhoneA, accept on PhoneA.
        4. Hold and unhold on PhoneA.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], False, WFC_MODE_WIFI_ONLY,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        ads[0].droid.telecomCallClearCallList()
        if num_active_calls(self.log, ads[0]) != 0:
            ads[0].log.error("Call List is not empty.")
            return False

        self.log.info("Begin MT Call Hold/Unhold Test.")
        if not call_setup_teardown(
                self.log,
                ads[1],
                ads[0],
                ad_hangup=None,
                verify_caller_func=None,
                verify_callee_func=is_phone_in_call_iwlan):
            return False

        if not hold_unhold_test(ads[0].log, ads)[0]:
            self.log.error("Hold/Unhold test fail.")
            return False

        if not hangup_call(self.log, ads[0]):
            self.log.error("Call Hangup Failed")
            return False

        return True

    @test_tracker_info(uuid="3efd5d59-30ee-45f5-8966-56ce8fadf9a1")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_mt_hold_unhold_wfc_wifi_preferred(self):
        """ WiFi Preferred, WiFi calling MT call hold/unhold test

        1. Setup PhoneA WFC mode: WIFI_PREFERRED.
        2. Make sure PhoneB can make/receive voice call.
        3. Call from PhoneB to PhoneA, accept on PhoneA.
        4. Hold and unhold on PhoneA.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        ads[0].droid.telecomCallClearCallList()
        if num_active_calls(self.log, ads[0]) != 0:
            ads[0].log.error("Call List is not empty.")
            return False

        self.log.info("Begin MT Call Hold/Unhold Test.")
        if not call_setup_teardown(
                self.log,
                ads[1],
                ads[0],
                ad_hangup=None,
                verify_caller_func=None,
                verify_callee_func=is_phone_in_call_iwlan):
            return False

        if not hold_unhold_test(ads[0].log, ads)[0]:
            self.log.error("Hold/Unhold test fail.")
            return False

        return True

    @test_tracker_info(uuid="35ed0f89-7435-4d3b-9ebc-c5cdc3f7e32b")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_mt_hold_unhold_apm_wfc_wifi_only(self):
        """ Airplane + WiFi Only, WiFi calling MT call hold/unhold test

        1. Setup PhoneA in airplane mode, WFC mode: WIFI_ONLY.
        2. Make sure PhoneB can make/receive voice call.
        3. Call from PhoneB to PhoneA, accept on PhoneA.
        4. Hold and unhold on PhoneA.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], True, WFC_MODE_WIFI_ONLY,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        ads[0].droid.telecomCallClearCallList()
        if num_active_calls(self.log, ads[0]) != 0:
            ads[0].log.error("Call List is not empty.")
            return False

        self.log.info("Begin MT Call Hold/Unhold Test.")
        if not call_setup_teardown(
                self.log,
                ads[1],
                ads[0],
                ad_hangup=None,
                verify_caller_func=None,
                verify_callee_func=is_phone_in_call_iwlan):
            return False

        if not hold_unhold_test(ads[0].log, ads)[0]:
            self.log.error("Hold/Unhold test fail.")
            return False

        if not hangup_call(self.log, ads[0]):
            self.log.error("Call Hangup Failed")
            return False

        return True

    @test_tracker_info("37ad003b-6426-42f7-b528-ec7c1842fd18")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_epdg_mt_hold_unhold_apm_wfc_wifi_preferred(self):
        """ Airplane + WiFi Preferred, WiFi calling MT call hold/unhold test

        1. Setup PhoneA in airplane mode, WFC mode: WIFI_PREFERRED.
        2. Make sure PhoneB can make/receive voice call.
        3. Call from PhoneB to PhoneA, accept on PhoneA.
        4. Hold and unhold on PhoneA.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        ads[0].droid.telecomCallClearCallList()
        if num_active_calls(self.log, ads[0]) != 0:
            ads[0].log.error("Call List is not empty.")
            return False

        self.log.info("Begin MT Call Hold/Unhold Test.")
        if not call_setup_teardown(
                self.log,
                ads[1],
                ads[0],
                ad_hangup=None,
                verify_caller_func=None,
                verify_callee_func=is_phone_in_call_iwlan):
            return False

        if not hold_unhold_test(ads[0].log, ads)[0]:
            self.log.error("Hold/Unhold test fail.")
            return False

        if not hangup_call(self.log, ads[0]):
            self.log.error("Call Hangup Failed")
            return False

        return True

    @test_tracker_info(uuid="fa37cd37-c30a-4caa-80b4-52507995ec77")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_volte_mo_hold_unhold(self):
        """ VoLTE MO call hold/unhold test

        1. Make Sure PhoneA is in LTE mode (with VoLTE).
        2. Make Sure PhoneB is able to make/receive call.
        3. Call from PhoneA to PhoneB, accept on PhoneB.
        4. Hold and unhold on PhoneA.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_volte, (self.log, ads[0])),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        ads[0].droid.telecomCallClearCallList()
        if num_active_calls(self.log, ads[0]) != 0:
            ads[0].log.error("Call List is not empty.")
            return False

        self.log.info("Begin MO Call Hold/Unhold Test.")
        if not call_setup_teardown(
                self.log,
                ads[0],
                ads[1],
                ad_hangup=None,
                verify_caller_func=is_phone_in_call_volte,
                verify_callee_func=None):
            return False

        if not hold_unhold_test(ads[0].log, ads)[0]:
            self.log.error("Hold/Unhold test fail.")
            return False

        if not hangup_call(self.log, ads[0]):
            self.log.error("Call Hangup Failed")
            return False

        return True

    @test_tracker_info(uuid="28a9acb3-83e8-4dd1-82bf-173da8bd2eca")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_volte_mt_hold_unhold(self):
        """ VoLTE MT call hold/unhold test

        1. Make Sure PhoneA is in LTE mode (with VoLTE).
        2. Make Sure PhoneB is able to make/receive call.
        3. Call from PhoneB to PhoneA, accept on PhoneA.
        4. Hold and unhold on PhoneA.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_volte, (self.log, ads[0])),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        ads[0].droid.telecomCallClearCallList()
        if num_active_calls(self.log, ads[0]) != 0:
            ads[0].log.error("Call List is not empty.")
            return False

        self.log.info("Begin MT Call Hold/Unhold Test.")
        if not call_setup_teardown(
                self.log,
                ads[1],
                ads[0],
                ad_hangup=None,
                verify_caller_func=None,
                verify_callee_func=is_phone_in_call_volte):
            return False

        if not hold_unhold_test(ads[0].log, ads)[0]:
            self.log.error("Hold/Unhold test fail.")
            return False

        if not hangup_call(self.log, ads[0]):
            self.log.error("Call Hangup Failed")
            return False

        return True

    @test_tracker_info(uuid="ffe724ae-4223-4c15-9fed-9aba17de9a63")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_wcdma_mo_hold_unhold(self):
        """ MO WCDMA hold/unhold test

        1. Make Sure PhoneA is in 3G WCDMA mode.
        2. Make Sure PhoneB is able to make/receive call.
        3. Call from PhoneA to PhoneB, accept on PhoneB.
        4. Hold and unhold on PhoneA.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])
        # make sure PhoneA is GSM phone before proceed.
        if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_GSM):
            ads[0].log.error(
                "Not GSM phone, abort this wcdma hold/unhold test.")
            raise signals.TestSkip(
                "Not GSM phone, abort this wcdma hold/unhold test")

        tasks = [(phone_setup_voice_3g, (self.log, ads[0])),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        ads[0].droid.telecomCallClearCallList()
        if num_active_calls(self.log, ads[0]) != 0:
            ads[0].log.error("Call List is not empty.")
            return False

        self.log.info("Begin MO Call Hold/Unhold Test.")
        if not call_setup_teardown(
                self.log,
                ads[0],
                ads[1],
                ad_hangup=None,
                verify_caller_func=is_phone_in_call_3g,
                verify_callee_func=None):
            return False

        if not hold_unhold_test(ads[0].log, ads)[0]:
            self.log.error("Hold/Unhold test fail.")
            return False

        if not hangup_call(self.log, ads[0]):
            self.log.error("Call Hangup Failed")
            return False

        return True

    @test_tracker_info(uuid="23805165-01ce-4351-83d3-73c9fb3bda76")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_wcdma_mt_hold_unhold(self):
        """ MT WCDMA hold/unhold test

        1. Make Sure PhoneA is in 3G WCDMA mode.
        2. Make Sure PhoneB is able to make/receive call.
        3. Call from PhoneB to PhoneA, accept on PhoneA.
        4. Hold and unhold on PhoneA.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])
        # make sure PhoneA is GSM phone before proceed.
        if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_GSM):
            ads[0].log.error(
                "Not GSM phone, abort this wcdma hold/unhold test.")
            raise signals.TestSkip(
                "Not GSM phone, abort this wcdma hold/unhold test")

        tasks = [(phone_setup_voice_3g, (self.log, ads[0])),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        ads[0].droid.telecomCallClearCallList()
        if num_active_calls(self.log, ads[0]) != 0:
            ads[0].log.error("Call List is not empty.")
            return False

        self.log.info("Begin MT Call Hold/Unhold Test.")
        if not call_setup_teardown(
                self.log,
                ads[1],
                ads[0],
                ad_hangup=None,
                verify_caller_func=None,
                verify_callee_func=is_phone_in_call_3g):
            return False

        if not hold_unhold_test(ads[0].log, ads)[0]:
            self.log.error("Hold/Unhold test fail.")
            return False

        if not hangup_call(self.log, ads[0]):
            self.log.error("Call Hangup Failed")
            return False

        return True

    @test_tracker_info(uuid="08c846c7-1978-4ece-8f2c-731129947699")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_csfb_mo_hold_unhold(self):
        """ MO CSFB WCDMA/GSM hold/unhold test

        1. Make Sure PhoneA is in LTE mode (VoLTE disabled).
        2. Make Sure PhoneB is able to make/receive call.
        3. Call from PhoneA to PhoneB, accept on PhoneB.
        4. Hold and unhold on PhoneA.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices
        # make sure PhoneA is GSM phone before proceed.
        if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_GSM):
            self.log.error("Not GSM phone, abort this wcdma hold/unhold test.")
            raise signals.TestSkip(
                "Not GSM phone, abort this wcdma hold/unhold test")

        tasks = [(phone_setup_csfb, (self.log, ads[0])),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        ads[0].droid.telecomCallClearCallList()
        if num_active_calls(self.log, ads[0]) != 0:
            ads[0].log.error("Call List is not empty.")
            return False

        self.log.info("Begin MO Call Hold/Unhold Test.")
        if not call_setup_teardown(
                self.log,
                ads[0],
                ads[1],
                ad_hangup=None,
                verify_caller_func=is_phone_in_call_csfb,
                verify_callee_func=None):
            return False

        if not hold_unhold_test(ads[0].log, ads)[0]:
            self.log.error("Hold/Unhold test fail.")
            return False

        if not hangup_call(self.log, ads[0]):
            self.log.error("Call Hangup Failed")
            return False

        return True

    @test_tracker_info(uuid="a6405fe6-c732-4ae6-bbae-e912a124f4a2")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_csfb_mt_hold_unhold(self):
        """ MT CSFB WCDMA/GSM hold/unhold test

        1. Make Sure PhoneA is in LTE mode (VoLTE disabled).
        2. Make Sure PhoneB is able to make/receive call.
        3. Call from PhoneB to PhoneA, accept on PhoneA.
        4. Hold and unhold on PhoneA.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices
        # make sure PhoneA is GSM phone before proceed.
        if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_GSM):
            ads[0].log.error(
                "Not GSM phone, abort this wcdma hold/unhold test.")
            raise signals.TestSkip(
                "Not GSM phone, abort this wcdma hold/unhold test")

        tasks = [(phone_setup_csfb, (self.log, ads[0])),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        ads[0].droid.telecomCallClearCallList()
        if num_active_calls(self.log, ads[0]) != 0:
            ads[0].log.error("Call List is not empty.")
            return False

        self.log.info("Begin MT Call Hold/Unhold Test.")
        if not call_setup_teardown(
                self.log,
                ads[1],
                ads[0],
                ad_hangup=None,
                verify_caller_func=None,
                verify_callee_func=is_phone_in_call_csfb):
            return False

        if not hold_unhold_test(ads[0].log, ads)[0]:
            self.log.error("Hold/Unhold test fail.")
            return False

        if not hangup_call(self.log, ads[0]):
            self.log.error("Call Hangup Failed")
            return False

        return True

    @test_tracker_info(uuid="5edc5034-90ef-4113-926f-05407ed60a87")
    @TelephonyBaseTest.tel_test_wrap
    def test_erase_all_pending_voicemail(self):
        """Script for TMO/ATT/SPT phone to erase all pending voice mail.
        This script only works if phone have already set up voice mail options,
        and phone should disable password protection for voice mail.

        1. If phone don't have pending voice message, return True.
        2. Dial voice mail number.
            For TMO, the number is '123'.
            For ATT, the number is phone's number.
            For SPT, the number is phone's number.
        3. Use DTMF to delete all pending voice messages.
        4. Check telephonyGetVoiceMailCount result. it should be 0.

        Returns:
            False if error happens. True is succeed.
        """
        ads = self.android_devices

        tasks = [(phone_setup_voice_general, (self.log, ads[0])),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        return call_voicemail_erase_all_pending_voicemail(
            self.log, self.android_devices[0])

    @test_tracker_info(uuid="c81156a2-089b-4b10-ba80-7afea61d06c6")
    @TelephonyBaseTest.tel_test_wrap
    def test_voicemail_indicator_volte(self):
        """Test Voice Mail notification in LTE (VoLTE enabled).
        This script currently only works for TMO now.

        1. Make sure DUT (ads[0]) in VoLTE mode. Both PhoneB (ads[0]) and DUT idle.
        2. Make call from PhoneB to DUT, reject on DUT.
        3. On PhoneB, leave a voice mail to DUT.
        4. Verify DUT receive voice mail notification.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_voice_general, (self.log, ads[1])),
                 (phone_setup_volte, (self.log, ads[0]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False
        if not call_voicemail_erase_all_pending_voicemail(self.log, ads[0]):
            self.log.error("Failed to clear voice mail.")
            return False

        return two_phone_call_leave_voice_mail(self.log, ads[1], None, None,
                                               ads[0], phone_idle_volte)

    @test_tracker_info(uuid="529e12cb-3178-4d2c-b155-d5cfb1eac0c9")
    @TelephonyBaseTest.tel_test_wrap
    def test_voicemail_indicator_lte(self):
        """Test Voice Mail notification in LTE (VoLTE disabled).
        This script currently only works for TMO/ATT/SPT now.

        1. Make sure DUT (ads[1]) in LTE (No VoLTE) mode. Both PhoneB (ads[0]) and DUT idle.
        2. Make call from PhoneB to DUT, reject on DUT.
        3. On PhoneB, leave a voice mail to DUT.
        4. Verify DUT receive voice mail notification.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_voice_general, (self.log, ads[0])),
                 (phone_setup_csfb, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False
        if not call_voicemail_erase_all_pending_voicemail(self.log, ads[0]):
            self.log.error("Failed to clear voice mail.")
            return False

        return two_phone_call_leave_voice_mail(self.log, ads[0], None, None,
                                               ads[1], phone_idle_csfb)

    @test_tracker_info(uuid="60cef7dd-f990-4913-af9a-75e9336fc80a")
    @TelephonyBaseTest.tel_test_wrap
    def test_voicemail_indicator_3g(self):
        """Test Voice Mail notification in 3G
        This script currently only works for TMO/ATT/SPT now.

        1. Make sure DUT (ads[0]) in 3G mode. Both PhoneB and DUT idle.
        2. Make call from PhoneB to DUT, reject on DUT.
        3. On PhoneB, leave a voice mail to DUT.
        4. Verify DUT receive voice mail notification.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])

        tasks = [(phone_setup_voice_3g, (self.log, ads[0])),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False
        if not call_voicemail_erase_all_pending_voicemail(self.log, ads[0]):
            self.log.error("Failed to clear voice mail.")
            return False

        return two_phone_call_leave_voice_mail(self.log, ads[1], None, None,
                                               ads[0], phone_idle_3g)

    @test_tracker_info(uuid="e4c83cfa-db60-4258-ab69-15f7de3614b0")
    @TelephonyBaseTest.tel_test_wrap
    def test_voicemail_indicator_2g(self):
        """Test Voice Mail notification in 2G
        This script currently only works for TMO/ATT/SPT now.

        1. Make sure DUT (ads[0]) in 2G mode. Both PhoneB (ads[1]) and DUT idle.
        2. Make call from PhoneB to DUT, reject on DUT.
        3. On PhoneB, leave a voice mail to DUT.
        4. Verify DUT receive voice mail notification.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])

        tasks = [(phone_setup_voice_general, (self.log, ads[1])),
                 (phone_setup_voice_2g, (self.log, ads[0]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False
        if not call_voicemail_erase_all_pending_voicemail(self.log, ads[0]):
            self.log.error("Failed to clear voice mail.")
            return False

        return two_phone_call_leave_voice_mail(self.log, ads[1], None, None,
                                               ads[0], phone_idle_2g)

    @test_tracker_info(uuid="f0cb02fb-a028-43da-9c87-5b21b2f8549b")
    @TelephonyBaseTest.tel_test_wrap
    def test_voicemail_indicator_iwlan(self):
        """Test Voice Mail notification in WiFI Calling
        This script currently only works for TMO now.

        1. Make sure DUT (ads[0]) in WFC mode. Both PhoneB (ads[1]) and DUT idle.
        2. Make call from PhoneB to DUT, reject on DUT.
        3. On PhoneB, leave a voice mail to DUT.
        4. Verify DUT receive voice mail notification.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_voice_general, (self.log, ads[1])),
                 (phone_setup_iwlan,
                  (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False
        if not call_voicemail_erase_all_pending_voicemail(self.log, ads[0]):
            self.log.error("Failed to clear voice mail.")
            return False

        return two_phone_call_leave_voice_mail(self.log, ads[1], None, None,
                                               ads[0], phone_idle_iwlan)

    @test_tracker_info(uuid="9bd0550e-abfd-436b-912f-571810f973d7")
    @TelephonyBaseTest.tel_test_wrap
    def test_voicemail_indicator_apm_iwlan(self):
        """Test Voice Mail notification in WiFI Calling
        This script currently only works for TMO now.

        1. Make sure DUT (ads[0]) in APM WFC mode. Both PhoneB (ads[1]) and DUT idle.
        2. Make call from PhoneB to DUT, reject on DUT.
        3. On PhoneB, leave a voice mail to DUT.
        4. Verify DUT receive voice mail notification.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_voice_general, (self.log, ads[1])),
                 (phone_setup_iwlan,
                  (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False
        if not call_voicemail_erase_all_pending_voicemail(self.log, ads[0]):
            self.log.error("Failed to clear voice mail.")
            return False

        return two_phone_call_leave_voice_mail(self.log, ads[1], None, None,
                                               ads[0], phone_idle_iwlan)

    @test_tracker_info(uuid="6bd5cf0f-522e-4e4a-99bf-92ae46261d8c")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_2g_to_2g(self):
        """ Test 2g<->2g call functionality.

        Make Sure PhoneA is in 2g mode.
        Make Sure PhoneB is in 2g mode.
        Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])

        tasks = [(phone_setup_voice_2g, (self.log, ads[0])),
                 (phone_setup_voice_2g, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_short_seq(
            self.log, ads[0], phone_idle_2g, is_phone_in_call_2g, ads[1],
            phone_idle_2g, is_phone_in_call_2g, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="947f3178-735b-4ac2-877c-a06a94972457")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_2g_to_2g_long(self):
        """ Test 2g<->2g call functionality.

        Make Sure PhoneA is in 2g mode.
        Make Sure PhoneB is in 2g mode.
        Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.
        Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneB.
        Call from PhoneB to PhoneA, accept on PhoneA, hang up on PhoneA.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])

        tasks = [(phone_setup_voice_2g, (self.log, ads[0])),
                 (phone_setup_voice_2g, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        result = two_phone_call_long_seq(
            self.log, ads[0], phone_idle_2g, is_phone_in_call_2g, ads[1],
            phone_idle_2g, is_phone_in_call_2g, None)
        self.tel_logger.set_result(result.result_value)
        if not result:
            raise signals.TestFailure("Failed",
                extras={"fail_reason": str(result.result_value)})

    @test_tracker_info(uuid="d109df55-ac2f-493f-9324-9be1d3d7d6d3")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_gsm_mo_hold_unhold(self):
        """ Test GSM call hold/unhold functionality.

        Make Sure PhoneA is in 2g mode (GSM).
        Make Sure PhoneB is able to make/receive call.
        Call from PhoneA to PhoneB, accept on PhoneB, hold and unhold on PhoneA.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])
        # make sure PhoneA is GSM phone before proceed.
        if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_GSM):
            raise signals.TestSkip(
                "Not GSM phone, abort this gsm hold/unhold test")

        tasks = [(phone_setup_voice_2g, (self.log, ads[0])),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        ads[0].droid.telecomCallClearCallList()
        if num_active_calls(self.log, ads[0]) != 0:
            ads[0].log.error("Call List is not empty.")
            return False

        self.log.info("Begin MO Call Hold/Unhold Test.")
        if not call_setup_teardown(
                self.log,
                ads[0],
                ads[1],
                ad_hangup=None,
                verify_caller_func=is_phone_in_call_2g,
                verify_callee_func=None):
            return False

        if not hold_unhold_test(ads[0].log, ads)[0]:
            self.log.error("Hold/Unhold test fail.")
            return False

        return True

    @test_tracker_info(uuid="a8279cda-73b3-470a-8ca7-a331ef99270b")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_gsm_mt_hold_unhold(self):
        """ Test GSM call hold/unhold functionality.

        Make Sure PhoneA is in 2g mode (GSM).
        Make Sure PhoneB is able to make/receive call.
        Call from PhoneB to PhoneA, accept on PhoneA, hold and unhold on PhoneA.

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])
        # make sure PhoneA is GSM phone before proceed.
        if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_GSM):
            self.log.error("Not GSM phone, abort this wcdma hold/unhold test.")
            return False

        tasks = [(phone_setup_voice_2g, (self.log, ads[0])),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        ads[0].droid.telecomCallClearCallList()
        if num_active_calls(self.log, ads[0]) != 0:
            ads[0].log.error("Call List is not empty.")
            return False

        self.log.info("Begin MT Call Hold/Unhold Test.")
        if not call_setup_teardown(
                self.log,
                ads[1],
                ads[0],
                ad_hangup=None,
                verify_caller_func=None,
                verify_callee_func=is_phone_in_call_2g):
            return False

        if not hold_unhold_test(ads[0].log, ads)[0]:
            self.log.error("Hold/Unhold test fail.")
            return False

        return True

    @test_tracker_info(uuid="d0008b51-25ed-414a-9b82-3ffb139a6e0d")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_long_duration_volte(self):
        """ Test call drop rate for VoLTE long duration call.

        Steps:
        1. Setup VoLTE for DUT.
        2. Make VoLTE call from DUT to PhoneB.
        3. For <total_duration> time, check if DUT drop call or not.

        Expected Results:
        DUT should not drop call.

        Returns:
        False if DUT call dropped during test.
        Otherwise True.
        """
        ads = self.android_devices

        tasks = [(phone_setup_volte, (self.log, ads[0])),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        return _test_call_long_duration(self.log, ads,
            is_phone_in_call_volte, self.long_call_duration)

    @test_tracker_info(uuid="d4c1aec0-df05-403f-954c-496faf18605a")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_long_duration_wfc(self):
        """ Test call drop rate for WiFi Calling long duration call.

        Steps:
        1. Setup WFC for DUT.
        2. Make WFC call from DUT to PhoneB.
        3. For <total_duration> time, check if DUT drop call or not.

        Expected Results:
        DUT should not drop call.

        Returns:
        False if DUT call dropped during test.
        Otherwise True.
        """
        ads = self.android_devices

        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        return _test_call_long_duration(self.log, ads,
            is_phone_in_call_iwlan, self.long_call_duration)

    @test_tracker_info(uuid="bc44f3ca-2616-4024-b959-3a5a85503dfd")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_long_duration_3g(self):
        """ Test call drop rate for 3G long duration call.

        Steps:
        1. Setup 3G for DUT.
        2. Make CS call from DUT to PhoneB.
        3. For <total_duration> time, check if DUT drop call or not.

        Expected Results:
        DUT should not drop call.

        Returns:
        False if DUT call dropped during test.
        Otherwise True.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])

        tasks = [(phone_setup_voice_3g, (self.log, ads[0])),
                 (phone_setup_voice_general, (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        return _test_call_long_duration(self.log, ads,
            is_phone_in_call_3g, self.long_call_duration)

    def _test_call_hangup_while_ringing(self, ad_caller, ad_callee):
        """ Call a phone and verify ringing, then hangup from the originator

        1. Setup PhoneA and PhoneB to ensure voice service.
        2. Call from PhoneA to PhoneB and wait for ringing.
        3. End the call on PhoneA.

        Returns:
            True if pass; False if fail.
        """

        caller_number = ad_caller.telephony['subscription'][
            get_outgoing_voice_sub_id(ad_caller)]['phone_num']
        callee_number = ad_callee.telephony['subscription'][
            get_incoming_voice_sub_id(ad_callee)]['phone_num']

        tasks = [(phone_setup_voice_general, (self.log, ad_caller)),
                 (phone_setup_voice_general, (self.log, ad_callee))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False

        ad_caller.droid.telecomCallClearCallList()
        if num_active_calls(self.log, ad_caller) != 0:
            ad_caller.log.error("Phone has ongoing calls.")
            return False

        if not initiate_call(self.log, ad_caller, callee_number):
            ad_caller.log.error("Phone was unable to initate a call")
            return False

        if not wait_for_ringing_call(self.log, ad_callee, caller_number):
            ad_callee.log.error("Phone never rang.")
            return False

        if not hangup_call(self.log, ad_caller):
            ad_caller.log.error("Unable to hang up the call")
            return False

        return True

    @test_tracker_info(uuid="ef4fb42d-9040-46f2-9626-d0a2e1dd854f")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mo_hangup_while_ringing(self):
        """ Call a phone and verify ringing, then hangup from the originator

        1. Setup PhoneA and PhoneB to ensure voice service.
        2. Call from PhoneA to PhoneB and wait for ringing.
        3. End the call on PhoneA.

        Returns:
            True if pass; False if fail.
        """

        return self._test_call_hangup_while_ringing(self.android_devices[0],
                                                    self.android_devices[1])

    @test_tracker_info(uuid="f514ac72-d551-4e21-b5af-bd87b6cdf34a")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mt_hangup_while_ringing(self):
        """ Call a phone and verify ringing, then hangup from the originator

        1. Setup PhoneA and PhoneB to ensure voice service.
        2. Call from PhoneB to PhoneA and wait for ringing.
        3. End the call on PhoneB.

        Returns:
            True if pass; False if fail.
        """

        return self._test_call_hangup_while_ringing(self.android_devices[1],
                                                    self.android_devices[0])


    @test_tracker_info(uuid="aa40e7e1-e64a-480b-86e4-db2242449555")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mo_voice_general_in_active_data_transfer(self):
        """Test call can be established during active data connection.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting downloading file from Internet.
        Initiate a MO voice call. Verify call can be established.
        Hangup Voice Call, verify file is downloaded successfully.
        Note: file download will be suspended when call is initiated if voice
              is using voice channel and voice channel and data channel are
              on different RATs.

        Returns:
            True if success.
            False if failed.
        """
        return test_call_setup_in_active_data_transfer(
            self.log,
            self.android_devices,
            rat=None,
            call_direction=DIRECTION_MOBILE_ORIGINATED)

    @test_tracker_info(uuid="d750d66b-2091-4e8d-baa2-084b9d2bbff5")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mt_voice_general_in_active_data_transfer(self):
        """Test call can be established during active data connection.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting downloading file from Internet.
        Initiate a MT voice call. Verify call can be established.
        Hangup Voice Call, verify file is downloaded successfully.
        Note: file download will be suspended when call is initiated if voice
              is using voice channel and voice channel and data channel are
              on different RATs.

        Returns:
            True if success.
            False if failed.
        """
        return test_call_setup_in_active_data_transfer(
            self.log,
            self.android_devices,
            rat=None,
            call_direction=DIRECTION_MOBILE_TERMINATED)

    @test_tracker_info(uuid="35703e83-b3e6-40af-aeaf-6b983d6205f4")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mo_voice_volte_in_active_data_transfer(self):
        """Test call can be established during active data connection.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting downloading file from Internet.
        Initiate a MO voice call. Verify call can be established.
        Hangup Voice Call, verify file is downloaded successfully.
        Note: file download will be suspended when call is initiated if voice
              is using voice channel and voice channel and data channel are
              on different RATs.

        Returns:
            True if success.
            False if failed.
        """
        return test_call_setup_in_active_data_transfer(
            self.log,
            self.android_devices,
            rat='volte',
            call_direction=DIRECTION_MOBILE_ORIGINATED)

    @test_tracker_info(uuid="a0f658d9-4212-44db-b3e8-7202f1eec04d")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mt_voice_volte_in_active_data_transfer(self):
        """Test call can be established during active data connection.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting downloading file from Internet.
        Initiate a MT voice call. Verify call can be established.
        Hangup Voice Call, verify file is downloaded successfully.
        Note: file download will be suspended when call is initiated if voice
              is using voice channel and voice channel and data channel are
              on different RATs.

        Returns:
            True if success.
            False if failed.
        """
        return test_call_setup_in_active_data_transfer(
            self.log,
            self.android_devices,
            rat='volte',
            call_direction=DIRECTION_MOBILE_TERMINATED)

    @test_tracker_info(uuid="e0b264ec-fc29-411e-b018-684b7ff5a37e")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mo_voice_csfb_in_active_data_transfer(self):
        """Test call can be established during active data connection.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting downloading file from Internet.
        Initiate a MO voice call. Verify call can be established.
        Hangup Voice Call, verify file is downloaded successfully.
        Note: file download will be suspended when call is initiated if voice
              is using voice channel and voice channel and data channel are
              on different RATs.

        Returns:
            True if success.
            False if failed.
        """
        return test_call_setup_in_active_data_transfer(
            self.log,
            self.android_devices,
            rat='csfb',
            call_direction=DIRECTION_MOBILE_ORIGINATED,
            allow_data_transfer_interruption=True)

    @test_tracker_info(uuid="98f04a27-74e1-474d-90d1-a4a45cdb6f5b")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mt_voice_csfb_in_active_data_transfer(self):
        """Test call can be established during active data connection.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting downloading file from Internet.
        Initiate a MT voice call. Verify call can be established.
        Hangup Voice Call, verify file is downloaded successfully.
        Note: file download will be suspended when call is initiated if voice
              is using voice channel and voice channel and data channel are
              on different RATs.

        Returns:
            True if success.
            False if failed.
        """
        return test_call_setup_in_active_data_transfer(
            self.log,
            self.android_devices,
            rat='csfb',
            call_direction=DIRECTION_MOBILE_TERMINATED,
            allow_data_transfer_interruption=True)

    @test_tracker_info(uuid="359b1ee1-36a6-427b-9d9e-4d77231fcb09")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mo_voice_3g_in_active_data_transfer(self):
        """Test call can be established during active data connection.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting downloading file from Internet.
        Initiate a MO voice call. Verify call can be established.
        Hangup Voice Call, verify file is downloaded successfully.
        Note: file download will be suspended when call is initiated if voice
              is using voice channel and voice channel and data channel are
              on different RATs.

        Returns:
            True if success.
            False if failed.
        """
        self.check_band_support(self.android_devices[0])
        return test_call_setup_in_active_data_transfer(
            self.log,
            self.android_devices,
            rat='3g',
            call_direction=DIRECTION_MOBILE_ORIGINATED,
            allow_data_transfer_interruption=True)

    @test_tracker_info(uuid="b172bbb4-2d6e-4d83-a381-ebfdf23bc30e")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mt_voice_3g_in_active_data_transfer(self):
        """Test call can be established during active data connection.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting downloading file from Internet.
        Initiate a MT voice call. Verify call can be established.
        Hangup Voice Call, verify file is downloaded successfully.
        Note: file download will be suspended when call is initiated if voice
              is using voice channel and voice channel and data channel are
              on different RATs.

        Returns:
            True if success.
            False if failed.
        """
        self.check_band_support(self.android_devices[0])
        return test_call_setup_in_active_data_transfer(
            self.log,
            self.android_devices,
            rat='3g',
            call_direction=DIRECTION_MOBILE_TERMINATED,
            allow_data_transfer_interruption=True)

    @test_tracker_info(uuid="f5d9bfd0-0996-4c18-b11e-c6113dc201e2")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mo_voice_2g_in_active_data_transfer(self):
        """Test call can be established during active data connection.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting downloading file from Internet.
        Initiate a MO voice call. Verify call can be established.
        Hangup Voice Call, verify file is downloaded successfully.
        Note: file download will be suspended when call is initiated if voice
              is using voice channel and voice channel and data channel are
              on different RATs.

        Returns:
            True if success.
            False if failed.
        """
        self.check_band_support(self.android_devices[0])
        return test_call_setup_in_active_data_transfer(
            self.log,
            self.android_devices,
            rat='2g',
            call_direction=DIRECTION_MOBILE_ORIGINATED,
            allow_data_transfer_interruption=True)

    @test_tracker_info(uuid="99cfd1be-b992-48bf-a50e-fc3eec8e5a67")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mt_voice_2g_in_active_data_transfer(self):
        """Test call can be established during active data connection.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting downloading file from Internet.
        Initiate a MT voice call. Verify call can be established.
        Hangup Voice Call, verify file is downloaded successfully.
        Note: file download will be suspended when call is initiated if voice
              is using voice channel and voice channel and data channel are
              on different RATs.

        Returns:
            True if success.
            False if failed.
        """
        self.check_band_support(self.android_devices[0])
        return test_call_setup_in_active_data_transfer(
            self.log,
            self.android_devices,
            rat='2g',
            call_direction=DIRECTION_MOBILE_TERMINATED,
            allow_data_transfer_interruption=True)

    @test_tracker_info(uuid="12677cf2-40d3-4bb1-8afa-91ebcbd0f862")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mo_voice_wifi_wfc_in_active_data_transfer(self):
        """Test call can be established during active data connection.

        Turn off airplane mode, turn on wfc and wifi.
        Starting downloading file from Internet.
        Initiate a MO voice call. Verify call can be established.
        Hangup Voice Call, verify file is downloaded successfully.

        Returns:
            True if success.
            False if failed.
        """
        if not phone_setup_iwlan(self.log, self.android_devices[0], False,
                                 WFC_MODE_WIFI_PREFERRED,
                                 self.wifi_network_ssid,
                                 self.wifi_network_pass):
            self.android_devices[0].log.error(
                "Failed to setup IWLAN with NON-APM WIFI WFC on")
            return False
        return test_call_setup_in_active_data_transfer(
            self.log,
            self.android_devices,
            rat=None,
            call_direction=DIRECTION_MOBILE_ORIGINATED)

    @test_tracker_info(uuid="84adcc19-43bb-4ea3-9284-7322ab139aac")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mt_voice_wifi_wfc_in_active_data_transfer(self):
        """Test call can be established during active data connection.

        Turn off airplane mode, turn on wfc and wifi.
        Starting downloading file from Internet.
        Initiate a MT voice call. Verify call can be established.
        Hangup Voice Call, verify file is downloaded successfully.

        Returns:
            True if success.
            False if failed.
        """
        if not phone_setup_iwlan(self.log, self.android_devices[0], False,
                                 WFC_MODE_WIFI_PREFERRED,
                                 self.wifi_network_ssid,
                                 self.wifi_network_pass):
            self.android_devices[0].log.error(
                "Failed to setup iwlan with APM off and WIFI and WFC on")
            return False
        return test_call_setup_in_active_data_transfer(
            self.log,
            self.android_devices,
            rat=None,
            call_direction=DIRECTION_MOBILE_TERMINATED)

    @test_tracker_info(uuid="42566255-c33f-406c-abab-932a0aaa01a8")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mo_voice_apm_wifi_wfc_in_active_data_transfer(self):
        """Test call can be established during active data connection.

        Turn on wifi-calling, airplane mode and wifi.
        Starting downloading file from Internet.
        Initiate a MO voice call. Verify call can be established.
        Hangup Voice Call, verify file is downloaded successfully.

        Returns:
            True if success.
            False if failed.
        """
        carrier = self.get_carrier_name(self.android_devices[0])
        if carrier == CARRIER_VZW:
            wfc = WFC_MODE_CELLULAR_PREFERRED
        else:
            wfc = WFC_MODE_WIFI_PREFERRED
        if not phone_setup_iwlan(self.log, self.android_devices[0], True,
                                 wfc,
                                 self.wifi_network_ssid,
                                 self.wifi_network_pass):
            self.android_devices[0].log.error(
                "Failed to setup iwlan with APM, WIFI and WFC on")
            return False
        return test_call_setup_in_active_data_transfer(
            self.log,
            self.android_devices,
            rat=None,
            call_direction=DIRECTION_MOBILE_ORIGINATED)

    @test_tracker_info(uuid="fbf52f60-449b-46f2-9486-36d338a1b070")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mt_voice_apm_wifi_wfc_in_active_data_transfer(self):
        """Test call can be established during active data connection.

        Turn on wifi-calling, airplane mode and wifi.
        Starting downloading file from Internet.
        Initiate a MT voice call. Verify call can be established.
        Hangup Voice Call, verify file is downloaded successfully.

        Returns:
            True if success.
            False if failed.
        """
        carrier = self.get_carrier_name(self.android_devices[0])
        if carrier == CARRIER_VZW:
            wfc = WFC_MODE_CELLULAR_PREFERRED
        else:
            wfc = WFC_MODE_WIFI_PREFERRED
        if not phone_setup_iwlan(self.log, self.android_devices[0], True,
                                 wfc,
                                 self.wifi_network_ssid,
                                 self.wifi_network_pass):
            self.android_devices[0].log.error(
                "Failed to setup iwlan with APM, WIFI and WFC on")
            return False
        return test_call_setup_in_active_data_transfer(
            self.log,
            self.android_devices,
            rat=None,
            call_direction=DIRECTION_MOBILE_TERMINATED)

    @test_tracker_info(uuid="d1bf0739-ffb7-4bf8-ab94-570619f812a8")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mo_voice_apm_wifi_in_active_data_transfer_cellular(self):
        """Test call can be established during active data connection.

        Turn on wifi, airplane mode and wifi.
        Starting downloading file from Internet.
        Initiate a MO voice call. Verify call can be established.
        Hangup Voice Call, verify file is downloaded successfully.

        Returns:
            True if success.
            False if failed.
        """
        if not phone_setup_iwlan(self.log,
                                 self.android_devices[0],
                                 True,
                                 WFC_MODE_CELLULAR_PREFERRED,
                                 self.wifi_network_ssid,
                                 self.wifi_network_pass):
            self.android_devices[0].log.error(
                "Failed to setup iwlan with APM, WIFI")
            return False
        return test_call_setup_in_active_data_transfer(
            self.log,
            self.android_devices,
            rat=None,
            call_direction=DIRECTION_MOBILE_ORIGINATED)

    @test_tracker_info(uuid="76b2cdaf-b783-4c1a-b91b-207f82ffa816")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mt_voice_apm_wifi_in_active_data_transfer_cellular(self):
        """Test call can be established during active data connection.

        Turn on wifi, airplane mode and wifi.
        Starting downloading file from Internet.
        Initiate a MT voice call. Verify call can be established.
        Hangup Voice Call, verify file is downloaded successfully.

        Returns:
            True if success.
            False if failed.
        """
        if not phone_setup_iwlan(self.log,
                                 self.android_devices[0],
                                 True,
                                 WFC_MODE_CELLULAR_PREFERRED,
                                 self.wifi_network_ssid,
                                 self.wifi_network_pass):
            self.android_devices[0].log.error(
                "Failed to setup iwlan with APM, WIFI and WFC on")
            return False
        return test_call_setup_in_active_data_transfer(
            self.log,
            self.android_devices,
            rat=None,
            call_direction=DIRECTION_MOBILE_TERMINATED)

    @test_tracker_info(uuid="1dc9f03f-1b6c-4c17-993b-3acafdc26ea3")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mo_voice_general_in_active_youtube_video(self):
        """Test call can be established during active youtube video.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting an youtube video.
        Initiate a MO voice call. Verify call can be established.

        Returns:
            True if success.
            False if failed.
        """
        return test_call_setup_in_active_youtube_video(
            self.log,
            self.android_devices,
            rat=None,
            call_direction=DIRECTION_MOBILE_ORIGINATED)

    @test_tracker_info(uuid="32bc8fab-a0b9-4d47-8afb-940d1fdcde02")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mt_voice_general_in_active_youtube_video(self):
        """Test call can be established during active youtube video.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting an youtube video.
        Initiate a MT voice call. Verify call can be established.

        Returns:
            True if success.
            False if failed.
        """
        return test_call_setup_in_active_youtube_video(
            self.log,
            self.android_devices,
            rat=None,
            call_direction=DIRECTION_MOBILE_TERMINATED)

    @test_tracker_info(uuid="72204212-e0c8-4447-be3f-ae23b2a63a1c")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mo_voice_volte_in_active_youtube_video(self):
        """Test call can be established during active youtube video.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting an youtube video.
        Initiate a MO voice call. Verify call can be established.

        Returns:
            True if success.
            False if failed.
        """
        return test_call_setup_in_active_youtube_video(
            self.log,
            self.android_devices,
            rat='volte',
            call_direction=DIRECTION_MOBILE_ORIGINATED)

    @test_tracker_info(uuid="84cd3ab9-a2b2-4ef9-b531-ee6201bec128")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mt_voice_volte_in_active_youtube_video(self):
        """Test call can be established during active youtube video.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting an youtube video.
        Initiate a MT voice call. Verify call can be established.

        Returns:
            True if success.
            False if failed.
        """
        return test_call_setup_in_active_youtube_video(
            self.log,
            self.android_devices,
            rat='volte',
            call_direction=DIRECTION_MOBILE_TERMINATED)

    @test_tracker_info(uuid="a8dca8d3-c44c-40a6-be56-931b4be5499b")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mo_voice_csfb_in_active_youtube_video(self):
        """Test call can be established during active youbube video.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting an youtube video.
        Initiate a MO voice call. Verify call can be established.

        Returns:
            True if success.
            False if failed.
        """
        return test_call_setup_in_active_youtube_video(
            self.log,
            self.android_devices,
            rat='csfb',
            call_direction=DIRECTION_MOBILE_ORIGINATED)

    @test_tracker_info(uuid="d11f7263-f51d-4ea3-916a-0df4f52023ce")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mt_voice_csfb_in_active_youtube_video(self):
        """Test call can be established during active youtube video.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting an youtube video.
        Initiate a MT voice call. Verify call can be established.

        Returns:
            True if success.
            False if failed.
        """
        return test_call_setup_in_active_youtube_video(
            self.log,
            self.android_devices,
            rat='csfb',
            call_direction=DIRECTION_MOBILE_TERMINATED)

    @test_tracker_info(uuid="676378b4-94b7-4ad7-8242-7ccd2bf1efba")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mo_voice_3g_in_active_youtube_video(self):
        """Test call can be established during active youtube video.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting an youtube video.
        Initiate a MO voice call. Verify call can be established.

        Returns:
            True if success.
            False if failed.
        """
        self.check_band_support(self.android_devices[0])
        return test_call_setup_in_active_youtube_video(
            self.log,
            self.android_devices,
            rat='3g',
            call_direction=DIRECTION_MOBILE_ORIGINATED)

    @test_tracker_info(uuid="6216fc6d-2aa2-4eb9-90e2-5791cb31c12e")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mt_voice_3g_in_active_youtube_video(self):
        """Test call can be established during active youtube video.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting youtube video.
        Initiate a MT voice call. Verify call can be established.

        Returns:
            True if success.
            False if failed.
        """
        self.check_band_support(self.android_devices[0])
        return test_call_setup_in_active_youtube_video(
            self.log,
            self.android_devices,
            rat='3g',
            call_direction=DIRECTION_MOBILE_TERMINATED)

    @test_tracker_info(uuid="58ec9783-6f8e-49f6-8dae-9dd33108b6f9")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mo_voice_2g_in_active_youtube_video(self):
        """Test call can be established during active youtube video.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting youtube video.
        Initiate a MO voice call. Verify call can be established.

        Returns:
            True if success.
            False if failed.
        """
        self.check_band_support(self.android_devices[0])
        return test_call_setup_in_active_youtube_video(
            self.log,
            self.android_devices,
            rat='2g',
            call_direction=DIRECTION_MOBILE_ORIGINATED)

    @test_tracker_info(uuid="e8ba7c0c-48a3-4fc6-aa34-a2e1c570521a")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mt_voice_2g_in_active_youtube_video(self):
        """Test call can be established during active youtube video.

        Turn off airplane mode, disable WiFi, enable Cellular Data.
        Make sure phone in <nw_gen>.
        Starting an youtube video.
        Initiate a MT voice call. Verify call can be established.

        Returns:
            True if success.
            False if failed.
        """
        self.check_band_support(self.android_devices[0])
        return test_call_setup_in_active_youtube_video(
            self.log,
            self.android_devices,
            rat='2g',
            call_direction=DIRECTION_MOBILE_TERMINATED)

    @test_tracker_info(uuid="eb8971c1-b34a-430f-98df-0d4554c7ab12")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mo_voice_wifi_wfc_in_active_youtube_video(self):
        """Test call can be established during active youtube video.

        Turn off airplane mode, turn on wfc and wifi.
        Starting youtube video.
        Initiate a MO voice call. Verify call can be established.

        Returns:
            True if success.
            False if failed.
        """
        return test_call_setup_in_active_youtube_video(
            self.log,
            self.android_devices,
            rat="wfc",
            wfc_mode=WFC_MODE_WIFI_PREFERRED,
            wifi_ssid=self.wifi_network_ssid,
            wifi_pwd=self.wifi_network_pass,
            call_direction=DIRECTION_MOBILE_ORIGINATED)

    @test_tracker_info(uuid="275a93d6-1f39-40c8-893f-ff77afd09e54")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mt_voice_wifi_wfc_in_active_youtube_video(self):
        """Test call can be established during active youtube_video.

        Turn off airplane mode, turn on wfc and wifi.
        Starting an youtube video.
        Initiate a MT voice call. Verify call can be established.

        Returns:
            True if success.
            False if failed.
        """
        return test_call_setup_in_active_youtube_video(
            self.log,
            self.android_devices,
            rat="wfc",
            wfc_mode=WFC_MODE_WIFI_PREFERRED,
            wifi_ssid=self.wifi_network_ssid,
            wifi_pwd=self.wifi_network_pass,
            call_direction=DIRECTION_MOBILE_TERMINATED)

    @test_tracker_info(uuid="ea087709-d4df-4223-b80c-1b33bacbd5a2")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mo_voice_apm_wifi_wfc_in_active_youtube_video(self):
        """Test call can be established during active youtube video.

        Turn on wifi-calling, airplane mode and wifi.
        Starting an youtube video.
        Initiate a MO voice call. Verify call can be established.

        Returns:
            True if success.
            False if failed.
        """
        carrier = self.get_carrier_name(self.android_devices[0])
        if carrier == CARRIER_VZW:
            wfc = WFC_MODE_CELLULAR_PREFERRED
        else:
            wfc = WFC_MODE_WIFI_PREFERRED

        return test_call_setup_in_active_youtube_video(
            self.log,
            self.android_devices,
            rat="wfc",
            is_airplane_mode=True,
            wfc_mode=wfc,
            wifi_ssid=self.wifi_network_ssid,
            wifi_pwd=self.wifi_network_pass,
            call_direction=DIRECTION_MOBILE_ORIGINATED)

    @test_tracker_info(uuid="44cc14e0-60c7-4fdb-ad26-31fdc4e52aaf")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mt_voice_apm_wifi_wfc_in_active_youtube_video(self):
        """Test call can be established during active youtube video.

        Turn on wifi-calling, airplane mode and wifi.
        Starting youtube video.
        Initiate a MT voice call. Verify call can be established.

        Returns:
            True if success.
            False if failed.
        """
        carrier = self.get_carrier_name(self.android_devices[0])
        if carrier == CARRIER_VZW:
            wfc = WFC_MODE_CELLULAR_PREFERRED
        else:
            wfc = WFC_MODE_WIFI_PREFERRED

        return test_call_setup_in_active_youtube_video(
            self.log,
            self.android_devices,
            rat="wfc",
            is_airplane_mode=True,
            wfc_mode=wfc,
            wifi_ssid=self.wifi_network_ssid,
            wifi_pwd=self.wifi_network_pass,
            call_direction=DIRECTION_MOBILE_TERMINATED)

    @test_tracker_info(uuid="e115e8a6-25bf-41fc-aeb8-8f4c922c50e4")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mo_voice_apm_wifi_wfc_in_active_youtube_video_cellular(self):
        """Test call can be established during active youtube video.

        Turn on wifi-calling, airplane mode and wifi.
        Starting an youtube video.
        Initiate a MO voice call. Verify call can be established.

        Returns:
            True if success.
            False if failed.
        """
        return test_call_setup_in_active_youtube_video(
            self.log,
            self.android_devices,
            rat="wfc",
            is_airplane_mode=True,
            wfc_mode=WFC_MODE_CELLULAR_PREFERRED,
            wifi_ssid=self.wifi_network_ssid,
            wifi_pwd=self.wifi_network_pass,
            call_direction=DIRECTION_MOBILE_ORIGINATED)

    @test_tracker_info(uuid="d754d3dd-0b02-4f13-bc65-fdafa254196b")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mt_voice_apm_wifi_wfc_in_active_youtube_video_cellular(self):
        """Test call can be established during active youtube video.

        Turn on wifi-calling, airplane mode and wifi.
        Starting youtube video.
        Initiate a MT voice call. Verify call can be established.

        Returns:
            True if success.
            False if failed.
        """
        return test_call_setup_in_active_youtube_video(
            self.log,
            self.android_devices,
            rat="wfc",
            is_airplane_mode=True,
            wfc_mode=WFC_MODE_CELLULAR_PREFERRED,
            wifi_ssid=self.wifi_network_ssid,
            wifi_pwd=self.wifi_network_pass,
            call_direction=DIRECTION_MOBILE_TERMINATED)

    @test_tracker_info(uuid="88822edf-4c4a-4bc4-9280-2f27ee9e28d5")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mo_voice_apm_wifi_in_active_youtube_video_cellular(self):
        """Test call can be established during active youtube video.

        Turn on wifi, Cellular Preferred, airplane mode and wifi.
        Starting an youtube video.
        Initiate a MO voice call. Verify call can be established.

        Returns:
            True if success.
            False if failed.
        """
        return test_call_setup_in_active_youtube_video(
            self.log,
            self.android_devices,
            rat="wfc",
            is_airplane_mode=True,
            wfc_mode=WFC_MODE_CELLULAR_PREFERRED,
            wifi_ssid=self.wifi_network_ssid,
            wifi_pwd=self.wifi_network_pass,
            call_direction=DIRECTION_MOBILE_ORIGINATED)

    @test_tracker_info(uuid="c4b066b0-3cfd-4831-9c61-5d6b132648c4")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_mt_voice_apm_wifi_in_active_youtube_video_cellular(self):
        """Test call can be established during active youtube video.

        Turn on cellular calling, airplane mode and wifi.
        Starting youtube video.
        Initiate a MT voice call. Verify call can be established.

        Returns:
            True if success.
            False if failed.
        """
        return test_call_setup_in_active_youtube_video(
            self.log,
            self.android_devices,
            rat="wfc",
            is_airplane_mode=True,
            wfc_mode=WFC_MODE_CELLULAR_PREFERRED,
            wifi_ssid=self.wifi_network_ssid,
            wifi_pwd=self.wifi_network_pass,
            call_direction=DIRECTION_MOBILE_TERMINATED)

    @test_tracker_info(uuid="f367de12-1fd8-488d-816f-091deaacb791")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_wfc_wifi_preferred_after_mobile_data_usage_limit_reached(
            self):
        """ WiFi Preferred, WiFi calling test after data limit reached

        1. Set the data limit to the current usage
        2. Setup PhoneA WFC mode: WIFI_PREFERRED.
        3. Make Sure PhoneB is in general mode.
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        5. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure is not success.
        """
        ads = self.android_devices
        self.check_band_support(ads[0])
        try:
            subscriber_id = ads[0].droid.telephonyGetSubscriberId()
            data_usage = get_mobile_data_usage(ads[0], subscriber_id)
            set_mobile_data_usage_limit(ads[0], data_usage, subscriber_id)

            # Turn OFF WiFi for Phone B
            set_wifi_to_default(self.log, ads[1])
            tasks = [(phone_setup_iwlan,
                      (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED,
                       self.wifi_network_ssid, self.wifi_network_pass)),
                     (phone_setup_voice_general, (self.log, ads[1]))]
            if not multithread_func(self.log, tasks):
                self.log.error("Phone Failed to Set Up Properly.")
                self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
                raise signals.TestFailure("Failed",
                    extras={"fail_reason": "Phone Failed to Set Up Properly."})

            result = two_phone_call_short_seq(
                self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan,
                ads[1], phone_idle_3g, is_phone_in_call_3g, None)
            self.tel_logger.set_result(result.result_value)
            if not result:
                raise signals.TestFailure("Failed",
                    extras={"fail_reason": str(result.result_value)})
        finally:
            remove_mobile_data_usage_limit(ads[0], subscriber_id)

    @test_tracker_info(uuid="af943c7f-2b42-408f-b8a3-2d360a7483f7")
    @TelephonyBaseTest.tel_test_wrap
    def test_call_volte_after_mobile_data_usage_limit_reached(self):
        """ VoLTE to VoLTE call test after mobile data usage limit reached

        1. Set the data limit to the current usage
        2. Make Sure PhoneA is in LTE mode (with VoLTE).
        3. Make Sure PhoneB is in LTE mode (with VoLTE).
        4. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneA.
        5. Call from PhoneA to PhoneB, accept on PhoneB, hang up on PhoneB.

        Raises:
            TestFailure if not success.
        """
        ads = self.android_devices
        try:
            subscriber_id = ads[0].droid.telephonyGetSubscriberId()
            data_usage = get_mobile_data_usage(ads[0], subscriber_id)
            set_mobile_data_usage_limit(ads[0], data_usage, subscriber_id)

            tasks = [(phone_setup_volte, (self.log, ads[0])),
                     (phone_setup_volte, (self.log, ads[1]))]
            if not multithread_func(self.log, tasks):
                self.log.error("Phone Failed to Set Up Properly.")
                self.tel_logger.set_result(CallResult("CALL_SETUP_FAILURE"))
                raise signals.TestFailure("Failed",
                    extras={"fail_reason": "Phone Failed to Set Up Properly."})

            result = two_phone_call_short_seq(
                self.log, ads[0], phone_idle_volte, is_phone_in_call_volte,
                ads[1], phone_idle_volte, is_phone_in_call_volte, None,
                WAIT_TIME_IN_CALL_FOR_IMS)
            self.tel_logger.set_result(result.result_value)
            if not result:
                raise signals.TestFailure("Failed",
                    extras={"fail_reason": str(result.result_value)})
        finally:
            remove_mobile_data_usage_limit(ads[0], subscriber_id)

    @test_tracker_info(uuid="7955f1ae-84b1-4c33-9e59-af930605672a")
    @TelephonyBaseTest.tel_test_wrap
    def test_volte_in_call_wifi_toggling(self):
        """ General voice to voice call.

        1. Make Sure PhoneA in VoLTE.
        2. Make Sure PhoneB in VoLTE.
        3. Call from PhoneA to PhoneB.
        4. Toggling Wifi connnection in call.
        5. Verify call is active.
        6. Hung up the call on PhoneA

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_volte, (self.log, ads[0])), (phone_setup_volte,
                                                           (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False
        return test_wifi_cell_switching_in_call(
            self.log,
            ads,
            self.wifi_network_ssid,
            self.wifi_network_pass,
            verify_caller_func=is_phone_in_call_volte,
            verify_callee_func=is_phone_in_call_volte)

    @test_tracker_info(uuid="8a853186-cdff-4078-930a-6c619ea89183")
    @TelephonyBaseTest.tel_test_wrap
    def test_wfc_in_call_wifi_toggling(self):
        """ General voice to voice call. TMO Only Test

        1. Make Sure PhoneA in wfc with APM off.
        2. Make Sure PhoneB in Voice Capable.
        3. Call from PhoneA to PhoneB.
        4. Toggling Wifi connection in call.
        5. Verify call is active.
        6. Hung up the call on PhoneA

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        if not phone_setup_volte(self.log, ads[0]):
            return False

        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass)),
                 (phone_setup_voice_general, (self.log, ads[1]))]

        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False
        return test_wifi_cell_switching_in_call(
            self.log,
            ads,
            self.wifi_network_ssid,
            self.wifi_network_pass,
            verify_caller_func=is_phone_in_call_iwlan)

    @test_tracker_info(uuid="187bf7b5-d122-4914-82c0-b0709272ee12")
    @TelephonyBaseTest.tel_test_wrap
    def test_csfb_in_call_wifi_toggling(self):
        """ General voice to voice call.

        1. Make Sure PhoneA in CSFB.
        2. Make Sure PhoneB in CSFB.
        3. Call from PhoneA to PhoneB.
        4. Toggling Wifi connection in call.
        5. Verify call is active.
        6. Hung up the call on PhoneA

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_csfb, (self.log, ads[0])), (phone_setup_csfb,
                                                          (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            return False
        return test_wifi_cell_switching_in_call(
            self.log,
            ads,
            self.wifi_network_ssid,
            self.wifi_network_pass,
            verify_caller_func=is_phone_in_call_csfb,
            verify_callee_func=is_phone_in_call_csfb)

    @test_tracker_info(uuid="df555d9f-30e6-47f9-9e9f-9814e6892857")
    @TelephonyBaseTest.tel_test_wrap
    def test_wfc_lte_call_handover(self):
        """ WFC to lte handover.

        1. Make a voice call over wifi.
        2. Turn off Wifi.
        3. Call should handover from Wifi to LTE.
        4. Verify call is active.
        5. Hung up the call on PhoneA

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_volte, (self.log, ads[0])), (phone_setup_volte,
                                                           (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})


        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass))]

        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        ad_caller = ads[0]
        ad_callee = ads[1]
        caller_number = get_phone_number(self.log, ad_caller)
        callee_number = get_phone_number(self.log, ad_callee)

        try:
            # Make MO/MT call.
            if not initiate_call(self.log, ad_caller, callee_number):
                raise signals.TestFailure("Failed to initiate call")
            if not wait_and_answer_call(self.log, ad_callee, caller_number):
                raise signals.TestFailure("Answer call falied")
            if not self._is_phone_in_call_iwlan():
                raise signals.TestFailure("Phone call not in Iwlan ")
            time.sleep(15)
            # Turn off the wifi and wait call to handover.
            wifi_toggle_state(self.log, self.android_devices[0], False)
            time.sleep(15)
            if not self.is_phone_in_call_volte():
                raise signals.TestFailure("WFC handover failed, call disconnected ")

            else:
                self.log.info("Handover Successful")

            if is_phone_in_call(self.log, ads[0]):
                # hangup call
                if not hangup_call(self.log, ads[0]):
                    raise signals.TestFailure("hangup_call fail.")

            else:
                raise signals.TestFailure("Unexpected call drop.")


        except Exception as e:
                self.log.error("Exception error %s", str(e))
                return False
        return True

    @test_tracker_info(uuid="331ff54c-ee36-4f59-9c3c-24faf41b1383")
    @TelephonyBaseTest.tel_test_wrap
    def test_lte_wfc_call_handover(self):
        """ LTE to WFC handover.

        1. Make a voice call over LTE.
        2. Turn on Wifi.
        3. Call should handover from LTE to Wifi.
        4. Verify call is active.
        5. Hung up the call on PhoneA

        Returns:
            True if pass; False if fail.
        """
        ads = self.android_devices

        tasks = [(phone_setup_volte, (self.log, ads[0])), (phone_setup_volte,
                                                           (self.log, ads[1]))]
        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})


        tasks = [(phone_setup_iwlan,
                  (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED,
                   self.wifi_network_ssid, self.wifi_network_pass))]

        if not multithread_func(self.log, tasks):
            self.log.error("Phone Failed to Set Up Properly.")
            raise signals.TestFailure("Failed",
                extras={"fail_reason": "Phone Failed to Set Up Properly."})

        ad_caller = ads[0]
        ad_callee = ads[1]
        caller_number = get_phone_number(self.log, ad_caller)
        callee_number = get_phone_number(self.log, ad_callee)

        try:
            # Turn off the wifi and make a call.
            wifi_toggle_state(self.log, self.android_devices[0], False)
            if not initiate_call(self.log, ad_caller, callee_number):
                raise signals.TestFailure("Failed to initiate call")
            if not wait_and_answer_call(self.log, ad_callee, caller_number):
                raise signals.TestFailure("Answer call falied")
            if not self.is_phone_in_call_volte():
                raise signals.TestFailure("Phone call not via LTE")
            time.sleep(15)
            # Turn on the wifi and wait call to handover.
            wifi_toggle_state(self.log, self.android_devices[0], True)
            time.sleep(15)
            if not self._is_phone_in_call_iwlan():
                raise signals.TestFailure("LTE handover failed, call disconnected ")

            else:
                self.log.info("Handover Successful")

            if is_phone_in_call(self.log, ads[0]):
                # hangup call
                if not hangup_call(self.log, ads[0]):
                    raise signals.TestFailure("hangup_call fail.")

            else:
                raise signals.TestFailure("Unexpected call drop.")


        except Exception as e:
                self.log.error("Exception error %s", str(e))
                return False
        return True


""" Tests End """