Add MMS test cases.

Test: tested with ACTS.
Bug: 34346312
Change-Id: I258a2a3af026eeb661dde4e384f276196baa4223

2 files changed, 992 insertions, 84 deletions

diff --git a/acts/framework/acts/test_utils/tel/tel_test_utils.py b/acts/framework/acts/test_utils/tel/tel_test_utils.py
index 8fc4e8cf91..12825ae2cd 100644
--- a/acts/framework/acts/test_utils/tel/tel_test_utils.py
+++ b/acts/framework/acts/test_utils/tel/tel_test_utils.py
@@ -92,6 +92,7 @@ from acts.test_utils.tel.tel_defines import EventDataSmsReceived
 from acts.test_utils.tel.tel_defines import EventMessageWaitingIndicatorChanged
 from acts.test_utils.tel.tel_defines import EventServiceStateChanged
 from acts.test_utils.tel.tel_defines import EventMmsSentSuccess
+from acts.test_utils.tel.tel_defines import EventMmsDownloaded
 from acts.test_utils.tel.tel_defines import EventSmsReceived
 from acts.test_utils.tel.tel_defines import EventSmsSentSuccess
 from acts.test_utils.tel.tel_defines import CallStateContainer
@@ -166,14 +167,15 @@ def setup_droid_properties_by_adb(log, ad, sim_filename=None):
     phone_number = get_phone_number_by_adb(ad) or sim_data[iccid]["phone_num"]
     if not phone_number:
         raise TelTestUtilsError(
-              "Failed to find valid phone number for {}".format(ad.serial))
+            "Failed to find valid phone number for {}".format(ad.serial))
     sim_record = {
-          'phone_num': phone_number_formatter(phone_number),
-          'iccid': get_iccid_by_adb(ad),
-          'operator': get_operator_by_adb(ad)}
+        'phone_num': phone_number_formatter(phone_number),
+        'iccid': get_iccid_by_adb(ad),
+        'operator': get_operator_by_adb(ad)
+    }
     device_props = {'subscription': {sub_id: sim_record}}
     log.info("phone_info: <{}:{}>, <subId: {}> <sim_record: {}>".format(
-           ad.model, ad.serial, sub_id, sim_record))
+        ad.model, ad.serial, sub_id, sim_record))
     setattr(ad, 'cfg', device_props)
 
 
@@ -184,7 +186,8 @@ def setup_droid_properties(log, ad, sim_filename=None):
         return
 
     if ad.skip_sl4a:
-        return setup_droid_properties_by_adb(log, ad, sim_filename=sim_filename)
+        return setup_droid_properties_by_adb(
+            log, ad, sim_filename=sim_filename)
     device_props = {}
     device_props['subscription'] = {}
 
@@ -330,8 +333,8 @@ def toggle_airplane_mode(log, ad, new_state=None, strict_checking=True):
     if ad.skip_sl4a:
         return toggle_airplane_mode_by_adb(log, ad, new_state)
     else:
-        return toggle_airplane_mode_msim(log, ad, new_state,
-                                         strict_checking=strict_checking)
+        return toggle_airplane_mode_msim(
+            log, ad, new_state, strict_checking=strict_checking)
 
 
 def is_expected_event(event_to_check, events_list):
@@ -417,8 +420,10 @@ def _wait_for_bluetooth_in_state(log, ad, state, max_wait):
                       format(bt_state, state))
             return False
 
-        event = {False: _BLUETOOTH_STATE_OFF_EVENT,
-                 True: _BLUETOOTH_STATE_ON_EVENT}[state]
+        event = {
+            False: _BLUETOOTH_STATE_OFF_EVENT,
+            True: _BLUETOOTH_STATE_ON_EVENT
+        }[state]
         ad.ed.pop_event(event, max_wait)
         return True
     except Empty:
@@ -516,10 +521,10 @@ def toggle_airplane_mode_msim(log, ad, new_state=None, strict_checking=True):
     # APM on (new_state=True) will turn off bluetooth but may not turn it on
     try:
         if new_state and not _wait_for_bluetooth_in_state(
-              log, ad, False, timeout_time - time.time()):
+                log, ad, False, timeout_time - time.time()):
             log.error(
-                  "Failed waiting for bluetooth during airplane mode toggle on {}".
-                  format(ad.serial))
+                "Failed waiting for bluetooth during airplane mode toggle on {}".
+                format(ad.serial))
             if strict_checking: return False
     except Exception as e:
         log.error("Failed to check bluetooth state due to {}".format(e))
@@ -2236,7 +2241,8 @@ def is_wfc_enabled(log, ad):
     """
     wfc_status = ad.droid.telephonyIsWifiCallingAvailable()
     if wfc_status is True and is_ims_registered(log, ad) is False:
-        log.error("Error! WiFi Calling is Available, but IMS is not registered.")
+        log.error(
+            "Error! WiFi Calling is Available, but IMS is not registered.")
         return False
     return wfc_status
 
@@ -2480,6 +2486,48 @@ def wait_for_matching_sms(log,
             return False
 
 
+def is_mms_match(event, phonenumber_tx, text):
+    """Return True if 'text' equals to event['data']['Text']
+        and phone number match.
+
+    Args:
+        event: Event object to verify.
+        phonenumber_tx: phone number for sender.
+        text: text string to verify.
+
+    Returns:
+        Return True if 'text' equals to event['data']['Text']
+            and phone number match.
+    """
+    #TODO:  add mms matching after mms message parser is added in sl4a. b/34276948
+    return True
+
+
+def wait_for_matching_mms(log, ad_rx, phonenumber_tx, text):
+    """Wait for matching incoming SMS.
+
+    Args:
+        log: Log object.
+        ad_rx: Receiver's Android Device Object
+        phonenumber_tx: Sender's phone number.
+        text: SMS content string.
+        allow_multi_part_long_sms: is long SMS allowed to be received as
+            multiple short SMS. This is optional, default value is True.
+
+    Returns:
+        True if matching incoming SMS is received.
+    """
+    try:
+        #TODO: add mms matching after mms message parser is added in sl4a. b/34276948
+        ad_rx.ed.wait_for_event(EventMmsDownloaded, is_mms_match,
+                                MAX_WAIT_TIME_SMS_RECEIVE, phonenumber_tx,
+                                text)
+        return True
+    except Empty:
+        log.error("No matched MMS downloaded event.")
+        return False
+
+
 def sms_send_receive_verify_for_subscription(log, ad_tx, ad_rx, subid_tx,
                                              subid_rx, array_message):
     """Send SMS, receive SMS, and verify content and sender's number.
@@ -2545,7 +2593,7 @@ def mms_send_receive_verify(log, ad_tx, ad_rx, array_message):
         get_incoming_message_sub_id(ad_rx), array_message)
 
 
-#TODO: b/21569494 This function is still a WIP and is disabled
+#TODO: add mms matching after mms message parser is added in sl4a. b/34276948
 def mms_send_receive_verify_for_subscription(log, ad_tx, ad_rx, subid_tx,
                                              subid_rx, array_payload):
     """Send SMS, receive SMS, and verify content and sender's number.
@@ -2563,49 +2611,28 @@ def mms_send_receive_verify_for_subscription(log, ad_tx, ad_rx, subid_tx,
         array_message: the array of message to send/receive
     """
 
-    log.error("Function is non-working: b/21569494")
-    return False
-
     phonenumber_tx = ad_tx.cfg['subscription'][subid_tx]['phone_num']
     phonenumber_rx = ad_rx.cfg['subscription'][subid_rx]['phone_num']
     for subject, message, filename in array_payload:
-        log.info("Sending MMS {} to {}, subject: {}, message: {}.".format(
-            phonenumber_tx, phonenumber_rx, subject, message))
+        log.info(
+            "Sending MMS {} to {}, subject: {}, message: {}, file: {}.".format(
+                phonenumber_tx, phonenumber_rx, subject, message, filename))
         result = False
         ad_rx.ed.clear_all_events()
         ad_rx.droid.smsStartTrackingIncomingMmsMessage()
-        ad_rx.droid.smsStartTrackingIncomingSmsMessage()
         try:
             ad_tx.droid.smsSendMultimediaMessage(
                 phonenumber_rx, subject, message, phonenumber_tx, filename)
+            try:
+                ad_tx.ed.pop_event(EventMmsSentSuccess,
+                                   MAX_WAIT_TIME_SMS_SENT_SUCCESS)
+            except Empty:
+                log.error("No sent_success event.")
+                return False
 
-            ad_tx.ed.pop_event(EventMmsSentSuccess,
-                               MAX_WAIT_TIME_SMS_SENT_SUCCESS)
-
-            start_time = time.time()
-            remaining_time = MAX_WAIT_TIME_SMS_RECEIVE
-            while remaining_time > 0:
-                event = ad_rx.ed.pop_event(EventSmsReceived, remaining_time)
-                if check_phone_number_match(event['data']['Sender'],
-                                            phonenumber_tx):
-                    log.debug("Received SMS Indication")
-                    while remaining_time > 0:
-                        event = ad_rx.ed.pop_event(EventDataSmsReceived,
-                                                   remaining_time)
-                        if check_phone_number_match(event['data']['Sender'],
-                                                    phonenumber_tx):
-                            result = True
-                            break
-                        remaining_time = time.time() - start_time
-                remaining_time = time.time() - start_time
-
-            if not result:
-                log.info("Expected sender:" + phonenumber_tx)
-                log.error("Received sender:" + event['data']['Sender'])
-                log.error("Failed in verify receiving MMS.")
+            if not wait_for_matching_mms(log, ad_rx, phonenumber_tx, message):
                 return False
         finally:
-            ad_rx.droid.smsStopTrackingIncomingSmsMessage()
             ad_rx.droid.smsStopTrackingIncomingMmsMessage()
     return True
 
@@ -2847,7 +2874,8 @@ def wait_for_not_network_rat_for_subscription(
         voice_or_data=None):
     return _wait_for_droid_in_state_for_subscription(
         log, ad, sub_id, max_wait_time,
-        lambda log, ad, sub_id, *args, **kwargs: not is_droid_in_rat_family_for_subscription(log, ad, sub_id, rat_family, voice_or_data))
+        lambda log, ad, sub_id, * args, ** kwargs: not is_droid_in_rat_family_for_subscription(log, ad, sub_id, rat_family, voice_or_data)
+    )
 
 
 def wait_for_preferred_network(log,
@@ -3604,8 +3632,7 @@ class WifiUtils():
         for network in networks:
             ad.droid.wifiForgetNetwork(network['networkId'])
             try:
-                event = ad.ed.pop_event(
-                    WifiUtils.WIFI_FORGET_NW_SUCCESS)
+                event = ad.ed.pop_event(WifiUtils.WIFI_FORGET_NW_SUCCESS)
             except Empty:
                 log.warning("Could not confirm the removal of network {}.".
                             format(network))
diff --git a/acts/tests/google/tel/live/TelLiveSmsTest.py b/acts/tests/google/tel/live/TelLiveSmsTest.py
index f2361a9a63..4862f814fd 100644
--- a/acts/tests/google/tel/live/TelLiveSmsTest.py
+++ b/acts/tests/google/tel/live/TelLiveSmsTest.py
@@ -59,7 +59,6 @@ from acts.utils import rand_ascii_str
 
 
 class TelLiveSmsTest(TelephonyBaseTest):
-
     def __init__(self, controllers):
         TelephonyBaseTest.__init__(self, controllers)
 
@@ -72,6 +71,12 @@ class TelLiveSmsTest(TelephonyBaseTest):
         except KeyError:
             self.wifi_network_pass = None
 
+        for ad in self.android_devices:
+            ad.adb.shell("su root setenforce 0")
+            #not needed for now. might need for image attachment later
+            #ad.adb.shell("pm grant com.google.android.apps.messaging "
+            #             "android.permission.READ_EXTERNAL_STORAGE")
+
     def _sms_test(self, ads):
         """Test SMS between two phones.
 
@@ -85,20 +90,37 @@ class TelLiveSmsTest(TelephonyBaseTest):
                           [rand_ascii_str(180)]]
 
         for outer_param in sms_params:
-            outer_param = (self.log,) + outer_param
+            outer_param = (self.log, ) + outer_param
             for message_array in message_arrays:
-                inner_param = outer_param + (message_array,)
+                inner_param = outer_param + (message_array, )
                 if not sms_send_receive_verify(*inner_param):
                     return False
 
         return True
 
+    def _mms_test(self, ads):
+        """Test SMS between two phones.
+
+        Returns:
+            True if success.
+            False if failed.
+        """
+        return mms_send_receive_verify(
+            self.log, ads[0], ads[1],
+            [("Test Message", "Basic Message Body", None)])
+
     def _sms_test_mo(self, ads):
         return self._sms_test([ads[0], ads[1]])
 
     def _sms_test_mt(self, ads):
         return self._sms_test([ads[1], ads[0]])
 
+    def _mms_test_mo(self, ads):
+        return self._mms_test([ads[0], ads[1]])
+
+    def _mms_test_mt(self, ads):
+        return self._mms_test([ads[1], ads[0]])
+
     def _mo_sms_in_3g_call(self, ads):
         self.log.info("Begin In Call SMS Test.")
         if not call_setup_teardown(
@@ -133,6 +155,40 @@ class TelLiveSmsTest(TelephonyBaseTest):
 
         return True
 
+    def _mo_mms_in_3g_call(self, ads):
+        self.log.info("Begin In Call MMS 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 self._mms_test_mo(ads):
+            self.log.error("MMS test fail.")
+            return False
+
+        return True
+
+    def _mt_mms_in_3g_call(self, ads):
+        self.log.info("Begin In Call MMS 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 self._mms_test_mt(ads):
+            self.log.error("MMS test fail.")
+            return False
+
+        return True
+
     def _mo_sms_in_2g_call(self, ads):
         self.log.info("Begin In Call SMS Test.")
         if not call_setup_teardown(
@@ -167,6 +223,40 @@ class TelLiveSmsTest(TelephonyBaseTest):
 
         return True
 
+    def _mo_mms_in_2g_call(self, ads):
+        self.log.info("Begin In Call MMS 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 self._mms_test_mo(ads):
+            self.log.error("MMS test fail.")
+            return False
+
+        return True
+
+    def _mt_mms_in_2g_call(self, ads):
+        self.log.info("Begin In Call MMS 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 self._mms_test_mt(ads):
+            self.log.error("MMS test fail.")
+            return False
+
+        return True
+
     @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_general(self):
         """Test SMS basic function between two phone. Phones in any network.
@@ -212,6 +302,50 @@ class TelLiveSmsTest(TelephonyBaseTest):
         return self._sms_test_mt(ads)
 
     @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mo_general(self):
+        """Test MMS basic function between two phone. Phones in any network.
+
+        Airplane mode is off.
+        Send MMS from PhoneA to PhoneB.
+        Verify received message on PhoneB is correct.
+
+        Returns:
+            True if success.
+            False if failed.
+        """
+        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 self._mms_test_mo(ads)
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mt_general(self):
+        """Test MMS basic function between two phone. Phones in any network.
+
+        Airplane mode is off.
+        Send MMS from PhoneB to PhoneA.
+        Verify received message on PhoneA is correct.
+
+        Returns:
+            True if success.
+            False if failed.
+        """
+        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 self._mms_test_mt(ads)
+
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_2g(self):
         """Test SMS basic function between two phone. Phones in 3g network.
 
@@ -256,6 +390,50 @@ class TelLiveSmsTest(TelephonyBaseTest):
         return self._sms_test_mt(ads)
 
     @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mo_2g(self):
+        """Test MMS basic function between two phone. Phones in 3g network.
+
+        Airplane mode is off.
+        Send MMS from PhoneA to PhoneB.
+        Verify received message on PhoneB is correct.
+
+        Returns:
+            True if success.
+            False if failed.
+        """
+        ads = self.android_devices
+
+        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
+
+        return self._mms_test_mo(ads)
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mt_2g(self):
+        """Test MMS basic function between two phone. Phones in 3g network.
+
+        Airplane mode is off.
+        Send MMS from PhoneB to PhoneA.
+        Verify received message on PhoneA is correct.
+
+        Returns:
+            True if success.
+            False if failed.
+        """
+        ads = self.android_devices
+
+        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
+
+        return self._mms_test_mt(ads)
+
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_3g(self):
         """Test SMS basic function between two phone. Phones in 3g network.
 
@@ -302,6 +480,52 @@ class TelLiveSmsTest(TelephonyBaseTest):
         return self._sms_test_mt(ads)
 
     @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mo_3g(self):
+        """Test MMS basic function between two phone. Phones in 3g network.
+
+        Airplane mode is off.
+        Send MMS from PhoneA to PhoneB.
+        Verify received message on PhoneB is correct.
+
+        Returns:
+            True if success.
+            False if failed.
+        """
+
+        ads = self.android_devices
+
+        tasks = [(phone_setup_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 self._mms_test_mo(ads)
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mt_3g(self):
+        """Test MMS basic function between two phone. Phones in 3g network.
+
+        Airplane mode is off.
+        Send MMS from PhoneB to PhoneA.
+        Verify received message on PhoneA is correct.
+
+        Returns:
+            True if success.
+            False if failed.
+        """
+
+        ads = self.android_devices
+
+        tasks = [(phone_setup_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 self._mms_test_mt(ads)
+
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_4g(self):
         """Test SMS basic function between two phone. Phones in LTE network.
 
@@ -351,6 +575,55 @@ class TelLiveSmsTest(TelephonyBaseTest):
         return self._sms_test_mt(ads)
 
     @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mo_4g(self):
+        """Test MMS text function between two phone. Phones in LTE network.
+
+        Airplane mode is off.
+        Send MMS from PhoneA to PhoneB.
+        Verify received message on PhoneB is correct.
+
+        Returns:
+            True if success.
+            False if failed.
+        """
+
+        #self.log.error("Test Case is non-functional: b/21569494")
+        #return False
+
+        ads = self.android_devices
+
+        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
+
+        return self._mms_test_mo(ads)
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mt_4g(self):
+        """Test MMS text function between two phone. Phones in LTE network.
+
+        Airplane mode is off.
+        Send MMS from PhoneB to PhoneA.
+        Verify received message on PhoneA is correct.
+
+        Returns:
+            True if success.
+            False if failed.
+        """
+
+        ads = self.android_devices
+
+        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
+
+        return self._mms_test_mt(ads)
+
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_in_call_volte(self):
         """ Test MO SMS during a MO VoLTE call.
 
@@ -421,6 +694,76 @@ class TelLiveSmsTest(TelephonyBaseTest):
         return True
 
     @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mo_in_call_volte(self):
+        """ Test MO MMS during a MO VoLTE call.
+
+        Make sure PhoneA is in LTE mode (with VoLTE).
+        Make sure PhoneB is able to make/receive call.
+        Call from PhoneA to PhoneB, accept on PhoneB, send MMS 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
+
+        self.log.info("Begin In Call SMS 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 self._mms_test_mo(ads):
+            self.log.error("MMS test fail.")
+            return False
+
+        return True
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mt_in_call_volte(self):
+        """ Test MT MMS during a MO VoLTE call.
+
+        Make sure PhoneA is in LTE mode (with VoLTE).
+        Make sure PhoneB is able to make/receive call.
+        Call from PhoneA to PhoneB, accept on PhoneB, receive MMS 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
+
+        self.log.info("Begin In Call MMS 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 self._mms_test_mt(ads):
+            self.log.error("MMS test fail.")
+            return False
+
+        return True
+
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_in_call_wcdma(self):
         """ Test MO SMS during a MO wcdma call.
 
@@ -471,6 +814,56 @@ class TelLiveSmsTest(TelephonyBaseTest):
         return self._mt_sms_in_3g_call(ads)
 
     @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mo_in_call_wcdma(self):
+        """ Test MO MMS during a MO wcdma call.
+
+        Make sure PhoneA is in wcdma mode.
+        Make sure PhoneB is able to make/receive call.
+        Call from PhoneA to PhoneB, accept on PhoneB, send MMS 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 MMS test.")
+            return False
+
+        tasks = [(phone_setup_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 self._mo_mms_in_3g_call(ads)
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mt_in_call_wcdma(self):
+        """ Test MT MMS during a MO wcdma call.
+
+        Make sure PhoneA is in wcdma mode.
+        Make sure PhoneB is able to make/receive call.
+        Call from PhoneA to PhoneB, accept on PhoneB, receive MMS 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 MMS test.")
+            return False
+
+        tasks = [(phone_setup_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 self._mt_mms_in_3g_call(ads)
+
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_in_call_csfb(self):
         """ Test MO SMS during a MO csfb wcdma/gsm call.
 
@@ -549,6 +942,84 @@ class TelLiveSmsTest(TelephonyBaseTest):
         return True
 
     @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mo_in_call_csfb(self):
+        """ Test MO MMS during a MO csfb wcdma/gsm call.
+
+        Make sure PhoneA is in LTE mode (no VoLTE).
+        Make sure PhoneB is able to make/receive call.
+        Call from PhoneA to PhoneB, accept on PhoneB, send MMS 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 csfb wcdma SMS test.")
+            return False
+
+        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
+
+        self.log.info("Begin In Call MMS 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 self._mms_test_mo(ads):
+            self.log.error("MMS test fail.")
+            return False
+
+        return True
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mt_in_call_csfb(self):
+        """ Test MT MMS during a MO csfb wcdma/gsm call.
+
+        Make sure PhoneA is in LTE mode (no VoLTE).
+        Make sure PhoneB is able to make/receive call.
+        Call from PhoneA to PhoneB, accept on PhoneB, receive receive 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 csfb wcdma MMS test.")
+            return False
+
+        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
+
+        self.log.info("Begin In Call MMS 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 self._mms_test_mt(ads):
+            self.log.error("MMS test fail.")
+            return False
+
+        return True
+
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_in_call_1x(self):
         """ Test MO SMS during a MO 1x call.
 
@@ -627,6 +1098,84 @@ class TelLiveSmsTest(TelephonyBaseTest):
         return True
 
     @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mo_in_call_1x(self):
+        """ Test MO MMS during a MO 1x call.
+
+        Make sure PhoneA is in 1x mode.
+        Make sure PhoneB is able to make/receive call.
+        Call from PhoneA to PhoneB, accept on PhoneB, send MMS on PhoneA.
+
+        Returns:
+            True if pass; False if fail.
+        """
+        ads = self.android_devices
+        # Make sure PhoneA is CDMA phone before proceed.
+        if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_CDMA):
+            self.log.error("Not CDMA phone, abort this 1x MMS test.")
+            return False
+
+        tasks = [(phone_setup_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
+
+        self.log.info("Begin In Call MMS Test.")
+        if not call_setup_teardown(
+                self.log,
+                ads[0],
+                ads[1],
+                ad_hangup=None,
+                verify_caller_func=is_phone_in_call_1x,
+                verify_callee_func=None):
+            return False
+
+        if not self._mms_test_mo(ads):
+            self.log.error("MMS test fail.")
+            return False
+
+        return True
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mt_in_call_1x(self):
+        """ Test MT MMS during a MO 1x call.
+
+        Make sure PhoneA is in 1x mode.
+        Make sure PhoneB is able to make/receive call.
+        Call from PhoneA to PhoneB, accept on PhoneB, receive MMS on PhoneA.
+
+        Returns:
+            True if pass; False if fail.
+        """
+        ads = self.android_devices
+        # Make sure PhoneA is CDMA phone before proceed.
+        if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_CDMA):
+            self.log.error("Not CDMA phone, abort this 1x MMS test.")
+            return False
+
+        tasks = [(phone_setup_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
+
+        self.log.info("Begin In Call MMS Test.")
+        if not call_setup_teardown(
+                self.log,
+                ads[0],
+                ads[1],
+                ad_hangup=None,
+                verify_caller_func=is_phone_in_call_1x,
+                verify_callee_func=None):
+            return False
+
+        if not self._mms_test_mt(ads):
+            self.log.error("MMS test fail.")
+            return False
+
+        return True
+
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_in_call_csfb_1x(self):
         """ Test MO SMS during a MO csfb 1x call.
 
@@ -705,6 +1254,84 @@ class TelLiveSmsTest(TelephonyBaseTest):
         return True
 
     @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mo_in_call_csfb_1x(self):
+        """ Test MO MMS during a MO csfb 1x call.
+
+        Make sure PhoneA is in LTE mode (no VoLTE).
+        Make sure PhoneB is able to make/receive call.
+        Call from PhoneA to PhoneB, accept on PhoneB, send MMS on PhoneA.
+
+        Returns:
+            True if pass; False if fail.
+        """
+        ads = self.android_devices
+        # Make sure PhoneA is CDMA phone before proceed.
+        if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_CDMA):
+            self.log.error("Not CDMA phone, abort this csfb 1x SMS test.")
+            return False
+
+        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
+
+        self.log.info("Begin In Call MMS Test.")
+        if not call_setup_teardown(
+                self.log,
+                ads[0],
+                ads[1],
+                ad_hangup=None,
+                verify_caller_func=is_phone_in_call_1x,
+                verify_callee_func=None):
+            return False
+
+        if not self._mms_test_mo(ads):
+            self.log.error("MMS test fail.")
+            return False
+
+        return True
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mt_in_call_csfb_1x(self):
+        """ Test MT MMS during a MO csfb 1x call.
+
+        Make sure PhoneA is in LTE mode (no VoLTE).
+        Make sure PhoneB is able to make/receive call.
+        Call from PhoneA to PhoneB, accept on PhoneB, receive MMS on PhoneA.
+
+        Returns:
+            True if pass; False if fail.
+        """
+        ads = self.android_devices
+        # Make sure PhoneA is CDMA phone before proceed.
+        if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_CDMA):
+            self.log.error("Not CDMA phone, abort this csfb 1x MMS test.")
+            return False
+
+        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
+
+        self.log.info("Begin In Call MMS Test.")
+        if not call_setup_teardown(
+                self.log,
+                ads[0],
+                ads[1],
+                ad_hangup=None,
+                verify_caller_func=is_phone_in_call_1x,
+                verify_callee_func=None):
+            return False
+
+        if not self._mms_test_mt(ads):
+            self.log.error("MMS test fail.")
+            return False
+
+        return True
+
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_iwlan(self):
         """ Test MO SMS, Phone in APM, WiFi connected, WFC WiFi Preferred mode.
 
@@ -755,6 +1382,56 @@ class TelLiveSmsTest(TelephonyBaseTest):
         return self._sms_test_mt(ads)
 
     @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mo_iwlan(self):
+        """ Test MO MMS, Phone in APM, WiFi connected, WFC WiFi Preferred mode.
+
+        Make sure PhoneA APM, WiFi connected, WFC WiFi preferred mode.
+        Make sure PhoneA report iwlan as data rat.
+        Make sure PhoneB is able to make/receive call/sms.
+        Send MMS 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
+
+        return self._mms_test_mo(ads)
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mt_iwlan(self):
+        """ Test MT MMS, Phone in APM, WiFi connected, WFC WiFi Preferred mode.
+
+        Make sure PhoneA APM, WiFi connected, WFC WiFi preferred mode.
+        Make sure PhoneA report iwlan as data rat.
+        Make sure PhoneB is able to make/receive call/sms.
+        Receive MMS 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
+
+        return self._mms_test_mt(ads)
+
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_apm_wifi_wfc_off(self):
         """ Test MO SMS, Phone in APM, WiFi connected, WFC off.
 
@@ -801,6 +1478,52 @@ class TelLiveSmsTest(TelephonyBaseTest):
         return self._sms_test_mt(ads)
 
     @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mo_apm_wifi_wfc_off(self):
+        """ Test MO MMS, Phone in APM, WiFi connected, WFC off.
+
+        Make sure PhoneA APM, WiFi connected, WFC off.
+        Make sure PhoneB is able to make/receive call/sms.
+        Send MMS on PhoneA.
+
+        Returns:
+            True if pass; False if fail.
+        """
+
+        ads = self.android_devices
+        phone_setup_voice_general(self.log, ads[0])
+        tasks = [(ensure_wifi_connected, (
+            self.log, ads[0], 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 self._mms_test_mo(ads)
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mt_apm_wifi_wfc_off(self):
+        """ Test MT MMS, Phone in APM, WiFi connected, WFC off.
+
+        Make sure PhoneA APM, WiFi connected, WFC off.
+        Make sure PhoneB is able to make/receive call/sms.
+        Receive MMS on PhoneA.
+
+        Returns:
+            True if pass; False if fail.
+        """
+
+        ads = self.android_devices
+        phone_setup_voice_general(self.log, ads[0])
+        tasks = [(ensure_wifi_connected, (
+            self.log, ads[0], 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 self._mms_test_mt(ads)
+
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_in_call_iwlan(self):
         """ Test MO SMS, Phone in APM, WiFi connected, WFC WiFi Preferred mode.
 
@@ -873,6 +1596,78 @@ class TelLiveSmsTest(TelephonyBaseTest):
         return self._sms_test_mt(ads)
 
     @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mo_in_call_iwlan(self):
+        """ Test MO MMS, Phone in APM, WiFi connected, WFC WiFi Preferred mode.
+
+        Make sure PhoneA APM, WiFi connected, WFC WiFi preferred mode.
+        Make sure PhoneA report iwlan as data rat.
+        Make sure PhoneB is able to make/receive call/sms.
+        Call from PhoneA to PhoneB, accept on PhoneB.
+        Send MMS 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
+
+        self.log.info("Begin In Call MMS 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
+
+        return self._mms_test_mo(ads)
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mt_in_call_iwlan(self):
+        """ Test MT MMS, Phone in APM, WiFi connected, WFC WiFi Preferred mode.
+
+        Make sure PhoneA APM, WiFi connected, WFC WiFi preferred mode.
+        Make sure PhoneA report iwlan as data rat.
+        Make sure PhoneB is able to make/receive call/sms.
+        Call from PhoneA to PhoneB, accept on PhoneB.
+        Receive MMS 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
+
+        self.log.info("Begin In Call MMS 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
+
+        return self._mms_test_mt(ads)
+
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_in_call_vt(self):
         """ Test MO SMS, Phone in ongoing VT call.
 
@@ -937,60 +1732,68 @@ class TelLiveSmsTest(TelephonyBaseTest):
         return self._sms_test_mt(ads)
 
     @TelephonyBaseTest.tel_test_wrap
-    def test_mms_mo_4g(self):
-        """Test MMS text function between two phone. Phones in LTE network.
+    def test_mms_mo_in_call_vt(self):
+        """ Test MO MMS, Phone in ongoing VT call.
 
-        Airplane mode is off.
-        Send SMS from PhoneA to PhoneB.
-        Verify received message on PhoneB is correct.
+        Make sure PhoneA and PhoneB in LTE and can make VT call.
+        Make Video Call from PhoneA to PhoneB, accept on PhoneB as Video Call.
+        Send MMS on PhoneA.
 
         Returns:
-            True if success.
-            False if failed.
+            True if pass; False if fail.
         """
-
-        self.log.error("Test Case is non-functional: b/21569494")
-        return False
-
         ads = self.android_devices
 
-        tasks = [(phone_setup_csfb, (self.log, ads[0])),
-                 (phone_setup_voice_general, (self.log, ads[1]))]
+        tasks = [(phone_setup_video, (self.log, ads[0])), (phone_setup_video,
+                                                           (self.log, ads[1]))]
         if not multithread_func(self.log, tasks):
             self.log.error("Phone Failed to Set Up Properly.")
             return False
 
-        return mms_send_receive_verify(
-            self.log, ads[0], ads[1],
-            [("Test Message", "Basic Message Body", None)])
+        if not video_call_setup_teardown(
+                self.log,
+                ads[0],
+                ads[1],
+                None,
+                video_state=VT_STATE_BIDIRECTIONAL,
+                verify_caller_func=is_phone_in_call_video_bidirectional,
+                verify_callee_func=is_phone_in_call_video_bidirectional):
+            self.log.error("Failed to setup a call")
+            return False
+
+        return self._mms_test_mo(ads)
 
     @TelephonyBaseTest.tel_test_wrap
-    def test_mms_mt_4g(self):
-        """Test MMS text function between two phone. Phones in LTE network.
+    def test_mms_mt_in_call_vt(self):
+        """ Test MT MMS, Phone in ongoing VT call.
 
-        Airplane mode is off.
-        Send SMS from PhoneB to PhoneA.
-        Verify received message on PhoneA is correct.
+        Make sure PhoneA and PhoneB in LTE and can make VT call.
+        Make Video Call from PhoneA to PhoneB, accept on PhoneB as Video Call.
+        Receive MMS on PhoneA.
 
         Returns:
-            True if success.
-            False if failed.
+            True if pass; False if fail.
         """
-
-        self.log.error("Test Case is non-functional: b/21569494")
-        return False
-
         ads = self.android_devices
 
-        tasks = [(phone_setup_csfb, (self.log, ads[0])),
-                 (phone_setup_voice_general, (self.log, ads[1]))]
+        tasks = [(phone_setup_video, (self.log, ads[0])), (phone_setup_video,
+                                                           (self.log, ads[1]))]
         if not multithread_func(self.log, tasks):
             self.log.error("Phone Failed to Set Up Properly.")
             return False
 
-        return mms_send_receive_verify(
-            self.log, ads[1], ads[0],
-            [("Test Message", "Basic Message Body", None)])
+        if not video_call_setup_teardown(
+                self.log,
+                ads[0],
+                ads[1],
+                None,
+                video_state=VT_STATE_BIDIRECTIONAL,
+                verify_caller_func=is_phone_in_call_video_bidirectional,
+                verify_callee_func=is_phone_in_call_video_bidirectional):
+            self.log.error("Failed to setup a call")
+            return False
+
+        return self._mms_test_mt(ads)
 
     @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_in_call_gsm(self):
@@ -1069,3 +1872,81 @@ class TelLiveSmsTest(TelephonyBaseTest):
             return False
 
         return True
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mo_in_call_gsm(self):
+        """ Test MO MMS during a MO gsm call.
+
+        Make sure PhoneA is in gsm mode.
+        Make sure PhoneB is able to make/receive call.
+        Call from PhoneA to PhoneB, accept on PhoneB, send MMS 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 gsm MMS 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
+
+        self.log.info("Begin In Call MMS 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 self._mms_test_mo(ads):
+            self.log.error("MMS test fail.")
+            return False
+
+        return True
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_mms_mt_in_call_gsm(self):
+        """ Test MT MMS during a MO gsm call.
+
+        Make sure PhoneA is in gsm mode.
+        Make sure PhoneB is able to make/receive call.
+        Call from PhoneA to PhoneB, accept on PhoneB, receive MMS 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 gsm MMS 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
+
+        self.log.info("Begin In Call MMS 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 self._mms_test_mt(ads):
+            self.log.error("MMS test fail.")
+            return False
+
+        return True