diff --git a/acts/framework/acts/base_test.py b/acts/framework/acts/base_test.py
index 2e70b03..d06aec4 100755
--- a/acts/framework/acts/base_test.py
+++ b/acts/framework/acts/base_test.py
@@ -267,6 +267,28 @@
             begin_time: Logline format timestamp taken when the test started.
         """
 
+    def _on_blocked(self, record):
+        """Proxy function to guarantee the base implementation of on_blocked
+        is called.
+
+        Args:
+            record: The records.TestResultRecord object for the blocked test
+                    case.
+        """
+        test_name = record.test_name
+        begin_time = logger.epoch_to_log_line_timestamp(record.begin_time)
+        self.log.info(RESULT_LINE_TEMPLATE, test_name, record.result)
+        self.log.info("Reason to block: %s", record.details)
+        self.on_blocked(test_name, begin_time)
+
+    def on_blocked(self, test_name, begin_time):
+        """A function that is executed upon a test begin skipped.
+
+        Args:
+            test_name: Name of the test that triggered this function.
+            begin_time: Logline format timestamp taken when the test started.
+        """
+
     def _on_exception(self, record):
         """Proxy function to guarantee the base implementation of on_exception
         is called.
@@ -374,6 +396,9 @@
             # This is a trigger test for generated tests, suppress reporting.
             is_generate_trigger = True
             self.results.requested.remove(test_name)
+        except signals.TestBlocked as e:
+            tr_record.test_blocked(e)
+            self._exec_procedure_func(self._on_blocked, tr_record)
         except Exception as e:
             self.log.error(traceback.format_exc())
             # Exception happened during test.
@@ -518,16 +543,51 @@
         """
         test_funcs = []
         for test_name in test_names:
-            if not test_name.startswith("test_"):
-                raise Error(("Test case name %s does not follow naming "
-                             "convention test_*, abort.") % test_name)
-            try:
-                test_funcs.append((test_name, getattr(self, test_name)))
-            except AttributeError:
-                raise Error("%s does not have test case %s." % (self.TAG,
-                                                                test_name))
+            test_funcs.append(self._get_test_func(test_name))
+
         return test_funcs
 
+    def _get_test_func(self, test_name):
+        """Obtain the actual function of test cases based on the test name.
+
+        Args:
+            test_name: String, The name of the test.
+
+        Returns:
+            A tuples of (string, function). String is the test case
+            name, function is the actual test case function.
+
+        Raises:
+            Error is raised if the test name does not follow
+            naming convention "test_*". This can only be caused by user input
+            here.
+        """
+        if not test_name.startswith("test_"):
+            raise Error(("Test case name %s does not follow naming "
+                         "convention test_*, abort.") % test_name)
+
+        try:
+            return test_name, getattr(self, test_name)
+        except:
+            raise Error("%s does not have test case %s." % (self.TAG,
+                                                            test_name))
+
+    def _block_all_test_cases(self, tests):
+        """
+        Block all passed in test cases.
+        Args:
+            tests: The tests to block.
+        """
+        for test_name, test_func in tests:
+            signal = signals.TestBlocked("Failed class setup")
+            record = records.TestResultRecord(test_name, self.TAG)
+            record.test_begin()
+            if hasattr(test_func, 'gather'):
+                signal.extras = test_func.gather()
+            record.test_blocked(signal)
+            self.results.add_record(record)
+            self._on_blocked(record)
+
     def run(self, test_names=None):
         """Runs test cases within a test class by the order they appear in the
         execution list.
@@ -560,24 +620,16 @@
         self.results.requested = test_names
         tests = self._get_test_funcs(test_names)
         # A TestResultRecord used for when setup_class fails.
-        class_record = records.TestResultRecord("setup_class", self.TAG)
-        class_record.test_begin()
         # Setup for the class.
         try:
             if self._setup_class() is False:
-                asserts.fail("Failed to setup %s." % self.TAG)
-        except signals.TestSkipClass as e:
-            class_record.test_skip(e)
-            self._exec_procedure_func(self._on_skip, class_record)
-            self._exec_func(self.teardown_class)
-            self.results.skip_class(class_record)
-            return self.results
+                self.log.error("Failed to setup %s.", self.TAG)
+                self._block_all_test_cases(tests)
+                return self.results
         except Exception as e:
             self.log.exception("Failed to setup %s.", self.TAG)
-            class_record.test_fail(e)
-            self._exec_procedure_func(self._on_fail, class_record)
             self._exec_func(self.teardown_class)
-            self.results.fail_class(class_record)
+            self._block_all_test_cases(tests)
             return self.results
         # Run tests in order.
         try:
diff --git a/acts/framework/acts/controllers/android_device.py b/acts/framework/acts/controllers/android_device.py
index 9109c62..e202514 100755
--- a/acts/framework/acts/controllers/android_device.py
+++ b/acts/framework/acts/controllers/android_device.py
@@ -20,6 +20,7 @@
 import logging
 import os
 import re
+import socket
 import time
 
 from acts import logger as acts_logger
@@ -732,8 +733,8 @@
         if cont_logcat_file:
             if self.droid:
                 self.droid.logI('Restarting logcat')
-            self.log.warning(
-                'Restarting logcat on file %s' % self.adb_logcat_file_path)
+            self.log.warning('Restarting logcat on file %s' %
+                             self.adb_logcat_file_path)
             logcat_file_path = self.adb_logcat_file_path
         else:
             f_name = "adblog,{},{}.txt".format(self.model, self.serial)
@@ -960,8 +961,8 @@
                 # process, which is normal. Ignoring these errors.
                 pass
             time.sleep(5)
-        raise AndroidDeviceError(
-            "Device %s booting process timed out." % self.serial)
+        raise AndroidDeviceError("Device %s booting process timed out." %
+                                 self.serial)
 
     def reboot(self):
         """Reboots the device.
@@ -1000,6 +1001,52 @@
             self.start_adb_logcat()
         return droid, ed
 
+    def get_ipv4_address(self, interface='wlan0', timeout=5):
+        for timer in range(0, timeout):
+            try:
+                ip_string = self.adb.shell('ifconfig %s|grep inet' % interface)
+                break
+            except adb.AdbError as e:
+                if timer + 1 == timeout:
+                    self.log.warning('Unable to find IP address for %s.' %
+                                     interface)
+                    return None
+                else:
+                    time.sleep(1)
+        result = re.search('addr:(.*) Bcast', ip_string)
+        if result != None:
+            ip_address = result.group(1)
+            try:
+                socket.inet_aton(ip_address)
+                return ip_address
+            except socket.error:
+                return None
+        else:
+            return None
+
+    def get_ipv4_gateway(self, timeout=5):
+        for timer in range(0, timeout):
+            try:
+                gateway_string = self.adb.shell(
+                    'dumpsys wifi | grep mDhcpResults')
+                break
+            except adb.AdbError as e:
+                if timer + 1 == timeout:
+                    self.log.warning('Unable to find gateway')
+                    return None
+                else:
+                    time.sleep(1)
+        result = re.search('Gateway (.*) DNS servers', gateway_string)
+        if result != None:
+            ipv4_gateway = result.group(1)
+            try:
+                socket.inet_aton(ipv4_gateway)
+                return ipv4_gateway
+            except socket.error:
+                return None
+        else:
+            return None
+
 
 class AndroidDeviceLoggerAdapter(logging.LoggerAdapter):
     def process(self, msg, kwargs):
diff --git a/acts/framework/acts/controllers/ap_lib/hostapd.py b/acts/framework/acts/controllers/ap_lib/hostapd.py
index d39de41..4cd3125 100644
--- a/acts/framework/acts/controllers/ap_lib/hostapd.py
+++ b/acts/framework/acts/controllers/ap_lib/hostapd.py
@@ -14,6 +14,7 @@
 
 import collections
 import itertools
+import logging
 import os
 import time
 
@@ -192,4 +193,9 @@
 
         hostapd_conf = '\n'.join(pairs)
 
+        logging.info('Writing %s' % self._config_file)
+        logging.debug('******************Start*******************')
+        logging.debug('\n%s' % hostapd_conf)
+        logging.debug('*******************End********************')
+
         self._shell.write_file(self._config_file, hostapd_conf)
diff --git a/acts/framework/acts/controllers/ap_lib/hostapd_ap_preset.py b/acts/framework/acts/controllers/ap_lib/hostapd_ap_preset.py
new file mode 100644
index 0000000..a18f0c7
--- /dev/null
+++ b/acts/framework/acts/controllers/ap_lib/hostapd_ap_preset.py
@@ -0,0 +1,127 @@
+#   Copyright 2017 - The Android Open Source Project
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+from acts.controllers.ap_lib import hostapd_config
+from acts.controllers.ap_lib import hostapd_constants
+
+
+def create_ap_preset(profile_name,
+                     channel=None,
+                     frequency=None,
+                     security=None,
+                     ssid=None,
+                     bss_settings=[]):
+    """AP preset config generator.  This a wrapper for hostapd_config but
+       but supplies the default settings for the preset that is selected.
+
+        You may specify channel or frequency, but not both.  Both options
+        are checked for validity (i.e. you can't specify an invalid channel
+        or a frequency that will not be accepted).
+
+    Args:
+        profile_name: The name of the device want the preset for.
+                      Options: whirlwind
+        channel: int, channel number.
+        frequency: int, frequency of channel.
+        security: Security, the secuirty settings to use.
+        ssid: string, The name of the ssid to brodcast.
+        bss_settings: The settings for all bss.
+
+    Returns: A hostapd_config object that can be used by the hostapd object.
+    """
+
+    force_wmm = None
+    force_wmm = None
+    beacon_interval = None
+    dtim_period = None
+    short_preamble = None
+    interface = None
+    mode = None
+    n_capabilities = None
+    ac_capabilities = None
+    if channel:
+        frequency = hostapd_config.get_frequency_for_channel(channel)
+    elif frequency:
+        channel = hostapd_config.get_channel_for_frequency(frequency)
+    else:
+        raise ValueError('Specify either frequency or channel.')
+
+    if (profile_name == 'whirlwind'):
+        force_wmm = True
+        beacon_interval = 100
+        dtim_period = 2
+        short_preamble = True
+        if frequency < 5000:
+            interface = hostapd_constants.WLAN0_STRING
+            mode = hostapd_constants.MODE_11N_MIXED
+            n_capabilities = [
+                hostapd_constants.N_CAPABILITY_LDPC,
+                hostapd_constants.N_CAPABILITY_SGI20,
+                hostapd_constants.N_CAPABILITY_SGI40,
+                hostapd_constants.N_CAPABILITY_TX_STBC,
+                hostapd_constants.N_CAPABILITY_RX_STBC1,
+                hostapd_constants.N_CAPABILITY_DSSS_CCK_40
+            ]
+            config = hostapd_config.HostapdConfig(
+                ssid=ssid,
+                security=security,
+                interface=interface,
+                mode=mode,
+                force_wmm=force_wmm,
+                beacon_interval=beacon_interval,
+                dtim_period=dtim_period,
+                short_preamble=short_preamble,
+                frequency=frequency,
+                n_capabilities=n_capabilities,
+                bss_settings=bss_settings)
+        else:
+            interface = hostapd_constants.WLAN1_STRING
+            mode = hostapd_constants.MODE_11AC_MIXED
+            if hostapd_config.ht40_plus_allowed(channel):
+                extended_channel = hostapd_constants.N_CAPABILITY_HT40_PLUS
+            elif hostapd_config.ht40_minus_allowed(channel):
+                extended_channel = hostapd_constants.N_CAPABILITY_HT40_MINUS
+            n_capabilities = [
+                hostapd_constants.N_CAPABILITY_LDPC, extended_channel,
+                hostapd_constants.N_CAPABILITY_SGI20,
+                hostapd_constants.N_CAPABILITY_SGI40,
+                hostapd_constants.N_CAPABILITY_TX_STBC,
+                hostapd_constants.N_CAPABILITY_RX_STBC1
+            ]
+            ac_capabilities = [
+                hostapd_constants.AC_CAPABILITY_MAX_MPDU_11454,
+                hostapd_constants.AC_CAPABILITY_RXLDPC,
+                hostapd_constants.AC_CAPABILITY_SHORT_GI_80,
+                hostapd_constants.AC_CAPABILITY_TX_STBC_2BY1,
+                hostapd_constants.AC_CAPABILITY_RX_STBC_1,
+                hostapd_constants.AC_CAPABILITY_MAX_A_MPDU_LEN_EXP7,
+                hostapd_constants.AC_CAPABILITY_RX_ANTENNA_PATTERN,
+                hostapd_constants.AC_CAPABILITY_TX_ANTENNA_PATTERN
+            ]
+            config = hostapd_config.HostapdConfig(
+                ssid=ssid,
+                security=security,
+                interface=interface,
+                mode=mode,
+                force_wmm=force_wmm,
+                beacon_interval=beacon_interval,
+                dtim_period=dtim_period,
+                short_preamble=short_preamble,
+                frequency=frequency,
+                n_capabilities=n_capabilities,
+                ac_capabilities=ac_capabilities,
+                bss_settings=bss_settings)
+    else:
+        raise ValueError('Invalid ap model specified (%s)' % profile_name)
+    return config
diff --git a/acts/framework/acts/controllers/ap_lib/hostapd_bss_settings.py b/acts/framework/acts/controllers/ap_lib/hostapd_bss_settings.py
new file mode 100644
index 0000000..8e23a66
--- /dev/null
+++ b/acts/framework/acts/controllers/ap_lib/hostapd_bss_settings.py
@@ -0,0 +1,49 @@
+#   Copyright 2017 - The Android Open Source Project
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+import collections
+
+
+class BssSettings(object):
+    """Settings for a bss.
+
+    Settings for a bss to allow multiple network on a single device.
+
+    Attributes:
+        name: string, The name that this bss will go by.
+        ssid: string, The name of the ssid to brodcast.
+        hidden: bool, If true then the ssid will be hidden.
+        security: Security, The security settings to use.
+    """
+
+    def __init__(self, name, ssid, hidden=False, security=None):
+        self.name = name
+        self.ssid = ssid
+        self.hidden = hidden
+        self.security = security
+
+    def generate_dict(self):
+        """Returns: A dictionary of bss settings."""
+        settings = collections.OrderedDict()
+        settings['bss'] = self.name
+        if self.ssid:
+            settings['ssid'] = self.ssid
+            settings['ignore_broadcast_ssid'] = 1 if self.hidden else 0
+
+        if self.security:
+            security_settings = self.security.generate_dict()
+            for k, v in security_settings.items():
+                settings[k] = v
+
+        return settings
diff --git a/acts/framework/acts/controllers/ap_lib/hostapd_config.py b/acts/framework/acts/controllers/ap_lib/hostapd_config.py
index d33d028..4c70bd7 100644
--- a/acts/framework/acts/controllers/ap_lib/hostapd_config.py
+++ b/acts/framework/acts/controllers/ap_lib/hostapd_config.py
@@ -18,102 +18,52 @@
 import collections
 import itertools
 
-
-class WpaSecurityMode(enum.IntEnum):
-    WPA1 = 1
-    WPA2 = 2
-    MIXED = 3
+from acts.controllers.ap_lib import hostapd_constants
 
 
-class Security(object):
-    """Base class for security settings."""
+def ht40_plus_allowed(channel):
+    """Returns: True iff HT40+ is enabled for this configuration."""
+    channel_supported = (channel in hostapd_constants.HT40_ALLOW_MAP[
+        hostapd_constants.N_CAPABILITY_HT40_PLUS_CHANNELS])
+    return (channel_supported)
 
 
-class WpaPskSecurity(Security):
-    """Security info that uses WPA encryption with a predefined psk.
+def ht40_minus_allowed(channel):
+    """Returns: True iff HT40- is enabled for this configuration."""
+    channel_supported = (channel in hostapd_constants.HT40_ALLOW_MAP[
+        hostapd_constants.N_CAPABILITY_HT40_MINUS_CHANNELS])
+    return (channel_supported)
 
-    Attributes:
-        mode: WpaSecurityMode, The type of WPA to use.
-        psk: A predefined psk for authentication.
+
+def get_frequency_for_channel(channel):
+    """The frequency associated with a given channel number.
+
+    Args:
+        value: int channel number.
+
+    Returns:
+        int, frequency in MHz associated with the channel.
+
     """
-
-    def __init__(self, mode, psk):
-        """
-        Args:
-            mode: WpaSecurityMode, The type of WPA to use.
-            psk: A predefined psk for authentication.
-        """
-        self.mode = mode
-        self.psk = psk
-
-    def generate_dict(self):
-        """Returns: an ordered dictionary of settings"""
-        settings = collections.OrderedDict()
-        settings['wpa'] = self.mode
-        settings['wpa_psk'] = self.psk
-
-        return settings
+    for frequency, channel_iter in \
+        hostapd_constants.CHANNEL_MAP.items():
+        if channel == channel_iter:
+            return frequency
+    else:
+        raise ValueError('Unknown channel value: %r.' % channel)
 
 
-class WpaPassphraseSecurity(Security):
-    """Security settings that uses a WPA passpharse.
+def get_channel_for_frequency(frequency):
+    """The channel number associated with a given frequency.
 
-    Attributes:
-        name: SSID brodcast name.
-        mode: WpaSecurityMode, The type of WPA to use.
-        passphrase: The passphrase to use for authentication.
+    Args:
+        value: int frequency in MHz.
+
+    Returns:
+        int, frequency associated with the channel.
+
     """
-
-    def __init__(self, mode, passphrase):
-        """
-        Args:
-            mode: The type of WPA to use (1, 2, or 3).
-            psk: A passphrase to use for authentication
-        """
-        self.mode = mode
-        self.passphrase = passphrase
-
-    def generate_dict(self):
-        """Returns: An ordered dictionary of settings."""
-        settings = collections.OrderedDict()
-        settings['wpa'] = self.mode
-        settings['wpa_passphrase'] = self.passphrase
-
-        return settings
-
-
-class BssSettings(object):
-    """Settings for a bss.
-
-    Settings for a bss to allow multiple network on a single device.
-
-    Attributes:
-        name: string, The name that this bss will go by.
-        ssid: string, The name of the ssid to brodcast.
-        hidden: bool, If true then the ssid will be hidden.
-        security: Security, The security settings to use.
-    """
-
-    def __init__(self, name, ssid=None, hidden=False, security=None):
-        self.name = name
-        self.ssid = ssid
-        self.hidden = hidden
-        self.security = security
-
-    def generate_dict(self):
-        """Returns: A dictionary of bss settings."""
-        settings = collections.OrderedDict()
-        settings['bss'] = self.name
-        if self.ssid:
-            settings['ssid'] = self.ssid
-            settings['ignore_broadcast_ssid'] = 1 if self.hidden else 0
-
-        if self.security:
-            security_settings = self.security.generate_dict()
-            for k, v in security_settings.items():
-                settings[k] = v
-
-        return settings
+    return hostapd_constants.CHANNEL_MAP[frequency]
 
 
 class HostapdConfig(object):
@@ -122,207 +72,21 @@
     All the settings for a router that are not part of an ssid.
     """
 
-    # A mapping of frequency to channel number.  This includes some
-    # frequencies used outside the US.
-    CHANNEL_MAP = {
-        2412: 1,
-        2417: 2,
-        2422: 3,
-        2427: 4,
-        2432: 5,
-        2437: 6,
-        2442: 7,
-        2447: 8,
-        2452: 9,
-        2457: 10,
-        2462: 11,
-        # 12, 13 are only legitimate outside the US.
-        2467: 12,
-        2472: 13,
-        # 14 is for Japan, DSSS and CCK only.
-        2484: 14,
-        # 34 valid in Japan.
-        5170: 34,
-        # 36-116 valid in the US, except 38, 42, and 46, which have
-        # mixed international support.
-        5180: 36,
-        5190: 38,
-        5200: 40,
-        5210: 42,
-        5220: 44,
-        5230: 46,
-        5240: 48,
-        5260: 52,
-        5280: 56,
-        5300: 60,
-        5320: 64,
-        5500: 100,
-        5520: 104,
-        5540: 108,
-        5560: 112,
-        5580: 116,
-        # 120, 124, 128 valid in Europe/Japan.
-        5600: 120,
-        5620: 124,
-        5640: 128,
-        # 132+ valid in US.
-        5660: 132,
-        5680: 136,
-        5700: 140,
-        # 144 is supported by a subset of WiFi chips
-        # (e.g. bcm4354, but not ath9k).
-        5720: 144,
-        5745: 149,
-        5765: 153,
-        5785: 157,
-        5805: 161,
-        5825: 165
-    }
-
-    MODE_11A = 'a'
-    MODE_11B = 'b'
-    MODE_11G = 'g'
-    MODE_11N_MIXED = 'n-mixed'
-    MODE_11N_PURE = 'n-only'
-    MODE_11AC_MIXED = 'ac-mixed'
-    MODE_11AC_PURE = 'ac-only'
-
-    N_CAPABILITY_HT20 = object()
-    N_CAPABILITY_HT40 = object()
-    N_CAPABILITY_HT40_PLUS = object()
-    N_CAPABILITY_HT40_MINUS = object()
-    N_CAPABILITY_GREENFIELD = object()
-    N_CAPABILITY_SGI20 = object()
-    N_CAPABILITY_SGI40 = object()
-    ALL_N_CAPABILITIES = [N_CAPABILITY_HT20,
-                          N_CAPABILITY_HT40,
-                          N_CAPABILITY_HT40_PLUS,
-                          N_CAPABILITY_HT40_MINUS,
-                          N_CAPABILITY_GREENFIELD,
-                          N_CAPABILITY_SGI20,
-                          N_CAPABILITY_SGI40] # yapf: disable
-
-    AC_CAPABILITY_VHT160 = object()
-    AC_CAPABILITY_VHT160_80PLUS80 = object()
-    AC_CAPABILITY_RXLDPC = object()
-    AC_CAPABILITY_SHORT_GI_80 = object()
-    AC_CAPABILITY_SHORT_GI_160 = object()
-    AC_CAPABILITY_TX_STBC_2BY1 = object()
-    AC_CAPABILITY_RX_STBC_1 = object()
-    AC_CAPABILITY_RX_STBC_12 = object()
-    AC_CAPABILITY_RX_STBC_123 = object()
-    AC_CAPABILITY_RX_STBC_1234 = object()
-    AC_CAPABILITY_SU_BEAMFORMER = object()
-    AC_CAPABILITY_SU_BEAMFORMEE = object()
-    AC_CAPABILITY_BF_ANTENNA_2 = object()
-    AC_CAPABILITY_SOUNDING_DIMENSION_2 = object()
-    AC_CAPABILITY_MU_BEAMFORMER = object()
-    AC_CAPABILITY_MU_BEAMFORMEE = object()
-    AC_CAPABILITY_VHT_TXOP_PS = object()
-    AC_CAPABILITY_HTC_VHT = object()
-    AC_CAPABILITY_MAX_A_MPDU_LEN_EXP0 = object()
-    AC_CAPABILITY_MAX_A_MPDU_LEN_EXP1 = object()
-    AC_CAPABILITY_MAX_A_MPDU_LEN_EXP2 = object()
-    AC_CAPABILITY_MAX_A_MPDU_LEN_EXP3 = object()
-    AC_CAPABILITY_MAX_A_MPDU_LEN_EXP4 = object()
-    AC_CAPABILITY_MAX_A_MPDU_LEN_EXP5 = object()
-    AC_CAPABILITY_MAX_A_MPDU_LEN_EXP6 = object()
-    AC_CAPABILITY_MAX_A_MPDU_LEN_EXP7 = object()
-    AC_CAPABILITY_VHT_LINK_ADAPT2 = object()
-    AC_CAPABILITY_VHT_LINK_ADAPT3 = object()
-    AC_CAPABILITY_RX_ANTENNA_PATTERN = object()
-    AC_CAPABILITY_TX_ANTENNA_PATTERN = object()
-    AC_CAPABILITIES_MAPPING = {
-        AC_CAPABILITY_VHT160: '[VHT160]',
-        AC_CAPABILITY_VHT160_80PLUS80: '[VHT160_80PLUS80]',
-        AC_CAPABILITY_RXLDPC: '[RXLDPC]',
-        AC_CAPABILITY_SHORT_GI_80: '[SHORT_GI_80]',
-        AC_CAPABILITY_SHORT_GI_160: '[SHORT_GI_160]',
-        AC_CAPABILITY_TX_STBC_2BY1: '[TX_STBC_2BY1',
-        AC_CAPABILITY_RX_STBC_1: '[RX_STBC_1]',
-        AC_CAPABILITY_RX_STBC_12: '[RX_STBC_12]',
-        AC_CAPABILITY_RX_STBC_123: '[RX_STBC_123]',
-        AC_CAPABILITY_RX_STBC_1234: '[RX_STBC_1234]',
-        AC_CAPABILITY_SU_BEAMFORMER: '[SU_BEAMFORMER]',
-        AC_CAPABILITY_SU_BEAMFORMEE: '[SU_BEAMFORMEE]',
-        AC_CAPABILITY_BF_ANTENNA_2: '[BF_ANTENNA_2]',
-        AC_CAPABILITY_SOUNDING_DIMENSION_2: '[SOUNDING_DIMENSION_2]',
-        AC_CAPABILITY_MU_BEAMFORMER: '[MU_BEAMFORMER]',
-        AC_CAPABILITY_MU_BEAMFORMEE: '[MU_BEAMFORMEE]',
-        AC_CAPABILITY_VHT_TXOP_PS: '[VHT_TXOP_PS]',
-        AC_CAPABILITY_HTC_VHT: '[HTC_VHT]',
-        AC_CAPABILITY_MAX_A_MPDU_LEN_EXP0: '[MAX_A_MPDU_LEN_EXP0]',
-        AC_CAPABILITY_MAX_A_MPDU_LEN_EXP1: '[MAX_A_MPDU_LEN_EXP1]',
-        AC_CAPABILITY_MAX_A_MPDU_LEN_EXP2: '[MAX_A_MPDU_LEN_EXP2]',
-        AC_CAPABILITY_MAX_A_MPDU_LEN_EXP3: '[MAX_A_MPDU_LEN_EXP3]',
-        AC_CAPABILITY_MAX_A_MPDU_LEN_EXP4: '[MAX_A_MPDU_LEN_EXP4]',
-        AC_CAPABILITY_MAX_A_MPDU_LEN_EXP5: '[MAX_A_MPDU_LEN_EXP5]',
-        AC_CAPABILITY_MAX_A_MPDU_LEN_EXP6: '[MAX_A_MPDU_LEN_EXP6]',
-        AC_CAPABILITY_MAX_A_MPDU_LEN_EXP7: '[MAX_A_MPDU_LEN_EXP7]',
-        AC_CAPABILITY_VHT_LINK_ADAPT2: '[VHT_LINK_ADAPT2]',
-        AC_CAPABILITY_VHT_LINK_ADAPT3: '[VHT_LINK_ADAPT3]',
-        AC_CAPABILITY_RX_ANTENNA_PATTERN: '[RX_ANTENNA_PATTERN]',
-        AC_CAPABILITY_TX_ANTENNA_PATTERN: '[TX_ANTENNA_PATTERN]'
-    }
-
-    VHT_CHANNEL_WIDTH_40 = object()
-    VHT_CHANNEL_WIDTH_80 = object()
-    VHT_CHANNEL_WIDTH_160 = object()
-    VHT_CHANNEL_WIDTH_80_80 = object()
-
-    # This is a loose merging of the rules for US and EU regulatory
-    # domains as taken from IEEE Std 802.11-2012 Appendix E.  For instance,
-    # we tolerate HT40 in channels 149-161 (not allowed in EU), but also
-    # tolerate HT40+ on channel 7 (not allowed in the US).  We take the loose
-    # definition so that we don't prohibit testing in either domain.
-    HT40_ALLOW_MAP = {
-        N_CAPABILITY_HT40_MINUS: tuple(
-            itertools.chain(
-                range(6, 14), range(40, 65, 8), range(104, 137, 8), [153, 161
-                                                                     ])),
-        N_CAPABILITY_HT40_PLUS: tuple(
-            itertools.chain(
-                range(1, 8), range(36, 61, 8), range(100, 133, 8), [149, 157]))
-    }
-
-    PMF_SUPPORT_DISABLED = 0
-    PMF_SUPPORT_ENABLED = 1
-    PMF_SUPPORT_REQUIRED = 2
-    PMF_SUPPORT_VALUES = (PMF_SUPPORT_DISABLED, PMF_SUPPORT_ENABLED,
-                          PMF_SUPPORT_REQUIRED)
-
-    DRIVER_NAME = 'nl80211'
-
-    @staticmethod
-    def get_channel_for_frequency(frequency):
-        """The channel number associated with a given frequency.
-
-        Args:
-            value: int frequency in MHz.
-
-        Returns:
-            int, frequency associated with the channel.
-
+    def _get_11ac_center_channel_from_channel(self, channel):
+        """Returns the center channel of the selected channel band based
+           on the channel and channel bandwidth provided.
         """
-        return HostapdConfig.CHANNEL_MAP[frequency]
+        channel = int(channel)
+        center_channel_delta = hostapd_constants.CENTER_CHANNEL_MAP[
+            self._vht_oper_chwidth]['delta']
 
-    @staticmethod
-    def get_frequency_for_channel(channel):
-        """The frequency associated with a given channel number.
-
-        Args:
-            value: int channel number.
-
-        Returns:
-            int, frequency in MHz associated with the channel.
-
-        """
-        for frequency, channel_iter in \
-            HostapdConfig.CHANNEL_MAP.items():
-            if channel == channel_iter:
-                return frequency
-        else:
-            raise ValueError('Unknown channel value: %r.' % channel)
+        for channel_map in hostapd_constants.CENTER_CHANNEL_MAP[
+                self._vht_oper_chwidth]['channels']:
+            lower_channel_bound, upper_channel_bound = channel_map
+            if lower_channel_bound <= channel <= upper_channel_bound:
+                return lower_channel_bound + center_channel_delta
+        raise ValueError('Invalid channel for {channel_width}.'.format(
+            channel_width=self._vht_oper_chwidth))
 
     @property
     def _get_default_config(self):
@@ -333,41 +97,17 @@
             # default RTS and frag threshold to ``off''
             ('rts_threshold', '2347'),
             ('fragm_threshold', '2346'),
-            ('driver', self.DRIVER_NAME)
+            ('driver', hostapd_constants.DRIVER_NAME)
         ])
 
     @property
-    def _ht40_plus_allowed(self):
-        """Returns: True iff HT40+ is enabled for this configuration."""
-        channel_supported = (
-            self.channel in self.HT40_ALLOW_MAP[self.N_CAPABILITY_HT40_PLUS])
-        return ((self.N_CAPABILITY_HT40_PLUS in self._n_capabilities or
-                 self.N_CAPABILITY_HT40 in self._n_capabilities) and
-                channel_supported)
-
-    @property
-    def _ht40_minus_allowed(self):
-        """Returns: True iff HT40- is enabled for this configuration."""
-        channel_supported = (
-            self.channel in self.HT40_ALLOW_MAP[self.N_CAPABILITY_HT40_MINUS])
-        return ((self.N_CAPABILITY_HT40_MINUS in self._n_capabilities or
-                 self.N_CAPABILITY_HT40 in self._n_capabilities) and
-                channel_supported)
-
-    @property
     def _hostapd_ht_capabilities(self):
-        """Returns: string suitable for the ht_capab= line in a hostapd config"""
+        """Returns: string suitable for the ht_capab= line in a hostapd config.
+        """
         ret = []
-        if self._ht40_plus_allowed:
-            ret.append('[HT40+]')
-        elif self._ht40_minus_allowed:
-            ret.append('[HT40-]')
-        if self.N_CAPABILITY_GREENFIELD in self._n_capabilities:
-            logging.warning('Greenfield flag is ignored for hostap...')
-        if self.N_CAPABILITY_SGI20 in self._n_capabilities:
-            ret.append('[SHORT-GI-20]')
-        if self.N_CAPABILITY_SGI40 in self._n_capabilities:
-            ret.append('[SHORT-GI-40]')
+        for cap in hostapd_constants.N_CAPABILITIES_MAPPING.keys():
+            if cap in self._n_capabilities:
+                ret.append(hostapd_constants.N_CAPABILITIES_MAPPING[cap])
         return ''.join(ret)
 
     @property
@@ -375,9 +115,9 @@
         """Returns: string suitable for the vht_capab= line in a hostapd config.
         """
         ret = []
-        for cap in self.AC_CAPABILITIES_MAPPING.keys():
+        for cap in hostapd_constants.AC_CAPABILITIES_MAPPING.keys():
             if cap in self._ac_capabilities:
-                ret.append(self.AC_CAPABILITIES_MAPPING[cap])
+                ret.append(hostapd_constants.AC_CAPABILITIES_MAPPING[cap])
         return ''.join(ret)
 
     @property
@@ -392,40 +132,40 @@
     @property
     def _require_vht(self):
         """Returns: True if clients should be required to support VHT."""
-        return self._mode == self.MODE_11AC_PURE
+        return self._mode == hostapd_constants.MODE_11AC_PURE
 
     @property
     def hw_mode(self):
         """Returns: string hardware mode understood by hostapd."""
-        if self._mode == self.MODE_11A:
-            return self.MODE_11A
-        if self._mode == self.MODE_11B:
-            return self.MODE_11B
-        if self._mode == self.MODE_11G:
-            return self.MODE_11G
+        if self._mode == hostapd_constants.MODE_11A:
+            return hostapd_constants.MODE_11A
+        if self._mode == hostapd_constants.MODE_11B:
+            return hostapd_constants.MODE_11B
+        if self._mode == hostapd_constants.MODE_11G:
+            return hostapd_constants.MODE_11G
         if self.is_11n or self.is_11ac:
             # For their own historical reasons, hostapd wants it this way.
             if self._frequency > 5000:
-                return self.MODE_11A
-
-            return self.MODE_11G
-
+                return hostapd_constants.MODE_11A
+            return hostapd_constants.MODE_11G
         raise ValueError('Invalid mode.')
 
     @property
     def is_11n(self):
         """Returns: True if we're trying to host an 802.11n network."""
-        return self._mode in (self.MODE_11N_MIXED, self.MODE_11N_PURE)
+        return self._mode in (hostapd_constants.MODE_11N_MIXED,
+                              hostapd_constants.MODE_11N_PURE)
 
     @property
     def is_11ac(self):
         """Returns: True if we're trying to host an 802.11ac network."""
-        return self._mode in (self.MODE_11AC_MIXED, self.MODE_11AC_PURE)
+        return self._mode in (hostapd_constants.MODE_11AC_MIXED,
+                              hostapd_constants.MODE_11AC_PURE)
 
     @property
     def channel(self):
         """Returns: int channel number for self.frequency."""
-        return self.get_channel_for_frequency(self.frequency)
+        return get_channel_for_frequency(self.frequency)
 
     @channel.setter
     def channel(self, value):
@@ -435,7 +175,7 @@
             value: int, channel number.
 
         """
-        self.frequency = self.get_frequency_for_channel(value)
+        self.frequency = get_frequency_for_channel(value)
 
     @property
     def bssid(self):
@@ -458,7 +198,7 @@
             value: int, frequency in MHz.
 
         """
-        if value not in self.CHANNEL_MAP or not self.supports_frequency(value):
+        if value not in hostapd_constants.CHANNEL_MAP:
             raise ValueError('Tried to set an invalid frequency: %r.' % value)
 
         self._frequency = value
@@ -528,10 +268,10 @@
         if not self.is_11n:
             return None
 
-        if self._ht40_plus_allowed:
+        if ht40_plus_allowed(self.channel):
             return 'HT40+'
 
-        if self._ht40_minus_allowed:
+        if ht40_minus_allowed(self.channel):
             return 'HT40-'
 
         return 'HT20'
@@ -560,19 +300,21 @@
         return self._min_streams
 
     def __init__(self,
-                 mode=MODE_11B,
+                 interface=None,
+                 mode=None,
                  channel=None,
                  frequency=None,
                  n_capabilities=[],
                  beacon_interval=None,
                  dtim_period=None,
                  frag_threshold=None,
+                 short_preamble=None,
                  ssid=None,
                  hidden=False,
                  security=None,
                  bssid=None,
                  force_wmm=None,
-                 pmf_support=PMF_SUPPORT_DISABLED,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_DISABLED,
                  obss_interval=None,
                  vht_channel_width=None,
                  vht_center_channel=None,
@@ -581,7 +323,8 @@
                  spectrum_mgmt_required=None,
                  scenario_name=None,
                  min_streams=None,
-                 bss_settings=[]):
+                 bss_settings=[],
+                 set_ap_defaults_model=None):
         """Construct a HostapdConfig.
 
         You may specify channel or frequency, but not both.  Both options
@@ -597,6 +340,7 @@
             beacon_interval: int, beacon interval of AP.
             dtim_period: int, include a DTIM every |dtim_period| beacons.
             frag_threshold: int, maximum outgoing data frame size.
+            short_preamble: Whether to use a short preamble.
             ssid: string, The name of the ssid to brodcast.
             hidden: bool, Should the ssid be hidden.
             security: Security, the secuirty settings to use.
@@ -620,24 +364,19 @@
             control_interface: The file name to use as the control interface.
             bss_settings: The settings for all bss.
         """
+        self._interface = interface
         if channel is not None and frequency is not None:
             raise ValueError('Specify either frequency or channel '
                              'but not both.')
 
         self._wmm_enabled = False
         unknown_caps = [
-            cap for cap in n_capabilities if cap not in self.ALL_N_CAPABILITIES
+            cap for cap in n_capabilities
+            if cap not in hostapd_constants.N_CAPABILITIES_MAPPING
         ]
         if unknown_caps:
             raise ValueError('Unknown capabilities: %r' % unknown_caps)
 
-        self._n_capabilities = set(n_capabilities)
-        if self._n_capabilities:
-            self._wmm_enabled = True
-        if self._n_capabilities and mode is None:
-            mode = self.MODE_11N_PURE
-        self._mode = mode
-
         self._frequency = None
         if channel:
             self.channel = channel
@@ -645,6 +384,28 @@
             self.frequency = frequency
         else:
             raise ValueError('Specify either frequency or channel.')
+        '''
+        if set_ap_defaults_model:
+            ap_default_config = hostapd_ap_default_configs.APDefaultConfig(
+                profile_name=set_ap_defaults_model, frequency=self.frequency)
+            force_wmm = ap_default_config.force_wmm
+            beacon_interval = ap_default_config.beacon_interval
+            dtim_period = ap_default_config.dtim_period
+            short_preamble = ap_default_config.short_preamble
+            self._interface = ap_default_config.interface
+            mode = ap_default_config.mode
+            if ap_default_config.n_capabilities:
+                n_capabilities = ap_default_config.n_capabilities
+            if ap_default_config.ac_capabilities:
+                ap_default_config = ap_default_config.ac_capabilities
+        '''
+
+        self._n_capabilities = set(n_capabilities)
+        if self._n_capabilities:
+            self._wmm_enabled = True
+        if self._n_capabilities and mode is None:
+            mode = hostapd_constants.MODE_11N_PURE
+        self._mode = mode
 
         if not self.supports_frequency(self.frequency):
             raise ValueError('Configured a mode %s that does not support '
@@ -653,6 +414,7 @@
         self._beacon_interval = beacon_interval
         self._dtim_period = dtim_period
         self._frag_threshold = frag_threshold
+        self._short_preamble = short_preamble
 
         self._ssid = ssid
         self._hidden = hidden
@@ -660,25 +422,32 @@
         self._bssid = bssid
         if force_wmm is not None:
             self._wmm_enabled = force_wmm
-        if pmf_support not in self.PMF_SUPPORT_VALUES:
+        if pmf_support not in hostapd_constants.PMF_SUPPORT_VALUES:
             raise ValueError('Invalid value for pmf_support: %r' % pmf_support)
 
         self._pmf_support = pmf_support
         self._obss_interval = obss_interval
-        if vht_channel_width == self.VHT_CHANNEL_WIDTH_40:
-            self._vht_oper_chwidth = 0
-        elif vht_channel_width == self.VHT_CHANNEL_WIDTH_80:
-            self._vht_oper_chwidth = 1
-        elif vht_channel_width == self.VHT_CHANNEL_WIDTH_160:
-            self._vht_oper_chwidth = 2
-        elif vht_channel_width == self.VHT_CHANNEL_WIDTH_80_80:
-            self._vht_oper_chwidth = 3
-        elif vht_channel_width is not None:
-            raise ValueError('Invalid channel width')
-        # TODO(zqiu) Add checking for center channel based on the channel width
-        # and operating channel.
-        self._vht_oper_centr_freq_seg0_idx = vht_center_channel
-        self._ac_capabilities = set(ac_capabilities)
+        if self.is_11ac:
+            if str(vht_channel_width) == '40':
+                self._vht_oper_chwidth = hostapd_constants.VHT_CHANNEL_WIDTH_40
+            elif str(vht_channel_width) == '80':
+                self._vht_oper_chwidth = hostapd_constants.VHT_CHANNEL_WIDTH_80
+            elif str(vht_channel_width) == '160':
+                self._vht_oper_chwidth = hostapd_constants.VHT_CHANNEL_WIDTH_160
+            elif str(vht_channel_width) == '80+80':
+                self._vht_oper_chwidth = hostapd_constants.VHT_CHANNEL_WIDTH_80_80
+            elif vht_channel_width is not None:
+                raise ValueError('Invalid channel width')
+            else:
+                logging.warning(
+                    'No channel bandwidth specified.  Using 80MHz for 11ac.')
+                self._vht_oper_chwidth = 1
+            if not vht_center_channel:
+                self._vht_oper_centr_freq_seg0_idx = self._get_11ac_center_channel_from_channel(
+                    self.channel)
+            else:
+                self._vht_oper_centr_freq_seg0_idx = vht_center_channel
+            self._ac_capabilities = set(ac_capabilities)
         self._beacon_footer = beacon_footer
         self._spectrum_mgmt_required = spectrum_mgmt_required
         self._scenario_name = scenario_name
@@ -710,7 +479,7 @@
         @return True iff the current mode supports the band of the channel.
 
         """
-        for freq, channel in self.CHANNEL_MAP.iteritems():
+        for freq, channel in hostapd_constants.CHANNEL_MAP.iteritems():
             if channel == value:
                 return self.supports_frequency(freq)
 
@@ -723,30 +492,27 @@
         @return True iff the current mode supports the band of the frequency.
 
         """
-        if self._mode == self.MODE_11A and frequency < 5000:
+        if self._mode == hostapd_constants.MODE_11A and frequency < 5000:
             return False
 
-        if self._mode in (self.MODE_11B, self.MODE_11G) and frequency > 5000:
+        if self._mode in (hostapd_constants.MODE_11B,
+                          hostapd_constants.MODE_11G) and frequency > 5000:
             return False
 
-        if frequency not in self.CHANNEL_MAP:
+        if frequency not in hostapd_constants.CHANNEL_MAP:
             return False
 
-        channel = self.CHANNEL_MAP[frequency]
-        supports_plus = (
-            channel in self.HT40_ALLOW_MAP[self.N_CAPABILITY_HT40_PLUS])
-        supports_minus = (
-            channel in self.HT40_ALLOW_MAP[self.N_CAPABILITY_HT40_MINUS])
-        if (self.N_CAPABILITY_HT40_PLUS in self._n_capabilities and
-                not supports_plus):
+        channel = hostapd_constants.CHANNEL_MAP[frequency]
+        supports_plus = (channel in hostapd_constants.HT40_ALLOW_MAP[
+            hostapd_constants.N_CAPABILITY_HT40_PLUS_CHANNELS])
+        supports_minus = (channel in hostapd_constants.HT40_ALLOW_MAP[
+            hostapd_constants.N_CAPABILITY_HT40_MINUS_CHANNELS])
+        if (hostapd_constants.N_CAPABILITY_HT40_PLUS in self._n_capabilities
+                and not supports_plus):
             return False
 
-        if (self.N_CAPABILITY_HT40_MINUS in self._n_capabilities and
-                not supports_minus):
-            return False
-
-        if (self.N_CAPABILITY_HT40 in self._n_capabilities and
-                not supports_plus and not supports_minus):
+        if (hostapd_constants.N_CAPABILITY_HT40_MINUS in self._n_capabilities
+                and not supports_minus):
             return False
 
         return True
@@ -775,6 +541,8 @@
         """
         # Start with the default config parameters.
         conf = self._get_default_config
+        if self._interface:
+            conf['interface'] = self._interface
         if self._bssid:
             conf['bssid'] = self._bssid
         if self._ssid:
@@ -807,6 +575,8 @@
             conf['ieee80211w'] = self._pmf_support
         if self._obss_interval:
             conf['obss_interval'] = self._obss_interval
+        if self._short_preamble:
+            conf['preamble'] = 1
         if self._spectrum_mgmt_required:
             # To set spectrum_mgmt_required, we must first set
             # local_pwr_constraint. And to set local_pwr_constraint,
diff --git a/acts/framework/acts/controllers/ap_lib/hostapd_constants.py b/acts/framework/acts/controllers/ap_lib/hostapd_constants.py
new file mode 100755
index 0000000..de5665d
--- /dev/null
+++ b/acts/framework/acts/controllers/ap_lib/hostapd_constants.py
@@ -0,0 +1,237 @@
+#!/usr/bin/env python3.4
+#
+#   Copyright 2017 - 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.
+
+import itertools
+
+WPA1 = 1
+WPA2 = 2
+MIXED = 3
+MAX_WPA_PSK_LENGTH = 64
+MIN_WPA_PSK_LENGTH = 8
+WPA_STRICT_REKEY = 1
+WPA_DEFAULT_CIPHER = 'TKIP'
+WPA2_DEFAULT_CIPER = 'CCMP'
+WPA_GROUP_KEY_ROTATION_TIME = 600
+WPA_STRICT_REKEY_DEFAULT = True
+WPA_STRING = 'wpa'
+WPA2_STRING = 'wpa2'
+WPA_MIXED_STRING = 'wpa/wpa2'
+WLAN0_STRING = 'wlan0'
+WLAN1_STRING = 'wlan1'
+WLAN2_STRING = 'wlan2'
+WLAN3_STRING = 'wlan3'
+
+# A mapping of frequency to channel number.  This includes some
+# frequencies used outside the US.
+CHANNEL_MAP = {
+    2412: 1,
+    2417: 2,
+    2422: 3,
+    2427: 4,
+    2432: 5,
+    2437: 6,
+    2442: 7,
+    2447: 8,
+    2452: 9,
+    2457: 10,
+    2462: 11,
+    # 12, 13 are only legitimate outside the US.
+    2467: 12,
+    2472: 13,
+    # 14 is for Japan, DSSS and CCK only.
+    2484: 14,
+    # 34 valid in Japan.
+    5170: 34,
+    # 36-116 valid in the US, except 38, 42, and 46, which have
+    # mixed international support.
+    5180: 36,
+    5190: 38,
+    5200: 40,
+    5210: 42,
+    5220: 44,
+    5230: 46,
+    5240: 48,
+    5260: 52,
+    5280: 56,
+    5300: 60,
+    5320: 64,
+    5500: 100,
+    5520: 104,
+    5540: 108,
+    5560: 112,
+    5580: 116,
+    # 120, 124, 128 valid in Europe/Japan.
+    5600: 120,
+    5620: 124,
+    5640: 128,
+    # 132+ valid in US.
+    5660: 132,
+    5680: 136,
+    5700: 140,
+    # 144 is supported by a subset of WiFi chips
+    # (e.g. bcm4354, but not ath9k).
+    5720: 144,
+    5745: 149,
+    5765: 153,
+    5785: 157,
+    5805: 161,
+    5825: 165
+}
+
+MODE_11A = 'a'
+MODE_11B = 'b'
+MODE_11G = 'g'
+MODE_11N_MIXED = 'n-mixed'
+MODE_11N_PURE = 'n-only'
+MODE_11AC_MIXED = 'ac-mixed'
+MODE_11AC_PURE = 'ac-only'
+
+N_CAPABILITY_LDPC = object()
+N_CAPABILITY_HT40_PLUS = object()
+N_CAPABILITY_HT40_MINUS = object()
+N_CAPABILITY_GREENFIELD = object()
+N_CAPABILITY_SGI20 = object()
+N_CAPABILITY_SGI40 = object()
+N_CAPABILITY_TX_STBC = object()
+N_CAPABILITY_RX_STBC1 = object()
+N_CAPABILITY_RX_STBC12 = object()
+N_CAPABILITY_RX_STBC123 = object()
+N_CAPABILITY_DSSS_CCK_40 = object()
+N_CAPABILITIES_MAPPING = {
+    N_CAPABILITY_LDPC: '[LDPC]',
+    N_CAPABILITY_HT40_PLUS: '[HT40+]',
+    N_CAPABILITY_HT40_MINUS: '[HT40-]',
+    N_CAPABILITY_GREENFIELD: '[GF]',
+    N_CAPABILITY_SGI20: '[SHORT-GI-20]',
+    N_CAPABILITY_SGI40: '[SHORT-GI-40]',
+    N_CAPABILITY_TX_STBC: '[TX-STBC]',
+    N_CAPABILITY_RX_STBC1: '[RX-STBC1]',
+    N_CAPABILITY_RX_STBC12: '[RX-STBC12]',
+    N_CAPABILITY_RX_STBC123: '[RX-STBC123]',
+    N_CAPABILITY_DSSS_CCK_40: '[DSSS_CCK-40]'
+}
+N_CAPABILITY_HT40_MINUS_CHANNELS = object()
+N_CAPABILITY_HT40_PLUS_CHANNELS = object()
+AC_CAPABILITY_VHT160 = object()
+AC_CAPABILITY_VHT160_80PLUS80 = object()
+AC_CAPABILITY_RXLDPC = object()
+AC_CAPABILITY_SHORT_GI_80 = object()
+AC_CAPABILITY_SHORT_GI_160 = object()
+AC_CAPABILITY_TX_STBC_2BY1 = object()
+AC_CAPABILITY_RX_STBC_1 = object()
+AC_CAPABILITY_RX_STBC_12 = object()
+AC_CAPABILITY_RX_STBC_123 = object()
+AC_CAPABILITY_RX_STBC_1234 = object()
+AC_CAPABILITY_SU_BEAMFORMER = object()
+AC_CAPABILITY_SU_BEAMFORMEE = object()
+AC_CAPABILITY_BF_ANTENNA_2 = object()
+AC_CAPABILITY_SOUNDING_DIMENSION_2 = object()
+AC_CAPABILITY_MU_BEAMFORMER = object()
+AC_CAPABILITY_MU_BEAMFORMEE = object()
+AC_CAPABILITY_VHT_TXOP_PS = object()
+AC_CAPABILITY_HTC_VHT = object()
+AC_CAPABILITY_MAX_A_MPDU_LEN_EXP0 = object()
+AC_CAPABILITY_MAX_A_MPDU_LEN_EXP1 = object()
+AC_CAPABILITY_MAX_A_MPDU_LEN_EXP2 = object()
+AC_CAPABILITY_MAX_A_MPDU_LEN_EXP3 = object()
+AC_CAPABILITY_MAX_A_MPDU_LEN_EXP4 = object()
+AC_CAPABILITY_MAX_A_MPDU_LEN_EXP5 = object()
+AC_CAPABILITY_MAX_A_MPDU_LEN_EXP6 = object()
+AC_CAPABILITY_MAX_A_MPDU_LEN_EXP7 = object()
+AC_CAPABILITY_VHT_LINK_ADAPT2 = object()
+AC_CAPABILITY_VHT_LINK_ADAPT3 = object()
+AC_CAPABILITY_RX_ANTENNA_PATTERN = object()
+AC_CAPABILITY_TX_ANTENNA_PATTERN = object()
+AC_CAPABILITY_MAX_MPDU_7991 = object()
+AC_CAPABILITY_MAX_MPDU_11454 = object()
+AC_CAPABILITIES_MAPPING = {
+    AC_CAPABILITY_VHT160: '[VHT160]',
+    AC_CAPABILITY_VHT160_80PLUS80: '[VHT160-80PLUS80]',
+    AC_CAPABILITY_RXLDPC: '[RXLDPC]',
+    AC_CAPABILITY_SHORT_GI_80: '[SHORT-GI-80]',
+    AC_CAPABILITY_SHORT_GI_160: '[SHORT-GI-160]',
+    AC_CAPABILITY_TX_STBC_2BY1: '[TX-STBC-2BY1]',
+    AC_CAPABILITY_RX_STBC_1: '[RX-STBC-1]',
+    AC_CAPABILITY_RX_STBC_12: '[RX-STBC-12]',
+    AC_CAPABILITY_RX_STBC_123: '[RX-STBC-123]',
+    AC_CAPABILITY_RX_STBC_1234: '[RX-STBC-1234]',
+    AC_CAPABILITY_SU_BEAMFORMER: '[SU-BEAMFORMER]',
+    AC_CAPABILITY_SU_BEAMFORMEE: '[SU-BEAMFORMEE]',
+    AC_CAPABILITY_BF_ANTENNA_2: '[BF-ANTENNA-2]',
+    AC_CAPABILITY_SOUNDING_DIMENSION_2: '[SOUNDING-DIMENSION-2]',
+    AC_CAPABILITY_MU_BEAMFORMER: '[MU-BEAMFORMER]',
+    AC_CAPABILITY_MU_BEAMFORMEE: '[MU-BEAMFORMEE]',
+    AC_CAPABILITY_VHT_TXOP_PS: '[VHT-TXOP-PS]',
+    AC_CAPABILITY_HTC_VHT: '[HTC-VHT]',
+    AC_CAPABILITY_MAX_A_MPDU_LEN_EXP0: '[MAX-A-MPDU-LEN-EXP0]',
+    AC_CAPABILITY_MAX_A_MPDU_LEN_EXP1: '[MAX-A-MPDU-LEN-EXP1]',
+    AC_CAPABILITY_MAX_A_MPDU_LEN_EXP2: '[MAX-A-MPDU-LEN-EXP2]',
+    AC_CAPABILITY_MAX_A_MPDU_LEN_EXP3: '[MAX-A-MPDU-LEN-EXP3]',
+    AC_CAPABILITY_MAX_A_MPDU_LEN_EXP4: '[MAX-A-MPDU-LEN-EXP4]',
+    AC_CAPABILITY_MAX_A_MPDU_LEN_EXP5: '[MAX-A-MPDU-LEN-EXP5]',
+    AC_CAPABILITY_MAX_A_MPDU_LEN_EXP6: '[MAX-A-MPDU-LEN-EXP6]',
+    AC_CAPABILITY_MAX_A_MPDU_LEN_EXP7: '[MAX-A-MPDU-LEN-EXP7]',
+    AC_CAPABILITY_VHT_LINK_ADAPT2: '[VHT-LINK-ADAPT2]',
+    AC_CAPABILITY_VHT_LINK_ADAPT3: '[VHT-LINK-ADAPT3]',
+    AC_CAPABILITY_RX_ANTENNA_PATTERN: '[RX-ANTENNA-PATTERN]',
+    AC_CAPABILITY_TX_ANTENNA_PATTERN: '[TX-ANTENNA-PATTERN]',
+    AC_CAPABILITY_MAX_MPDU_11454: '[MAX-MPDU-11454]',
+    AC_CAPABILITY_MAX_MPDU_7991: '[MAX-MPDU-7991]'
+}
+VHT_CHANNEL_WIDTH_40 = 0
+VHT_CHANNEL_WIDTH_80 = 1
+VHT_CHANNEL_WIDTH_160 = 2
+VHT_CHANNEL_WIDTH_80_80 = 3
+
+# This is a loose merging of the rules for US and EU regulatory
+# domains as taken from IEEE Std 802.11-2012 Appendix E.  For instance,
+# we tolerate HT40 in channels 149-161 (not allowed in EU), but also
+# tolerate HT40+ on channel 7 (not allowed in the US).  We take the loose
+# definition so that we don't prohibit testing in either domain.
+HT40_ALLOW_MAP = {
+    N_CAPABILITY_HT40_MINUS_CHANNELS: tuple(
+        itertools.chain(
+            range(6, 14), range(40, 65, 8), range(104, 137, 8), [153, 161])),
+    N_CAPABILITY_HT40_PLUS_CHANNELS: tuple(
+        itertools.chain(
+            range(1, 8), range(36, 61, 8), range(100, 133, 8), [149, 157]))
+}
+
+PMF_SUPPORT_DISABLED = 0
+PMF_SUPPORT_ENABLED = 1
+PMF_SUPPORT_REQUIRED = 2
+PMF_SUPPORT_VALUES = (PMF_SUPPORT_DISABLED, PMF_SUPPORT_ENABLED,
+                      PMF_SUPPORT_REQUIRED)
+
+DRIVER_NAME = 'nl80211'
+
+CENTER_CHANNEL_MAP = {
+    VHT_CHANNEL_WIDTH_40: {
+        'delta': 2,
+        'channels': ((36, 40), (44, 48), (52, 56), (60, 64), (100, 104),
+                     (108, 112), (116, 120), (124, 128), (132, 136),
+                     (140, 144), (149, 153), (147, 161))
+    },
+    VHT_CHANNEL_WIDTH_80: {
+        'delta': 6,
+        'channels': ((36, 48), (52, 64), (100, 112), (116, 128), (132, 144),
+                     (149, 161))
+    },
+    VHT_CHANNEL_WIDTH_160: {
+        'delta': 14,
+        'channels': ((36, 64), (100, 128))
+    }
+}
diff --git a/acts/framework/acts/controllers/ap_lib/hostapd_security.py b/acts/framework/acts/controllers/ap_lib/hostapd_security.py
new file mode 100644
index 0000000..4e1ae3a
--- /dev/null
+++ b/acts/framework/acts/controllers/ap_lib/hostapd_security.py
@@ -0,0 +1,99 @@
+#   Copyright 2017 - The Android Open Source Project
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+import collections
+
+from acts.controllers.ap_lib import hostapd_constants
+
+
+class Security(object):
+    """The Security class for hostapd representing some of the security
+       settings that are allowed in hostapd.  If needed more can be added.
+    """
+
+    def __init__(self,
+                 security_mode=None,
+                 password=None,
+                 wpa_cipher=hostapd_constants.WPA_DEFAULT_CIPHER,
+                 wpa2_cipher=hostapd_constants.WPA2_DEFAULT_CIPER,
+                 wpa_group_rekey=hostapd_constants.WPA_GROUP_KEY_ROTATION_TIME,
+                 wpa_strict_rekey=hostapd_constants.WPA_STRICT_REKEY_DEFAULT):
+        """Gather all of the security settings for WPA-PSK.  This could be
+           expanded later.
+
+        Args:
+            security_mode: Type of security modes.
+                           Options: wpa, wpa2, wpa/wpa2
+            password: The PSK or passphrase for the security mode.
+            wpa_cipher: The cipher to be used for wpa.
+                        Options: TKIP, CCMP, TKIP CCMP
+                        Default: TKIP
+            wpa2_cipher: The cipher to be used for wpa2.
+                         Options: TKIP, CCMP, TKIP CCMP
+                         Default: CCMP
+            wpa_group_rekey: How often to refresh the GTK regardless of network
+                             changes.
+                             Options: An integrer in seconds, None
+                             Default: 600 seconds
+            wpa_strict_rekey: Whether to do a group key update when client
+                              leaves the network or not.
+                              Options: True, False
+                              Default: True
+        """
+        self.wpa_cipher = wpa_cipher
+        self.wpa2_cipher = wpa2_cipher
+        self.wpa_group_rekey = wpa_group_rekey
+        self.wpa_strict_rekey = wpa_strict_rekey
+        if security_mode == hostapd_constants.WPA_STRING:
+            security_mode = hostapd_constants.WPA1
+        elif security_mode == hostapd_constants.WPA2_STRING:
+            security_mode = hostapd_constants.WPA2
+        elif security_mode == hostapd_constants.WPA_MIXED_STRING:
+            security_mode = hostapd_constants.MIXED
+        else:
+            security_mode = None
+        self.security_mode = security_mode
+        if len(password) < hostapd_constants.MIN_WPA_PSK_LENGTH or len(
+                password) > hostapd_constants.MAX_WPA_PSK_LENGTH:
+            raise ValueError(
+                'Password must be a minumum of %s characters and a maximum of %s'
+                % (hostapd_constants.MIN_WPA_PSK_LENGTH,
+                   hostapd_constants.MAX_WPA_PSK_LENGTH))
+        else:
+            self.password = password
+
+    def generate_dict(self):
+        """Returns: an ordered dictionary of settings"""
+        settings = collections.OrderedDict()
+        if self.security_mode:
+            settings['wpa'] = self.security_mode
+            if len(self.password) == hostapd_constants.MAX_WPA_PSK_LENGTH:
+                settings['wpa_psk'] = self.password
+            else:
+                settings['wpa_passphrase'] = self.password
+
+            if self.security_mode == hostapd_constants.MIXED:
+                settings['wpa_pairwise'] = self.wpa_cipher
+                settings['rsn_pairwise'] = self.wpa2_cipher
+            elif self.security_mode == hostapd_constants.WPA1:
+                settings['wpa_pairwise'] = self.wpa_cipher
+            elif self.security_mode == hostapd_constants.WPA2:
+                settings['rsn_pairwise'] = self.wpa2_cipher
+
+            if self.wpa_group_rekey:
+                settings['wpa_group_rekey'] = self.wpa_group_rekey
+            if self.wpa_strict_rekey:
+                settings[
+                    'wpa_strict_rekey'] = hostapd_constants.WPA_STRICT_REKEY
+        return settings
diff --git a/acts/framework/acts/records.py b/acts/framework/acts/records.py
index 56eaf97..9b9a1c6 100644
--- a/acts/framework/acts/records.py
+++ b/acts/framework/acts/records.py
@@ -43,6 +43,7 @@
     TEST_RESULT_PASS = "PASS"
     TEST_RESULT_FAIL = "FAIL"
     TEST_RESULT_SKIP = "SKIP"
+    TEST_RESULT_BLOCKED = "BLOCKED"
     TEST_RESULT_UNKNOWN = "UNKNOWN"
 
 
@@ -124,6 +125,14 @@
         """
         self._test_end(TestResultEnums.TEST_RESULT_SKIP, e)
 
+    def test_blocked(self, e=None):
+        """To mark the test as blocked in this record.
+
+        Args:
+            e: An instance of acts.signals.Test
+        """
+        self._test_end(TestResultEnums.TEST_RESULT_BLOCKED, e)
+
     def test_unknown(self, e=None):
         """To mark the test as unknown in this record.
 
@@ -213,6 +222,7 @@
         self.executed = []
         self.passed = []
         self.skipped = []
+        self.blocked = []
         self.unknown = []
         self.controller_info = {}
 
@@ -263,14 +273,18 @@
         Args:
             record: A test record object to add.
         """
-        self.executed.append(record)
         if record.result == TestResultEnums.TEST_RESULT_FAIL:
+            self.executed.append(record)
             self.failed.append(record)
         elif record.result == TestResultEnums.TEST_RESULT_SKIP:
             self.skipped.append(record)
         elif record.result == TestResultEnums.TEST_RESULT_PASS:
+            self.executed.append(record)
             self.passed.append(record)
+        elif record.result == TestResultEnums.TEST_RESULT_BLOCKED:
+            self.blocked.append(record)
         else:
+            self.executed.append(record)
             self.unknown.append(record)
 
     def add_controller_info(self, name, info):
@@ -283,29 +297,11 @@
             return
         self.controller_info[name] = info
 
-    def fail_class(self, test_record):
-        """Add a record to indicate a test class setup has failed and no test
-        in the class was executed.
-
-        Args:
-            test_record: A TestResultRecord object for the test class.
-        """
-        self.executed.append(test_record)
-        self.failed.append(test_record)
-
-    def skip_class(self, test_record):
-        """Add a record to indicate a test class setup has skipped and no test
-        in the class was executed.
-
-        Args:
-            test_record: A TestResultRecord object for the test class.
-        """
-        self.skipped.append(test_record)
-
     @property
     def is_all_pass(self):
         """True if no tests failed or threw errors, False otherwise."""
-        num_of_failures = len(self.failed) + len(self.unknown)
+        num_of_failures = (
+            len(self.failed) + len(self.unknown) + len(self.blocked))
         if num_of_failures == 0:
             return True
         return False
@@ -366,5 +362,6 @@
         d["Passed"] = len(self.passed)
         d["Failed"] = len(self.failed)
         d["Skipped"] = len(self.skipped)
+        d["Blocked"] = len(self.blocked)
         d["Unknown"] = len(self.unknown)
         return d
diff --git a/acts/framework/acts/signals.py b/acts/framework/acts/signals.py
index e82fa95..49be989 100644
--- a/acts/framework/acts/signals.py
+++ b/acts/framework/acts/signals.py
@@ -77,6 +77,10 @@
     """Raised when a test has been skipped."""
 
 
+class TestBlocked(TestSignal):
+    """Raised when a test has been blocked from running."""
+
+
 class TestSkipClass(TestSignal):
     """Raised in setup_class when a whole test class should be skipped."""
 
diff --git a/acts/framework/acts/test_decorators.py b/acts/framework/acts/test_decorators.py
index b7763f5..20c1383 100644
--- a/acts/framework/acts/test_decorators.py
+++ b/acts/framework/acts/test_decorators.py
@@ -37,35 +37,9 @@
         **keyed_info: The key, value info to include in the extras for this
                       test.
     """
+
     def test_info_decoractor(func):
-        def func_wrapper(*args, **kwargs):
-            try:
-                result = func(*args, **kwargs)
-                if result or result is None:
-                    new_signal = signals.TestPass('')
-                else:
-                    new_signal = signals.TestFailure('')
-            except signals.TestSignal as signal:
-                new_signal = signal
-
-            if not isinstance(new_signal.extras, dict) and new_signal.extras:
-                raise ValueError('test_info can only append to signal data '
-                                 'that has a dict as the extra value.')
-            elif not new_signal.extras:
-                new_signal.extras = {}
-
-            if not predicate or predicate(args[0], args[1:], kwargs):
-                for k, v in keyed_info.items():
-                    if v and k not in new_signal.extras:
-                        new_signal.extras[k] = v
-                    elif v and k in new_signal.extras:
-                        if not isinstance(new_signal.extras[k], list):
-                            new_signal.extras[k] = [new_signal.extras[k]]
-                        new_signal.extras[k].append(v)
-
-            raise new_signal
-
-        return func_wrapper
+        return _TestInfoDecoratorFunc(func, predicate, keyed_info)
 
     return test_info_decoractor
 
@@ -86,6 +60,130 @@
         extra_environment_info: Extra info about the test tracker environment.
         predicate: A func that if false when called will ignore this info.
     """
-    return test_info(test_tracker_uuid=uuid,
-                     test_tracker_enviroment_info=extra_environment_info,
-                     predicate=predicate)
+    return test_info(
+        test_tracker_uuid=uuid,
+        test_tracker_enviroment_info=extra_environment_info,
+        predicate=predicate)
+
+
+class _TestInfoDecoratorFunc(object):
+    """Object that acts as a function decorator test info."""
+
+    def __init__(self, func, predicate, keyed_info):
+        self.func = func
+        self.predicate = predicate
+        self.keyed_info = keyed_info
+
+    def __get__(self, instance, owner):
+        """Called by Python to create a binding for an instance closure.
+
+        When called by Python this object will create a special binding for
+        that instance. That binding will know how to interact with this
+        specific decorator.
+        """
+        return _TestInfoBinding(self, instance)
+
+    def __call__(self, *args, **kwargs):
+        """
+        When called runs the underlying func and then attaches test info
+        to a signal.
+        """
+        try:
+            result = self.func(*args, **kwargs)
+
+            if result or result is None:
+                new_signal = signals.TestPass('')
+            else:
+                new_signal = signals.TestFailure('')
+        except signals.TestSignal as signal:
+            new_signal = signal
+
+        if not isinstance(new_signal.extras, dict) and new_signal.extras:
+            raise ValueError('test_info can only append to signal data '
+                             'that has a dict as the extra value.')
+        elif not new_signal.extras:
+            new_signal.extras = {}
+
+        gathered_extras = self._gather_local_info(*args, **kwargs)
+        for k, v in gathered_extras.items():
+            if k not in new_signal.extras:
+                new_signal.extras[k] = v
+            else:
+                if not isinstance(new_signal.extras[k], list):
+                    new_signal.extras[k] = [new_signal.extras[k]]
+
+                new_signal.extras[k].insert(0, v)
+
+        raise new_signal
+
+    def gather(self, *args, **kwargs):
+        """
+        Gathers the info from this decorator without invoking the underlying
+        function. This will also gather all child info if the underlying func
+        has that ability.
+
+        Returns: A dictionary of info.
+        """
+        if hasattr(self.func, 'gather'):
+            extras = self.func.gather(*args, **kwargs)
+        else:
+            extras = {}
+
+        self._gather_local_info(*args, gather_into=extras, **kwargs)
+
+        return extras
+
+    def _gather_local_info(self, *args, gather_into=None, **kwargs):
+        """Gathers info from this decorator and ignores children.
+
+        Args:
+            gather_into: Gathers into a dictionary that already exists.
+
+        Returns: The dictionary with gathered info in it.
+        """
+        if gather_into is None:
+            extras = {}
+        else:
+            extras = gather_into
+        if not self.predicate or self.predicate(args, kwargs):
+            for k, v in self.keyed_info.items():
+                if v and k not in extras:
+                    extras[k] = v
+                elif v and k in extras:
+                    if not isinstance(extras[k], list):
+                        extras[k] = [extras[k]]
+                    extras[k].insert(0, v)
+
+        return extras
+
+
+class _TestInfoBinding(object):
+    """
+    When Python creates an instance of an object it creates a binding object
+    for each closure that contains what the instance variable should be when
+    called. This object is a similar binding for _TestInfoDecoratorFunc.
+    When Python tries to create a binding of a _TestInfoDecoratorFunc it
+    will return one of these objects to hold the instance for that closure.
+    """
+
+    def __init__(self, target, instance):
+        """
+        Args:
+            target: The target for creating a binding to.
+            instance: The instance to bind the target with.
+        """
+        self.target = target
+        self.instance = instance
+
+    def __call__(self, *args, **kwargs):
+        """
+        When this object is called it will call the target with the bound
+        instance.
+        """
+        return self.target(self.instance, *args, **kwargs)
+
+    def gather(self, *args, **kwargs):
+        """
+        Will gather the target with the bound instance.
+        """
+        return self.target.gather(self.instance, *args, **kwargs)
diff --git a/acts/framework/acts/test_utils/tel/TelephonyBaseTest.py b/acts/framework/acts/test_utils/tel/TelephonyBaseTest.py
index 0ddf218..6808110 100644
--- a/acts/framework/acts/test_utils/tel/TelephonyBaseTest.py
+++ b/acts/framework/acts/test_utils/tel/TelephonyBaseTest.py
@@ -67,17 +67,24 @@
         inspect_stack = inspect.stack()
         trace_info = ""
         for i in range(level):
-            stack_frames = inspect_stack[2 + i]
-            info = inspect.getframeinfo(stack_frames[0])
-            trace_info = "%s[%s:%s:%s]" % (trace_info,
-                                           os.path.basename(info.filename),
-                                           info.function, info.lineno)
+            try:
+                stack_frames = inspect_stack[2 + i]
+                info = inspect.getframeinfo(stack_frames[0])
+                trace_info = "%s[%s:%s:%s]" % (trace_info,
+                                               os.path.basename(info.filename),
+                                               info.function, info.lineno)
+            except IndexError:
+                break
         return trace_info
 
     def error(self, msg, *args, **kwargs):
         trace_info = _TelephonyTraceLogger._get_trace_info(level=3)
         self._logger.error("%s %s" % (msg, trace_info), *args, **kwargs)
 
+    def warn(self, msg, *args, **kwargs):
+        trace_info = _TelephonyTraceLogger._get_trace_info(level=1)
+        self._logger.warn("%s %s" % (msg, trace_info), *args, **kwargs)
+
     def warning(self, msg, *args, **kwargs):
         trace_info = _TelephonyTraceLogger._get_trace_info(level=1)
         self._logger.warning("%s %s" % (msg, trace_info), *args, **kwargs)
@@ -213,11 +220,12 @@
 
             # Setup VoWiFi MDN for Verizon. b/33187374
             build_id = ad.build_info["build_id"]
-            if "vzw" in [sub["operator"] for sub in ad.cfg[
-                    "subscription"].values()] and ad.model in (
-                            "marlin", "sailfish") and (build_id.startswith(
-                                    "N2") or build_id.startswith("OR")):
-                ad.log.info("setup VoWiFi MDN for MR2 or OC branch per b/33187374")
+            if "vzw" in [
+                    sub["operator"] for sub in ad.cfg["subscription"].values()
+            ] and ad.model in ("marlin", "sailfish") and (
+                    build_id.startswith("N2") or build_id.startswith("OR")):
+                ad.log.info(
+                    "setup VoWiFi MDN for MR2 or OC branch per b/33187374")
                 ad.adb.shell("setprop dbg.vzw.force_wfc_nv_enabled true")
                 ad.adb.shell("am start --ei EXTRA_LAUNCH_CARRIER_APP 0 -n "
                              "\"com.google.android.wfcactivation/"
@@ -265,11 +273,10 @@
                 if "enable_wifi_verbose_logging" in self.user_params:
                     ad.droid.wifiEnableVerboseLogging(
                         WIFI_VERBOSE_LOGGING_DISABLED)
+            return True
         except Exception as e:
             self.log.error("Failure with %s", e)
 
-        return True
-
     def setup_test(self):
         if getattr(self, "diag_logger", None):
             for logger in self.diag_logger:
@@ -322,8 +329,8 @@
                 ad.adb.wait_for_device()
                 ad.take_bug_report(test_name, begin_time)
                 tombstone_path = os.path.join(
-                    ad.log_path, "BugReports",
-                    "{},{}".format(begin_time, ad.serial).replace(' ', '_'))
+                    ad.log_path, "BugReports", "{},{}".format(
+                        begin_time, ad.serial).replace(' ', '_'))
                 utils.create_dir(tombstone_path)
                 ad.adb.pull('/data/tombstones/', tombstone_path, timeout=1200)
             except Exception as e:
diff --git a/acts/framework/acts/test_utils/tel/anritsu_utils.py b/acts/framework/acts/test_utils/tel/anritsu_utils.py
index 72c4462..6aa9e91 100644
--- a/acts/framework/acts/test_utils/tel/anritsu_utils.py
+++ b/acts/framework/acts/test_utils/tel/anritsu_utils.py
@@ -65,6 +65,10 @@
 # Time to wait for before aSRVCC
 WAIT_TIME_IN_ALERT = 5
 
+# SIM card names
+P0250Ax = "P0250Ax"
+VzW12349 = "VzW12349"
+
 # Test PLMN information
 TEST_PLMN_LTE_NAME = "MD8475A_LTE"
 TEST_PLMN_WCDMA_NAME = "MD8475A_WCDMA"
@@ -76,42 +80,30 @@
 DEFAULT_MNC = "01"
 DEFAULT_RAC = 1
 DEFAULT_LAC = 1
+VzW_MCC = "311"
+VzW_MNC = "480"
 
 # IP address information for internet sharing
-#GATEWAY_IPV4_ADDRESS = "192.168.137.1"
-#UE_IPV4_ADDRESS_1 = "192.168.137.2"
-#UE_IPV4_ADDRESS_2 = "192.168.137.3"
-#UE_IPV4_ADDRESS_3 = "192.168.137.4"
-#DNS_IPV4_ADDRESS = "192.168.137.1"
-#CSCF_IPV4_ADDRESS = "192.168.137.1"
+#GATEWAY_IPV4_ADDR = "192.168.137.1"
+#UE_IPV4_ADDR_1 = "192.168.137.2"
+#UE_IPV4_ADDR_2 = "192.168.137.3"
+#UE_IPV4_ADDR_3 = "192.168.137.4"
+#DNS_IPV4_ADDR = "192.168.137.1"
+#CSCF_IPV4_ADDR = "192.168.137.1"
 
 # Default IP address in Smart Studio, work for Internet Sharing with and
 # without WLAN ePDG server. Remember to add 192.168.1.2 to Ethernet 0
 # on MD8475A after turn on Windows' Internet Coonection Sharing
-GATEWAY_IPV4_ADDRESS = "192.168.1.2"
-UE_IPV4_ADDRESS_1 = "192.168.1.1"
-UE_IPV4_ADDRESS_2 = "192.168.1.11"
-UE_IPV4_ADDRESS_3 = "192.168.1.21"
-DNS_IPV4_ADDRESS = "192.168.1.2"
-CSCF_IPV4_ADDRESS = "192.168.1.2"
-CSCF_IPV6_ADDRESS = "2001:0:0:1::2"
-
-# LTE BAND constants
-LTE_BAND_1 = 1
-LTE_BAND_2 = 2
-LTE_BAND_3 = 3
-LTE_BAND_4 = 4
-LTE_BAND_5 = 5
-LTE_BAND_7 = 7
-LTE_BAND_12 = 12
-LTE_BAND_13 = 13
-
-# WCDMA BAND constants
-WCDMA_BAND_1 = 1
-WCDMA_BAND_2 = 2
-WCDMA_BAND_4 = 4
-WCDMA_BAND_5 = 5
-WCDMA_BAND_8 = 8
+GATEWAY_IPV4_ADDR = "192.168.1.2"
+UE_IPV4_ADDR_1 = "192.168.1.1"
+UE_IPV4_ADDR_2 = "192.168.1.11"
+UE_IPV4_ADDR_3 = "192.168.1.21"
+UE_IPV6_ADDR_1 = "2001:0:0:1::1"
+UE_IPV6_ADDR_2 = "2001:0:0:1::11"
+UE_IPV6_ADDR_3 = "2001:0:0:1::21"
+DNS_IPV4_ADDR = "192.168.1.2"
+CSCF_IPV4_ADDR = "192.168.1.2"
+CSCF_IPV6_ADDR = "2001:0:0:1::2"
 
 # GSM BAND constants
 GSM_BAND_GSM450 = "GSM450"
@@ -123,40 +115,32 @@
 GSM_BAND_DCS1800 = "DCS1800"
 GSM_BAND_PCS1900 = "PCS1900"
 
-# CDMA 1X BAND constants
-CDMA1X_BAND_0 = 0
-CDMA1X_BAND_1 = 1
-
-# CDMA 1X DL Channel constants
-CDMA1X_CHANNEL_356 = 356
-CDMA1X_CHANNEL_600 = 600
-
-# CDMA 1X SID constants
-CDMA1X_SID_0 = 0
-
-# CDMA 1X NID constants
-CDMA1X_NID_65535 = 65535
-
-# EVDO constants
-EVDO_BAND_0 = 0
-EVDO_BAND_1 = 1
-EVDO_CHANNEL_356 = 356
-EVDO_CHANNEL_600 = 600
-EVDO_SECTOR_ID_0000 = "00000000,00000000,00000000,00000000"
+LTE_BAND_2 = 2
+LTE_BAND_4 = 4
+LTE_BAND_12 = 12
+WCDMA_BAND_1 = 1
+WCDMA_BAND_2 = 2
 
 # Default Cell Parameters
 DEFAULT_OUTPUT_LEVEL = -40
 DEFAULT_INPUT_LEVEL = -10  # apply to LTE & WCDMA only
-DEFAULT_LTE_BAND = LTE_BAND_2
-DEFAULT_WCDMA_BAND = WCDMA_BAND_1
+DEFAULT_LTE_BAND = 2
+DEFAULT_WCDMA_BAND = 1
 DEFAULT_GSM_BAND = GSM_BAND_GSM850
-DEFAULT_CDMA1X_BAND = CDMA1X_BAND_1
-DEFAULT_CDMA1X_CHANNEL = CDMA1X_CHANNEL_600
-DEFAULT_CDMA1X_SID = CDMA1X_SID_0
-DEFAULT_CDMA1X_NID = CDMA1X_NID_65535
-DEFAULT_EVDO_BAND = EVDO_BAND_0
-DEFAULT_EVDO_CHANNEL = EVDO_CHANNEL_356
-DEFAULT_EVDO_SECTOR_ID = EVDO_SECTOR_ID_0000
+DEFAULT_CDMA1X_BAND = 1
+DEFAULT_CDMA1X_CH = 0
+DEFAULT_CDMA1X_SID = 0
+DEFAULT_CDMA1X_NID = 65535
+DEFAULT_EVDO_BAND = 0
+DEFAULT_EVDO_CH = 356
+DEFAULT_EVDO_SECTOR_ID = "00000000,00000000,00000000,00000000"
+VzW_CDMA1x_BAND = 1
+VzW_CDMA1x_CH = 150
+VzW_CDMA1X_SID = 26
+VzW_CDMA1X_NID = 65535
+VzW_EVDO_BAND = 0
+VzW_EVDO_CH = 384
+VzW_EVDO_SECTOR_ID = "12345678,00000000,00000000,00000000"
 
 # CMAS Message IDs
 CMAS_MESSAGE_PRESIDENTIAL_ALERT = hex(0x1112)
@@ -235,6 +219,26 @@
         i += 1
 
 
+def set_usim_parameters(anritsu_handle, sim_card):
+    """ set USIM parameters in MD8475A simulationn parameter
+
+    Args:
+        anritsu_handle: anritusu device object.
+        sim_card : "P0250Ax" or "12349"
+
+    Returns:
+        None
+    """
+    if sim_card == P0250Ax:
+        anritsu_handle.usim_key = "000102030405060708090A0B0C0D0E0F"
+    elif sim_card == VzW12349:
+        anritsu_handle.usim_key = "465B5CE8B199B49FAA5F0A2EE238A6BC"
+        anritsu_handle.send_command("IMSI 311480012345678")
+        anritsu_handle.send_command("SECURITY3G MILENAGE")
+        anritsu_handle.send_command(
+            "MILENAGEOP 5F1D289C5D354D0A140C2548F5F3E3BA")
+
+
 def save_anritsu_log_files(anritsu_handle, test_name, user_params):
     """ saves the anritsu smart studio log files
         The logs should be saved in Anritsu system. Need to provide
@@ -273,7 +277,7 @@
     return "{}_{}".format(test_name, time_stamp)
 
 
-def _init_lte_bts(bts, user_params, cell_no):
+def _init_lte_bts(bts, user_params, cell_no, sim_card):
     """ initializes the LTE BTS
         All BTS parameters should be set here
 
@@ -288,14 +292,14 @@
     """
     bts.nw_fullname_enable = BtsNwNameEnable.NAME_ENABLE
     bts.nw_fullname = TEST_PLMN_LTE_NAME
-    bts.mcc = get_lte_mcc(user_params, cell_no)
-    bts.mnc = get_lte_mnc(user_params, cell_no)
+    bts.mcc = get_lte_mcc(user_params, cell_no, sim_card)
+    bts.mnc = get_lte_mnc(user_params, cell_no, sim_card)
     bts.band = get_lte_band(user_params, cell_no)
     bts.output_level = DEFAULT_OUTPUT_LEVEL
     bts.input_level = DEFAULT_INPUT_LEVEL
 
 
-def _init_wcdma_bts(bts, user_params, cell_no):
+def _init_wcdma_bts(bts, user_params, cell_no, sim_card):
     """ initializes the WCDMA BTS
         All BTS parameters should be set here
 
@@ -310,8 +314,8 @@
     """
     bts.nw_fullname_enable = BtsNwNameEnable.NAME_ENABLE
     bts.nw_fullname = TEST_PLMN_WCDMA_NAME
-    bts.mcc = get_lte_mcc(user_params, cell_no)
-    bts.mnc = get_lte_mnc(user_params, cell_no)
+    bts.mcc = get_wcdma_mcc(user_params, cell_no, sim_card)
+    bts.mnc = get_wcdma_mnc(user_params, cell_no, sim_card)
     bts.band = get_wcdma_band(user_params, cell_no)
     bts.rac = get_wcdma_rac(user_params, cell_no)
     bts.lac = get_wcdma_lac(user_params, cell_no)
@@ -319,7 +323,7 @@
     bts.input_level = DEFAULT_INPUT_LEVEL
 
 
-def _init_gsm_bts(bts, user_params, cell_no):
+def _init_gsm_bts(bts, user_params, cell_no, sim_card):
     """ initializes the GSM BTS
         All BTS parameters should be set here
 
@@ -334,15 +338,15 @@
     """
     bts.nw_fullname_enable = BtsNwNameEnable.NAME_ENABLE
     bts.nw_fullname = TEST_PLMN_GSM_NAME
-    bts.mcc = get_lte_mcc(user_params, cell_no)
-    bts.mnc = get_lte_mnc(user_params, cell_no)
+    bts.mcc = get_gsm_mcc(user_params, cell_no, sim_card)
+    bts.mnc = get_gsm_mnc(user_params, cell_no, sim_card)
     bts.band = get_gsm_band(user_params, cell_no)
     bts.rac = get_gsm_rac(user_params, cell_no)
     bts.lac = get_gsm_lac(user_params, cell_no)
     bts.output_level = DEFAULT_OUTPUT_LEVEL
 
 
-def _init_1x_bts(bts, user_params, cell_no):
+def _init_1x_bts(bts, user_params, cell_no, sim_card):
     """ initializes the 1X BTS
         All BTS parameters should be set here
 
@@ -355,15 +359,15 @@
     Returns:
         None
     """
-    bts.sector1_mcc = get_1x_mcc(user_params, cell_no)
-    bts.band = get_1x_band(user_params, cell_no)
-    bts.dl_channel = get_1x_channel(user_params, cell_no)
-    bts.sector1_sid = get_1x_sid(user_params, cell_no)
-    bts.sector1_nid = get_1x_nid(user_params, cell_no)
+    bts.sector1_mcc = get_1x_mcc(user_params, cell_no, sim_card)
+    bts.band = get_1x_band(user_params, cell_no, sim_card)
+    bts.dl_channel = get_1x_channel(user_params, cell_no, sim_card)
+    bts.sector1_sid = get_1x_sid(user_params, cell_no, sim_card)
+    bts.sector1_nid = get_1x_nid(user_params, cell_no, sim_card)
     bts.output_level = DEFAULT_OUTPUT_LEVEL
 
 
-def _init_evdo_bts(bts, user_params, cell_no):
+def _init_evdo_bts(bts, user_params, cell_no, sim_card):
     """ initializes the EVDO BTS
         All BTS parameters should be set here
 
@@ -376,13 +380,13 @@
     Returns:
         None
     """
-    bts.band = get_evdo_band(user_params, cell_no)
-    bts.dl_channel = get_evdo_channel(user_params, cell_no)
-    bts.evdo_sid = get_evdo_sid(user_params, cell_no)
+    bts.band = get_evdo_band(user_params, cell_no, sim_card)
+    bts.dl_channel = get_evdo_channel(user_params, cell_no, sim_card)
+    bts.evdo_sid = get_evdo_sid(user_params, cell_no, sim_card)
     bts.output_level = DEFAULT_OUTPUT_LEVEL
 
 
-def _init_PDN(anritsu_handle, pdn, ip_address, ims_binding):
+def _init_PDN(anritsu_handle, pdn, ipv4, ipv6, ims_binding):
     """ initializes the PDN parameters
         All PDN parameters should be set here
 
@@ -396,15 +400,16 @@
         None
     """
     # Setting IP address for internet connection sharing
-    anritsu_handle.gateway_ipv4addr = GATEWAY_IPV4_ADDRESS
-    pdn.ue_address_ipv4 = ip_address
+    anritsu_handle.gateway_ipv4addr = GATEWAY_IPV4_ADDR
+    pdn.ue_address_ipv4 = ipv4
+    pdn.ue_address_ipv6 = ipv6
     if ims_binding:
         pdn.pdn_ims = Switch.ENABLE
         pdn.pdn_vnid = DEFAULT_VNID
     else:
-        pdn.primary_dns_address_ipv4 = DNS_IPV4_ADDRESS
-        pdn.secondary_dns_address_ipv4 = DNS_IPV4_ADDRESS
-        pdn.cscf_address_ipv4 = CSCF_IPV4_ADDRESS
+        pdn.primary_dns_address_ipv4 = DNS_IPV4_ADDR
+        pdn.secondary_dns_address_ipv4 = DNS_IPV4_ADDR
+        pdn.cscf_address_ipv4 = CSCF_IPV4_ADDR
 
 
 def _init_IMS(anritsu_handle, vnid):
@@ -419,8 +424,8 @@
         None
     """
     # vnid.sync = Switch.ENABLE # supported in 6.40a release
-    vnid.cscf_address_ipv4 = CSCF_IPV4_ADDRESS
-    vnid.cscf_address_ipv6 = CSCF_IPV6_ADDRESS
+    vnid.cscf_address_ipv4 = CSCF_IPV4_ADDR
+    vnid.cscf_address_ipv6 = CSCF_IPV6_ADDR
     vnid.dns = Switch.DISABLE
     vnid.ndp_nic = NDP_NIC_NAME
     vnid.cscf_monitoring_ua = CSCF_Monitoring_UA_URI
@@ -428,7 +433,7 @@
     vnid.psap_auto_answer = Switch.ENABLE
 
 
-def set_system_model_lte_lte(anritsu_handle, user_params):
+def set_system_model_lte_lte(anritsu_handle, user_params, sim_card):
     """ Configures Anritsu system for LTE and LTE simulation
 
     Args:
@@ -442,21 +447,21 @@
     # setting BTS parameters
     lte1_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
     lte2_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
-    _init_lte_bts(lte1_bts, user_params, CELL_1)
-    _init_lte_bts(lte2_bts, user_params, CELL_2)
+    _init_lte_bts(lte1_bts, user_params, CELL_1, sim_card)
+    _init_lte_bts(lte2_bts, user_params, CELL_2, sim_card)
     pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
     pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
     pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
     # Initialize PDN IP address for internet connection sharing
-    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDRESS_1, True)
-    _init_PDN(anritsu_handle, pdn2, UE_IPV4_ADDRESS_2, False)
-    _init_PDN(anritsu_handle, pdn3, UE_IPV4_ADDRESS_3, True)
+    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True)
+    _init_PDN(anritsu_handle, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False)
+    _init_PDN(anritsu_handle, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True)
     vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID)
     _init_IMS(anritsu_handle, vnid1)
     return [lte1_bts, lte2_bts]
 
 
-def set_system_model_wcdma_wcdma(anritsu_handle, user_params):
+def set_system_model_wcdma_wcdma(anritsu_handle, user_params, sim_card):
     """ Configures Anritsu system for WCDMA and WCDMA simulation
 
     Args:
@@ -471,15 +476,15 @@
     # setting BTS parameters
     wcdma1_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
     wcdma2_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
-    _init_wcdma_bts(wcdma1_bts, user_params, CELL_1)
-    _init_wcdma_bts(wcdma2_bts, user_params, CELL_2)
+    _init_wcdma_bts(wcdma1_bts, user_params, CELL_1, sim_card)
+    _init_wcdma_bts(wcdma2_bts, user_params, CELL_2, sim_card)
     pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
     # Initialize PDN IP address for internet connection sharing
-    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDRESS_1, False)
+    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
     return [wcdma1_bts, wcdma2_bts]
 
 
-def set_system_model_lte_wcdma(anritsu_handle, user_params):
+def set_system_model_lte_wcdma(anritsu_handle, user_params, sim_card):
     """ Configures Anritsu system for LTE and WCDMA simulation
 
     Args:
@@ -493,21 +498,21 @@
     # setting BTS parameters
     lte_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
     wcdma_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
-    _init_lte_bts(lte_bts, user_params, CELL_1)
-    _init_wcdma_bts(wcdma_bts, user_params, CELL_2)
+    _init_lte_bts(lte_bts, user_params, CELL_1, sim_card)
+    _init_wcdma_bts(wcdma_bts, user_params, CELL_2, sim_card)
     pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
     pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
     pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
     # Initialize PDN IP address for internet connection sharing
-    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDRESS_1, True)
-    _init_PDN(anritsu_handle, pdn2, UE_IPV4_ADDRESS_2, False)
-    _init_PDN(anritsu_handle, pdn3, UE_IPV4_ADDRESS_3, True)
+    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True)
+    _init_PDN(anritsu_handle, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False)
+    _init_PDN(anritsu_handle, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True)
     vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID)
     _init_IMS(anritsu_handle, vnid1)
     return [lte_bts, wcdma_bts]
 
 
-def set_system_model_lte_gsm(anritsu_handle, user_params):
+def set_system_model_lte_gsm(anritsu_handle, user_params, sim_card):
     """ Configures Anritsu system for LTE and GSM simulation
 
     Args:
@@ -521,21 +526,21 @@
     # setting BTS parameters
     lte_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
     gsm_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
-    _init_lte_bts(lte_bts, user_params, CELL_1)
-    _init_gsm_bts(gsm_bts, user_params, CELL_2)
+    _init_lte_bts(lte_bts, user_params, CELL_1, sim_card)
+    _init_gsm_bts(gsm_bts, user_params, CELL_2, sim_card)
     pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
     pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
     pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
     # Initialize PDN IP address for internet connection sharing
-    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDRESS_1, True)
-    _init_PDN(anritsu_handle, pdn2, UE_IPV4_ADDRESS_2, False)
-    _init_PDN(anritsu_handle, pdn3, UE_IPV4_ADDRESS_3, True)
+    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True)
+    _init_PDN(anritsu_handle, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False)
+    _init_PDN(anritsu_handle, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True)
     vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID)
     _init_IMS(anritsu_handle, vnid1)
     return [lte_bts, gsm_bts]
 
 
-def set_system_model_lte_1x(anritsu_handle, user_params):
+def set_system_model_lte_1x(anritsu_handle, user_params, sim_card):
     """ Configures Anritsu system for LTE and 1x simulation
 
     Args:
@@ -550,21 +555,21 @@
     # setting BTS parameters
     lte_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
     cdma1x_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
-    _init_lte_bts(lte_bts, user_params, CELL_1)
-    _init_1x_bts(cdma1x_bts, user_params, CELL_2)
+    _init_lte_bts(lte_bts, user_params, CELL_1, sim_card)
+    _init_1x_bts(cdma1x_bts, user_params, CELL_2, sim_card)
     pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
     pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
     pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
     # Initialize PDN IP address for internet connection sharing
-    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDRESS_1, True)
-    _init_PDN(anritsu_handle, pdn2, UE_IPV4_ADDRESS_2, False)
-    _init_PDN(anritsu_handle, pdn3, UE_IPV4_ADDRESS_3, True)
+    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True)
+    _init_PDN(anritsu_handle, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False)
+    _init_PDN(anritsu_handle, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True)
     vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID)
     _init_IMS(anritsu_handle, vnid1)
     return [lte_bts, cdma1x_bts]
 
 
-def set_system_model_wcdma_gsm(anritsu_handle, user_params):
+def set_system_model_wcdma_gsm(anritsu_handle, user_params, sim_card):
     """ Configures Anritsu system for WCDMA and GSM simulation
 
     Args:
@@ -578,15 +583,15 @@
     # setting BTS parameters
     wcdma_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
     gsm_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
-    _init_wcdma_bts(wcdma_bts, user_params, CELL_1)
-    _init_gsm_bts(gsm_bts, user_params, CELL_2)
+    _init_wcdma_bts(wcdma_bts, user_params, CELL_1, sim_card)
+    _init_gsm_bts(gsm_bts, user_params, CELL_2, sim_card)
     pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
     # Initialize PDN IP address for internet connection sharing
-    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDRESS_1, False)
+    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
     return [wcdma_bts, gsm_bts]
 
 
-def set_system_model_gsm_gsm(anritsu_handle, user_params):
+def set_system_model_gsm_gsm(anritsu_handle, user_params, sim_card):
     """ Configures Anritsu system for GSM and GSM simulation
 
     Args:
@@ -600,15 +605,15 @@
     # setting BTS parameters
     gsm1_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
     gsm2_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
-    _init_gsm_bts(gsm1_bts, user_params, CELL_1)
-    _init_gsm_bts(gsm2_bts, user_params, CELL_2)
+    _init_gsm_bts(gsm1_bts, user_params, CELL_1, sim_card)
+    _init_gsm_bts(gsm2_bts, user_params, CELL_2, sim_card)
     pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
     # Initialize PDN IP address for internet connection sharing
-    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDRESS_1, False)
+    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
     return [gsm1_bts, gsm2_bts]
 
 
-def set_system_model_lte(anritsu_handle, user_params):
+def set_system_model_lte(anritsu_handle, user_params, sim_card):
     """ Configures Anritsu system for LTE simulation
 
     Args:
@@ -621,20 +626,20 @@
     anritsu_handle.set_simulation_model(BtsTechnology.LTE)
     # setting BTS parameters
     lte_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
-    _init_lte_bts(lte_bts, user_params, CELL_1)
+    _init_lte_bts(lte_bts, user_params, CELL_1, sim_card)
     pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
     pdn2 = anritsu_handle.get_PDN(PDN_NO_2)
     pdn3 = anritsu_handle.get_PDN(PDN_NO_3)
     # Initialize PDN IP address for internet connection sharing
-    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDRESS_1, True)
-    _init_PDN(anritsu_handle, pdn2, UE_IPV4_ADDRESS_2, False)
-    _init_PDN(anritsu_handle, pdn3, UE_IPV4_ADDRESS_3, True)
+    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, True)
+    _init_PDN(anritsu_handle, pdn2, UE_IPV4_ADDR_2, UE_IPV6_ADDR_2, False)
+    _init_PDN(anritsu_handle, pdn3, UE_IPV4_ADDR_3, UE_IPV6_ADDR_3, True)
     vnid1 = anritsu_handle.get_IMS(DEFAULT_VNID)
     _init_IMS(anritsu_handle, vnid1)
     return [lte_bts]
 
 
-def set_system_model_wcdma(anritsu_handle, user_params):
+def set_system_model_wcdma(anritsu_handle, user_params, sim_card):
     """ Configures Anritsu system for WCDMA simulation
 
     Args:
@@ -647,14 +652,14 @@
     anritsu_handle.set_simulation_model(BtsTechnology.WCDMA)
     # setting BTS parameters
     wcdma_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
-    _init_wcdma_bts(wcdma_bts, user_params, CELL_1)
+    _init_wcdma_bts(wcdma_bts, user_params, CELL_1, sim_card)
     pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
     # Initialize PDN IP address for internet connection sharing
-    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDRESS_1, False)
+    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
     return [wcdma_bts]
 
 
-def set_system_model_gsm(anritsu_handle, user_params):
+def set_system_model_gsm(anritsu_handle, user_params, sim_card):
     """ Configures Anritsu system for GSM simulation
 
     Args:
@@ -667,14 +672,14 @@
     anritsu_handle.set_simulation_model(BtsTechnology.GSM)
     # setting BTS parameters
     gsm_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
-    _init_gsm_bts(gsm_bts, user_params, CELL_1)
+    _init_gsm_bts(gsm_bts, user_params, CELL_1, sim_card)
     pdn1 = anritsu_handle.get_PDN(PDN_NO_1)
     # Initialize PDN IP address for internet connection sharing
-    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDRESS_1, False)
+    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
     return [gsm_bts]
 
 
-def set_system_model_1x(anritsu_handle, user_params):
+def set_system_model_1x(anritsu_handle, user_params, sim_card):
     """ Configures Anritsu system for CDMA 1X simulation
 
     Args:
@@ -688,14 +693,14 @@
     anritsu_handle.set_simulation_model(BtsTechnology.CDMA1X)
     # setting BTS parameters
     cdma1x_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
-    _init_1x_bts(cdma1x_bts, user_params, CELL_1)
+    _init_1x_bts(cdma1x_bts, user_params, CELL_1, sim_card)
     pdn1 = anritsu_handle.get_PDN(PDN_ONE)
     # Initialize PDN IP address for internet connection sharing
-    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDRESS_1, False)
+    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
     return [cdma1x_bts]
 
 
-def set_system_model_1x_evdo(anritsu_handle, user_params):
+def set_system_model_1x_evdo(anritsu_handle, user_params, sim_card):
     """ Configures Anritsu system for CDMA 1X simulation
 
     Args:
@@ -711,11 +716,11 @@
     # setting BTS parameters
     cdma1x_bts = anritsu_handle.get_BTS(BtsNumber.BTS1)
     evdo_bts = anritsu_handle.get_BTS(BtsNumber.BTS2)
-    _init_1x_bts(cdma1x_bts, user_params, CELL_1)
-    _init_evdo_bts(evdo_bts, user_params, CELL_1)
+    _init_1x_bts(cdma1x_bts, user_params, CELL_1, sim_card)
+    _init_evdo_bts(evdo_bts, user_params, CELL_2, sim_card)
     pdn1 = anritsu_handle.get_PDN(PDN_ONE)
     # Initialize PDN IP address for internet connection sharing
-    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDRESS_1, False)
+    _init_PDN(anritsu_handle, pdn1, UE_IPV4_ADDR_1, UE_IPV6_ADDR_1, False)
     return [cdma1x_bts]
 
 
@@ -1475,7 +1480,7 @@
     return gsm_band
 
 
-def get_1x_band(user_params, cell_no):
+def get_1x_band(user_params, cell_no, sim_card):
     """ Returns the 1X BAND to be used from the user specified parameters
         or default value
 
@@ -1488,14 +1493,11 @@
         1X BAND to be used
     """
     key = "cell{}_1x_band".format(cell_no)
-    try:
-        cdma_1x_band = user_params[key]
-    except KeyError:
-        cdma_1x_band = DEFAULT_CDMA1X_BAND
-    return cdma_1x_band
+    band = VzW_CDMA1x_BAND if sim_card == VzW12349 else DEFAULT_CDMA1x_BAND
+    return user_params.get(key, band)
 
 
-def get_evdo_band(user_params, cell_no):
+def get_evdo_band(user_params, cell_no, sim_card):
     """ Returns the EVDO BAND to be used from the user specified parameters
         or default value
 
@@ -1508,7 +1510,8 @@
         EVDO BAND to be used
     """
     key = "cell{}_evdo_band".format(cell_no)
-    return user_params.get(key, DEFAULT_EVDO_BAND)
+    band = VzW_EVDO_BAND if sim_card == VzW12349 else DEFAULT_EVDO_BAND
+    return user_params.get(key, band)
 
 
 def get_wcdma_rac(user_params, cell_no):
@@ -1591,7 +1594,7 @@
     return gsm_lac
 
 
-def get_lte_mcc(user_params, cell_no):
+def get_lte_mcc(user_params, cell_no, sim_card):
     """ Returns the LTE MCC to be used from the user specified parameters
         or default value
 
@@ -1603,15 +1606,13 @@
     Returns:
         LTE MCC to be used
     """
+
     key = "cell{}_lte_mcc".format(cell_no)
-    try:
-        lte_mcc = user_params[key]
-    except KeyError:
-        lte_mcc = DEFAULT_MCC
-    return lte_mcc
+    mcc = VzW_MCC if sim_card == VzW12349 else DEFAULT_MCC
+    return user_params.get(key, mcc)
 
 
-def get_lte_mnc(user_params, cell_no):
+def get_lte_mnc(user_params, cell_no, sim_card):
     """ Returns the LTE MNC to be used from the user specified parameters
         or default value
 
@@ -1624,14 +1625,11 @@
         LTE MNC to be used
     """
     key = "cell{}_lte_mnc".format(cell_no)
-    try:
-        lte_mnc = user_params[key]
-    except KeyError:
-        lte_mnc = DEFAULT_MNC
-    return lte_mnc
+    mnc = VzW_MNC if sim_card == VzW12349 else DEFAULT_MNC
+    return user_params.get(key, mnc)
 
 
-def get_wcdma_mcc(user_params, cell_no):
+def get_wcdma_mcc(user_params, cell_no, sim_card):
     """ Returns the WCDMA MCC to be used from the user specified parameters
         or default value
 
@@ -1644,14 +1642,11 @@
         WCDMA MCC to be used
     """
     key = "cell{}_wcdma_mcc".format(cell_no)
-    try:
-        wcdma_mcc = user_params[key]
-    except KeyError:
-        wcdma_mcc = DEFAULT_MCC
-    return wcdma_mcc
+    mcc = VzW_MCC if sim_card == VzW12349 else DEFAULT_MCC
+    return user_params.get(key, mcc)
 
 
-def get_wcdma_mnc(user_params, cell_no):
+def get_wcdma_mnc(user_params, cell_no, sim_card):
     """ Returns the WCDMA MNC to be used from the user specified parameters
         or default value
 
@@ -1664,14 +1659,11 @@
         WCDMA MNC to be used
     """
     key = "cell{}_wcdma_mnc".format(cell_no)
-    try:
-        wcdma_mnc = user_params[key]
-    except KeyError:
-        wcdma_mnc = DEFAULT_MNC
-    return wcdma_mnc
+    mnc = VzW_MNC if sim_card == VzW12349 else DEFAULT_MNC
+    return user_params.get(key, mnc)
 
 
-def get_gsm_mcc(user_params, cell_no):
+def get_gsm_mcc(user_params, cell_no, sim_card):
     """ Returns the GSM MCC to be used from the user specified parameters
         or default value
 
@@ -1684,14 +1676,11 @@
         GSM MCC to be used
     """
     key = "cell{}_gsm_mcc".format(cell_no)
-    try:
-        gsm_mcc = user_params[key]
-    except KeyError:
-        gsm_mcc = DEFAULT_MCC
-    return gsm_mcc
+    mcc = VzW_MCC if sim_card == VzW12349 else DEFAULT_MCC
+    return user_params.get(key, mcc)
 
 
-def get_gsm_mnc(user_params, cell_no):
+def get_gsm_mnc(user_params, cell_no, sim_card):
     """ Returns the GSM MNC to be used from the user specified parameters
         or default value
 
@@ -1704,14 +1693,11 @@
         GSM MNC to be used
     """
     key = "cell{}_gsm_mnc".format(cell_no)
-    try:
-        gsm_mnc = user_params[key]
-    except KeyError:
-        gsm_mnc = DEFAULT_MNC
-    return gsm_mnc
+    mnc = VzW_MNC if sim_card == VzW12349 else DEFAULT_MNC
+    return user_params.get(key, mnc)
 
 
-def get_1x_mcc(user_params, cell_no):
+def get_1x_mcc(user_params, cell_no, sim_card):
     """ Returns the 1X MCC to be used from the user specified parameters
         or default value
 
@@ -1724,14 +1710,11 @@
         1X MCC to be used
     """
     key = "cell{}_1x_mcc".format(cell_no)
-    try:
-        cdma_1x_mcc = user_params[key]
-    except KeyError:
-        cdma_1x_mcc = DEFAULT_MCC
-    return cdma_1x_mcc
+    mcc = VzW_MCC if sim_card == VzW12349 else DEFAULT_MCC
+    return user_params.get(key, mcc)
 
 
-def get_1x_channel(user_params, cell_no):
+def get_1x_channel(user_params, cell_no, sim_card):
     """ Returns the 1X Channel to be used from the user specified parameters
         or default value
 
@@ -1744,10 +1727,11 @@
         1X Channel to be used
     """
     key = "cell{}_1x_channel".format(cell_no)
-    return user_params.get(key, DEFAULT_CDMA1X_CHANNEL)
+    ch = VzW_CDMA1x_CH if sim_card == VzW12349 else DEFAULT_CDMA1X_CH
+    return user_params.get(key, ch)
 
 
-def get_1x_sid(user_params, cell_no):
+def get_1x_sid(user_params, cell_no, sim_card):
     """ Returns the 1X SID to be used from the user specified parameters
         or default value
 
@@ -1760,14 +1744,11 @@
         1X SID to be used
     """
     key = "cell{}_1x_sid".format(cell_no)
-    try:
-        cdma_1x_sid = user_params[key]
-    except KeyError:
-        cdma_1x_sid = CDMA1X_SID_0
-    return cdma_1x_sid
+    sid = VzW_CDMA1X_SID if sim_card == VzW12349 else DEFAULT_CDMA1X_SID
+    return user_params.get(key, sid)
 
 
-def get_1x_nid(user_params, cell_no):
+def get_1x_nid(user_params, cell_no, sim_card):
     """ Returns the 1X NID to be used from the user specified parameters
         or default value
 
@@ -1780,10 +1761,11 @@
         1X NID to be used
     """
     key = "cell{}_1x_nid".format(cell_no)
-    return user_params.get(key, CDMA1X_NID_65535)
+    nid = VzW_CDMA1X_NID if sim_card == VzW12349 else DEFAULT_CDMA1X_NID
+    return user_params.get(key, nid)
 
 
-def get_evdo_channel(user_params, cell_no):
+def get_evdo_channel(user_params, cell_no, sim_card):
     """ Returns the EVDO Channel to be used from the user specified parameters
         or default value
 
@@ -1796,10 +1778,11 @@
         EVDO Channel to be used
     """
     key = "cell{}_evdo_channel".format(cell_no)
-    return user_params.get(key, DEFAULT_EVDO_CHANNEL)
+    ch = VzW_EVDO_CH if sim_card == VzW12349 else DEFAULT_EVDO_CH
+    return user_params.get(key, ch)
 
 
-def get_evdo_sid(user_params, cell_no):
+def get_evdo_sid(user_params, cell_no, sim_card):
     """ Returns the EVDO SID to be used from the user specified parameters
         or default value
 
@@ -1813,6 +1796,8 @@
     """
     key = "cell{}_evdo_sid".format(cell_no)
     return user_params.get(key, DEFAULT_EVDO_SECTOR_ID)
+    sid = VzW_EVDO_SECTOR_ID if sim_card == VzW12349 else DEFAULT_EVDO_SECTOR_ID
+    return user_params.get(key, sid)
 
 
 def get_csfb_type(user_params):
diff --git a/acts/framework/acts/test_utils/tel/tel_data_utils.py b/acts/framework/acts/test_utils/tel/tel_data_utils.py
index ad8d731..ac0bfd4 100644
--- a/acts/framework/acts/test_utils/tel/tel_data_utils.py
+++ b/acts/framework/acts/test_utils/tel/tel_data_utils.py
@@ -34,7 +34,7 @@
 from acts.test_utils.tel.tel_test_utils import rat_generation_from_rat
 from acts.test_utils.tel.tel_test_utils import set_wifi_to_default
 from acts.test_utils.tel.tel_test_utils import toggle_airplane_mode
-from acts.test_utils.tel.tel_test_utils import verify_http_connection
+from acts.test_utils.tel.tel_test_utils import verify_internet_connection
 from acts.test_utils.tel.tel_test_utils import wait_for_cell_data_connection
 from acts.test_utils.tel.tel_test_utils import wait_for_wifi_data_connection
 from acts.test_utils.tel.tel_test_utils import wait_for_data_attach_for_subscription
@@ -113,7 +113,8 @@
     log.info("--->Start wifi_tethering_setup_teardown<---")
     log.info("Provider: {}".format(provider.serial))
     if not provider.droid.connectivityIsTetheringSupported():
-        log.error("Provider does not support tethering. Stop tethering test.")
+        provider.log.error(
+            "Provider does not support tethering. Stop tethering test.")
         return False
 
     if ssid is None:
@@ -132,49 +133,45 @@
             client.droid.telephonyToggleDataConnection(False)
         log.info("WiFI Tethering: Verify client have no Internet access.")
         for client in client_list:
-            if verify_http_connection(log, client):
-                log.error("Turn off Data on client fail. {}".format(
-                    client.serial))
+            if verify_internet_connection(log, client):
+                client.log.error("Turn off Data on client fail")
                 return False
 
-        log.info(
-            "WiFI Tethering: Turn on WiFi tethering on {}. SSID: {}, password: {}".
-            format(provider.serial, ssid, password))
+        provider.log.info(
+            "Provider turn on WiFi tethering. SSID: %s, password: %s", ssid,
+            password)
 
         if not start_wifi_tethering(log, provider, ssid, password, ap_band):
-            log.error("Provider start WiFi tethering failed.")
+            provider.log.error("Provider start WiFi tethering failed.")
             return False
         time.sleep(WAIT_TIME_ANDROID_STATE_SETTLING)
 
-        log.info("Provider {} check Internet connection.".format(
-            provider.serial))
-        if not verify_http_connection(log, provider):
+        provider.log.info("Provider check Internet connection.")
+        if not verify_internet_connection(log, provider):
             return False
         for client in client_list:
-            log.info(
-                "WiFI Tethering: {} connect to WiFi and verify AP band correct.".
-                format(client.serial))
+            client.log.info(
+                "Client connect to WiFi and verify AP band correct.")
             if not ensure_wifi_connected(log, client, ssid, password):
-                log.error("Client connect to WiFi failed.")
+                client.log.error("Client connect to WiFi failed.")
                 return False
 
             wifi_info = client.droid.wifiGetConnectionInfo()
             if ap_band == WIFI_CONFIG_APBAND_5G:
                 if wifi_info["is_24ghz"]:
-                    log.error("Expected 5g network. WiFi Info: {}".format(
-                        wifi_info))
+                    client.log.error("Expected 5g network. WiFi Info: %s",
+                                     wifi_info)
                     return False
             else:
                 if wifi_info["is_5ghz"]:
-                    log.error("Expected 2g network. WiFi Info: {}".format(
-                        wifi_info))
+                    client.log.error("Expected 2g network. WiFi Info: %s",
+                                     wifi_info)
                     return False
 
-            log.info("Client{} check Internet connection.".format(
-                client.serial))
+            client.log.info("Client check Internet connection.")
             if (not wait_for_wifi_data_connection(log, client, True) or
-                    not verify_http_connection(log, client)):
-                log.error("No WiFi Data on client: {}.".format(client.serial))
+                    not verify_internet_connection(log, client)):
+                client.log.error("No WiFi Data on client")
                 return False
 
         if not tethering_check_internet_connection(
@@ -207,18 +204,24 @@
     Returns:
         True if no error happened. False otherwise.
     """
-    for i in range(1, check_iteration):
+    for i in range(1, check_iteration + 1):
+        result = True
         time.sleep(check_interval)
-        log.info("Provider {} check Internet connection after {} seconds.".
-                 format(provider.serial, check_interval * i))
-        if not verify_http_connection(log, provider):
-            return False
+        provider.log.info(
+            "Provider check Internet connection after %s seconds.",
+            check_interval * i)
+        if not verify_internet_connection(log, provider):
+            result = False
+            continue
         for client in client_list:
-            log.info("Client {} check Internet connection after {} seconds.".
-                     format(client.serial, check_interval * i))
-            if not verify_http_connection(log, client):
-                return False
-    return True
+            client.log.info(
+                "Client check Internet connection after %s seconds.",
+                check_interval * i)
+            if not verify_internet_connection(log, client):
+                result = False
+                break
+        if result: return result
+    return False
 
 
 def wifi_cell_switching(log, ad, wifi_network_ssid, wifi_network_pass, nw_gen):
@@ -244,16 +247,17 @@
     try:
 
         if not ensure_network_generation_for_subscription(
-                log, ad, get_default_data_sub_id(ad), nw_gen,
+                log, ad,
+                get_default_data_sub_id(ad), nw_gen,
                 MAX_WAIT_TIME_NW_SELECTION, NETWORK_SERVICE_DATA):
-            log.error("Device failed to register in {}".format(nw_gen))
+            ad.log.error("Device failed to register in %s", nw_gen)
             return False
 
         # Ensure WiFi can connect to live network
-        log.info("Make sure phone can connect to live network by WIFI")
+        ad.log.info("Make sure phone can connect to live network by WIFI")
         if not ensure_wifi_connected(log, ad, wifi_network_ssid,
                                      wifi_network_pass):
-            log.error("WiFi connect fail.")
+            ad.log.error("WiFi connect fail.")
             return False
         log.info("Phone connected to WIFI.")
 
@@ -262,29 +266,29 @@
         wifi_toggle_state(log, ad, True)
         ad.droid.telephonyToggleDataConnection(True)
         if (not wait_for_wifi_data_connection(log, ad, True) or
-                not verify_http_connection(log, ad)):
-            log.error("Data is not on WiFi")
+                not verify_internet_connection(log, ad)):
+            ad.log.error("Data is not on WiFi")
             return False
 
         log.info("Step2 WiFi is Off, Data is on Cell.")
         wifi_toggle_state(log, ad, False)
         if (not wait_for_cell_data_connection(log, ad, True) or
-                not verify_http_connection(log, ad)):
-            log.error("Data did not return to cell")
+                not verify_internet_connection(log, ad)):
+            ad.log.error("Data did not return to cell")
             return False
 
         log.info("Step3 WiFi is On, Data is on WiFi.")
         wifi_toggle_state(log, ad, True)
         if (not wait_for_wifi_data_connection(log, ad, True) or
-                not verify_http_connection(log, ad)):
-            log.error("Data did not return to WiFi")
+                not verify_internet_connection(log, ad)):
+            ad.log.error("Data did not return to WiFi")
             return False
 
         log.info("Step4 WiFi is Off, Data is on Cell.")
         wifi_toggle_state(log, ad, False)
         if (not wait_for_cell_data_connection(log, ad, True) or
-                not verify_http_connection(log, ad)):
-            log.error("Data did not return to cell")
+                not verify_internet_connection(log, ad)):
+            ad.log.error("Data did not return to cell")
             return False
         return True
 
@@ -317,36 +321,36 @@
 
         log.info("Step1: ensure attach")
         if not toggle_airplane_mode(log, ad, False):
-            log.error("Failed initial attach")
+            ad.log.error("Failed initial attach")
             return False
-        if not verify_http_connection(log, ad):
-            log.error("Data not available on cell.")
+        if not verify_internet_connection(log, ad):
+            ad.log.error("Data not available on cell.")
             return False
 
         log.info("Step2: enable airplane mode and ensure detach")
         if not toggle_airplane_mode(log, ad, True):
-            log.error("Failed to enable Airplane Mode")
+            ad.log.error("Failed to enable Airplane Mode")
             return False
         if not wait_for_cell_data_connection(log, ad, False):
-            log.error("Failed to disable cell data connection")
+            ad.log.error("Failed to disable cell data connection")
             return False
-        if verify_http_connection(log, ad):
-            log.error("Data available in airplane mode.")
+        if verify_internet_connection(log, ad):
+            ad.log.error("Data available in airplane mode.")
             return False
 
         log.info("Step3: disable airplane mode and ensure attach")
         if not toggle_airplane_mode(log, ad, False):
-            log.error("Failed to disable Airplane Mode")
+            ad.log.error("Failed to disable Airplane Mode")
             return False
 
         if not wait_for_cell_data_connection(log, ad, True):
-            log.error("Failed to enable cell data connection")
+            ad.log.error("Failed to enable cell data connection")
             return False
 
         time.sleep(WAIT_TIME_ANDROID_STATE_SETTLING)
 
         log.info("Step4 verify internet")
-        return verify_http_connection(log, ad)
+        return verify_internet_connection(log, ad)
     finally:
         toggle_airplane_mode(log, ad, False)
 
@@ -372,11 +376,12 @@
     ensure_phones_idle(log, [ad])
     wait_time = MAX_WAIT_TIME_NW_SELECTION
     if getattr(ad, 'roaming', False):
-       wait_time = 2 * wait_time
+        wait_time = 2 * wait_time
     if not ensure_network_generation_for_subscription(
-            log, ad, get_default_data_sub_id(ad), nw_gen,
-            MAX_WAIT_TIME_NW_SELECTION, NETWORK_SERVICE_DATA):
-        ad.log.error("Device failed to connect to %s in %ss.", nw_gen,
+            log, ad,
+            get_default_data_sub_id(ad), nw_gen, MAX_WAIT_TIME_NW_SELECTION,
+            NETWORK_SERVICE_DATA):
+        ad.log.error("Device failed to connect to %s in %s seconds.", nw_gen,
                      wait_time)
         return False
 
@@ -385,42 +390,43 @@
         toggle_airplane_mode(log, ad, False)
         ad.droid.telephonyToggleDataConnection(True)
         if not wait_for_cell_data_connection(log, ad, True):
-            log.error("Failed to enable data connection.")
+            ad.log.error("Failed to enable data connection.")
             return False
 
         log.info("Step2 Verify internet")
-        if not verify_http_connection(log, ad):
-            log.error("Data not available on cell.")
+        if not verify_internet_connection(log, ad):
+            ad.log.error("Data not available on cell.")
             return False
 
         log.info("Step3 Turn off data and verify not connected.")
         ad.droid.telephonyToggleDataConnection(False)
         if not wait_for_cell_data_connection(log, ad, False):
-            log.error("Step3 Failed to disable data connection.")
+            ad.log.error("Step3 Failed to disable data connection.")
             return False
 
-        if verify_http_connection(log, ad):
-            log.error("Step3 Data still available when disabled.")
+        if verify_internet_connection(log, ad):
+            ad.log.error("Step3 Data still available when disabled.")
             return False
 
         log.info("Step4 Re-enable data.")
         ad.droid.telephonyToggleDataConnection(True)
         if not wait_for_cell_data_connection(log, ad, True):
-            log.error("Step4 failed to re-enable data.")
+            ad.log.error("Step4 failed to re-enable data.")
             return False
-        if not verify_http_connection(log, ad):
-            log.error("Data not available on cell.")
+        if not verify_internet_connection(log, ad):
+            ad.log.error("Data not available on cell.")
             return False
 
         if not is_droid_in_network_generation_for_subscription(
-                log, ad, get_default_data_sub_id(ad), nw_gen,
-                NETWORK_SERVICE_DATA):
-            log.error("Failed: droid is no longer on correct network")
-            log.info("Expected:{}, Current:{}".format(
-                nw_gen, rat_generation_from_rat(
+                log, ad,
+                get_default_data_sub_id(ad), nw_gen, NETWORK_SERVICE_DATA):
+            ad.log.error("Failed: droid is no longer on correct network")
+            ad.log.info(
+                "Expected:%s, Current:%s", nw_gen,
+                rat_generation_from_rat(
                     get_network_rat_for_subscription(
-                        log, ad, get_default_data_sub_id(
-                            ad), NETWORK_SERVICE_DATA))))
+                        log, ad,
+                        get_default_data_sub_id(ad), NETWORK_SERVICE_DATA)))
             return False
         return True
     finally:
@@ -439,13 +445,13 @@
         Data SIM changed successfully, data attached and Internet access is OK.
     """
     sub_id = get_subid_from_slot_index(log, ad, sim_slot)
-    log.info("Change Data to subId: {}, SIM slot: {}".format(sub_id, sim_slot))
+    ad.log.info("Change Data to subId: %s, SIM slot: %s", sub_id, sim_slot)
     set_subid_for_data(ad, sub_id)
     if not wait_for_data_attach_for_subscription(log, ad, sub_id,
                                                  MAX_WAIT_TIME_NW_SELECTION):
-        log.error("Failed to attach data on subId:{}".format(sub_id))
+        ad.log.error("Failed to attach data on subId:%s", sub_id)
         return False
-    if not verify_http_connection(log, ad):
-        log.error("No Internet access after changing Data SIM.")
+    if not verify_internet_connection(log, ad):
+        ad.log.error("No Internet access after changing Data SIM.")
         return False
     return True
diff --git a/acts/framework/acts/test_utils/tel/tel_defines.py b/acts/framework/acts/test_utils/tel/tel_defines.py
index 346ca23..48c4bdd 100644
--- a/acts/framework/acts/test_utils/tel/tel_defines.py
+++ b/acts/framework/acts/test_utils/tel/tel_defines.py
@@ -94,7 +94,7 @@
 MAX_WAIT_TIME_TETHERING_ENTITLEMENT_CHECK = 15
 
 # Max time to wait for voice mail count report correct result.
-MAX_WAIT_TIME_VOICE_MAIL_COUNT = 30
+MAX_WAIT_TIME_VOICE_MAIL_COUNT = 90
 
 # Max time to wait for data SIM change
 MAX_WAIT_TIME_DATA_SUB_CHANGE = 150
diff --git a/acts/framework/acts/test_utils/tel/tel_lookup_tables.py b/acts/framework/acts/test_utils/tel/tel_lookup_tables.py
index 26c83e3..a33569c 100644
--- a/acts/framework/acts/test_utils/tel/tel_lookup_tables.py
+++ b/acts/framework/acts/test_utils/tel/tel_lookup_tables.py
@@ -113,12 +113,21 @@
     return None
 
 
+def get_ee_voice_mail_number():
+    return "+447953222222"
+
+
 def get_voice_mail_number_function(operator):
-    return _TelTables.voice_mail_number_get_function_tbl[operator]
+    return _TelTables.voice_mail_number_get_function_tbl.get(operator)
 
 
 def get_voice_mail_count_check_function(operator):
-    return _TelTables.voice_mail_count_check_function_tbl[operator]
+    return _TelTables.voice_mail_count_check_function_tbl.get(
+        operator, check_tmo_voice_mail_count)
+
+
+def get_voice_mail_delete_digit(operator):
+    return _TelTables.voice_mail_delete_digit_tbl.get(operator, "7")
 
 
 def get_allowable_network_preference(operator, phone_type=None):
@@ -627,7 +636,8 @@
         tel_defines.CARRIER_TMO: get_tmo_voice_mail_number,
         tel_defines.CARRIER_VZW: get_vzw_voice_mail_number,
         tel_defines.CARRIER_ATT: get_att_voice_mail_number,
-        tel_defines.CARRIER_SPT: get_spt_voice_mail_number
+        tel_defines.CARRIER_SPT: get_spt_voice_mail_number,
+        tel_defines.CARRIER_EEUK: get_ee_voice_mail_number
     }
 
     voice_mail_count_check_function_tbl = {
@@ -636,6 +646,8 @@
         tel_defines.CARRIER_SPT: check_spt_voice_mail_count
     }
 
+    voice_mail_delete_digit_tbl = {tel_defines.CARRIER_EEUK: "3"}
+
 
 device_capabilities = {
     NexusModelNames.ONE:
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 24a9b85..62967d7 100644
--- a/acts/framework/acts/test_utils/tel/tel_test_utils.py
+++ b/acts/framework/acts/test_utils/tel/tel_test_utils.py
@@ -116,6 +116,7 @@
 from acts.test_utils.tel.tel_lookup_tables import \
     get_voice_mail_count_check_function
 from acts.test_utils.tel.tel_lookup_tables import get_voice_mail_number_function
+from acts.test_utils.tel.tel_lookup_tables import get_voice_mail_delete_digit
 from acts.test_utils.tel.tel_lookup_tables import \
     network_preference_for_generaton
 from acts.test_utils.tel.tel_lookup_tables import operator_name_from_plmn_id
@@ -136,6 +137,7 @@
     get_incoming_message_sub_id
 from acts.test_utils.wifi import wifi_test_utils
 from acts.test_utils.wifi import wifi_constants
+from acts.utils import adb_shell_ping
 from acts.utils import load_config
 
 WIFI_SSID_KEY = wifi_test_utils.WifiEnums.SSID_KEY
@@ -883,7 +885,7 @@
 
     if not wait_for_ringing_call_for_subscription(log, ad, sub_id,
                                                   incoming_number):
-        log.error("Could not reject a call: phone never rang.")
+        ad.log.error("Could not reject a call: phone never rang.")
         return False
 
     ad.ed.clear_all_events()
@@ -891,7 +893,6 @@
     if reject is True:
         # Delay between ringing and reject.
         time.sleep(delay_reject)
-        log.info("Reject on callee.")
         is_find = False
         # Loop the call list and find the matched one to disconnect.
         for call in ad.droid.telecomCallGetCallIds():
@@ -899,13 +900,14 @@
                     get_number_from_tel_uri(get_call_uri(ad, call)),
                     incoming_number):
                 ad.droid.telecomCallDisconnect(call)
+                ad.log.info("Callee reject the call")
                 is_find = True
         if is_find is False:
-            log.error("Did not find matching call to reject.")
+            ad.log.error("Callee did not find matching call to reject.")
             return False
     else:
         # don't reject on callee. Just ignore the incoming call.
-        log.info("Received incoming call. Ignore it.")
+        ad.log.info("Callee received incoming call. Ignore it.")
     try:
         ad.ed.wait_for_event(
             EventCallStateChanged,
@@ -914,7 +916,7 @@
             field=CallStateContainer.CALL_STATE,
             value_list=[TELEPHONY_STATE_IDLE, TELEPHONY_STATE_OFFHOOK])
     except Empty:
-        log.error("No onCallStateChangedIdle event received.")
+        ad.log.error("No onCallStateChangedIdle event received.")
         return False
     finally:
         ad.droid.telephonyStopTrackingCallStateChangeForSubscription(sub_id)
@@ -1201,6 +1203,13 @@
     ad_caller.log.info("Call from %s to %s", caller_number, callee_number)
 
     try:
+        voice_mail_count_before = ad_callee.droid.telephonyGetVoiceMailCountForSubscription(
+            subid_callee)
+        ad_callee.log.info("voice mail count is %s", voice_mail_count_before)
+        # -1 means there are unread voice mail, but the count is unknown
+        # 0 means either this API not working (VZW) or no unread voice mail.
+        if voice_mail_count_before != 0:
+            log.warning("--Pending new Voice Mail, please clear on phone.--")
 
         if not initiate_call(log, ad_caller, callee_number):
             raise _CallSequenceException("Initiate call failed.")
@@ -1211,13 +1220,6 @@
 
         ad_callee.droid.telephonyStartTrackingVoiceMailStateChangeForSubscription(
             subid_callee)
-        voice_mail_count_before = ad_callee.droid.telephonyGetVoiceMailCountForSubscription(
-            subid_callee)
-
-        # -1 means there are unread voice mail, but the count is unknown
-        # 0 means either this API not working (VZW) or no unread voice mail.
-        if voice_mail_count_before != 0:
-            log.warning("--Pending new Voice Mail, please clear on phone.--")
 
         # ensure that all internal states are updated in telecom
         time.sleep(WAIT_TIME_ANDROID_STATE_SETTLING)
@@ -1228,7 +1230,6 @@
 
         # TODO: b/26293512 Need to play some sound to leave message.
         # Otherwise carrier voice mail server may drop this voice mail.
-
         time.sleep(wait_time_in_call)
 
         if not verify_caller_func:
@@ -1237,8 +1238,8 @@
             caller_state_result = verify_caller_func(log, ad_caller)
         if not caller_state_result:
             raise _CallSequenceException(
-                "Caller not in correct state after {} seconds".format(
-                    wait_time_in_call))
+                "Caller %s not in correct state after %s seconds" %
+                (ad_caller.serial, wait_time_in_call))
 
         if not hangup_call(log, ad_caller):
             raise _CallSequenceException("Error in Hanging-Up Call")
@@ -1250,6 +1251,8 @@
                 _is_on_message_waiting_event_true)
             log.info(event)
         except Empty:
+            ad_callee.log.warning("No expected event %s",
+                                  EventMessageWaitingIndicatorChanged)
             raise _CallSequenceException("No expected event {}.".format(
                 EventMessageWaitingIndicatorChanged))
         voice_mail_count_after = ad_callee.droid.telephonyGetVoiceMailCountForSubscription(
@@ -1264,7 +1267,7 @@
         # -1 means there are unread voice mail, but the count is unknown
         if not check_voice_mail_count(log, ad_callee, voice_mail_count_before,
                                       voice_mail_count_after):
-            log.error("telephonyGetVoiceMailCount output is incorrect.")
+            log.error("before and after voice mail count is not incorrect.")
             return False
 
     except _CallSequenceException as e:
@@ -1302,26 +1305,33 @@
         False if error happens. True is succeed.
     """
     log.info("Erase all pending voice mail.")
-    if ad.droid.telephonyGetVoiceMailCount() == 0:
-        log.info("No Pending voice mail.")
+    count = ad.droid.telephonyGetVoiceMailCount()
+    if count == 0:
+        ad.log.info("No Pending voice mail.")
         return True
+    if count == -1:
+        ad.log.info("There is pending voice mail, but the count is unknown")
+        count = MAX_SAVED_VOICE_MAIL
+    else:
+        ad.log.info("There are %s voicemails", count)
 
     voice_mail_number = get_voice_mail_number(log, ad)
-
+    delete_digit = get_voice_mail_delete_digit(get_operator_name(log, ad))
     if not initiate_call(log, ad, voice_mail_number):
-        log.error("Initiate call failed.")
+        log.error("Initiate call to voice mail failed.")
         return False
     time.sleep(WAIT_TIME_VOICE_MAIL_SERVER_RESPONSE)
     callId = ad.droid.telecomCallGetCallIds()[0]
     time.sleep(WAIT_TIME_VOICE_MAIL_SERVER_RESPONSE)
-    count = MAX_SAVED_VOICE_MAIL
     while (is_phone_in_call(log, ad) and (count > 0)):
-        log.info("Press 7 to delete voice mail.")
-        ad.droid.telecomCallPlayDtmfTone(callId, VOICEMAIL_DELETE_DIGIT)
+        ad.log.info("Press %s to delete voice mail.", delete_digit)
+        ad.droid.telecomCallPlayDtmfTone(callId, delete_digit)
         ad.droid.telecomCallStopDtmfTone(callId)
         time.sleep(WAIT_TIME_VOICE_MAIL_SERVER_RESPONSE)
         count -= 1
-    log.info("Voice mail server dropped this call.")
+    if is_phone_in_call(log, ad):
+        hangup_call(log, ad)
+
     # wait for telephonyGetVoiceMailCount to update correct result
     remaining_time = MAX_WAIT_TIME_VOICE_MAIL_COUNT
     while ((remaining_time > 0) and
@@ -1513,8 +1523,8 @@
     """
     # make sure input_string is 10 digital
     # Remove white spaces, dashes, dots
-    input_string = input_string.replace(" ", "").replace(
-        "-", "").replace(".", "").strip("0")
+    input_string = input_string.replace(" ", "").replace("-", "").replace(
+        ".", "").strip("0")
     if not formatter:
         return input_string
     # Remove "1"  or "+1"from front
@@ -1632,7 +1642,7 @@
         return False
 
 
-def active_data_transfer_task(log, ad):
+def active_data_transfer_task(log, ad, file_name="5MB"):
     curl_capable = True
     try:
         out = ad.adb.shell("curl --version")
@@ -1646,23 +1656,50 @@
         # files available for download on the same website:
         # 1GB.zip, 512MB.zip, 200MB.zip, 50MB.zip, 20MB.zip, 10MB.zip, 5MB.zip
         # download file by adb command, as phone call will use sl4a
-        url = "http://download.thinkbroadband.com/5MB.zip"
-        file_size = 5000000
-        output_path = "/sdcard/Download/5MB.zip"
-        return (http_file_download_by_adb,
-                (log, ad, url, output_path, file_size))
+        url = "http://download.thinkbroadband.com/" + file_name + ".zip"
+        file_map_dict = {
+            '5MB': 5000000,
+            '10MB': 10000000,
+            '20MB': 20000000,
+            '50MB': 50000000,
+            '200MB': 200000000,
+            '512MB': 512000000,
+            '1GB': 1000000000
+        }
+        if file_name in file_map_dict:
+            file_size = file_map_dict[file_name]
+        else:
+            ad.log.warning("file_size provided for DL is not available")
+            return False
+        output_path = "/sdcard/Download/" + file_name + ".zip"
+        return (http_file_download_by_adb, (log, ad, url, output_path,
+                                            file_size))
 
 
-def active_data_transfer_test(log, ad):
-    task = active_data_transfer_task(log, ad)
+def active_data_transfer_test(log, ad, file_name="5MB"):
+    task = active_data_transfer_task(log, ad, file_name)
     return task[0](*task[1])
 
 
+def verify_internet_connection(log, ad):
+    """Verify internet connection by ping test.
+
+    Args:
+        log: log object
+        ad: Android Device Object.
+
+    """
+    ad.log.info("Verify internet connection")
+    return adb_shell_ping(ad, count=5, timeout=60, loss_tolerance=40)
+
+
 def iperf_test_by_adb(log,
                       ad,
                       iperf_server,
+                      port_num=None,
+                      reverse=False,
                       timeout=180,
-                      limit_rate=100000,
+                      limit_rate=None,
                       omit=10,
                       ipv6=False):
     """Iperf test by adb.
@@ -1670,14 +1707,17 @@
     Args:
         log: log object
         ad: Android Device Object.
-        url: The iperf host url".
+        iperf_Server: The iperf host url".
+        port_num: TCP/UDP server port
         timeout: timeout for file download to complete.
         limit_rate: iperf bandwidth option. None by default
         omit: the omit option provided in iperf command.
     """
     iperf_option = "-t %s -O %s -J" % (timeout, omit)
     if limit_rate: iperf_option += " -b %s" % limit_rate
+    if port_num: iperf_option += " -p %s" % port_num
     if ipv6: iperf_option += " -6"
+    if reverse: iperf_option += " -R"
     try:
         ad.log.info("Running adb iperf test with server %s", iperf_server)
         result, data = ad.run_iperf_client(
@@ -1696,14 +1736,15 @@
         ad.log.warning("Fail to run iperf test with exception %s", e)
         return False
 
+
 def http_file_download_by_adb(log,
                               ad,
                               url,
                               out_path=None,
                               expected_file_size=None,
                               remove_file_after_check=True,
-                              timeout=300,
-                              limit_rate=50000,
+                              timeout=900,
+                              limit_rate=None,
                               retry=3):
     """Download http file by adb curl.
 
@@ -1804,8 +1845,7 @@
                 connection_type, connection_type_string_in_event, cur_type)
             return False
 
-    if 'isConnected' in _event['data'] and _event['data'][
-            'isConnected'] == target_state:
+    if 'isConnected' in _event['data'] and _event['data']['isConnected'] == target_state:
         return True
     return False
 
@@ -1832,8 +1872,8 @@
         False if failed.
     """
     sub_id = get_default_data_sub_id(ad)
-    return wait_for_cell_data_connection_for_subscription(log, ad, sub_id,
-                                                          state, timeout_value)
+    return wait_for_cell_data_connection_for_subscription(
+        log, ad, sub_id, state, timeout_value)
 
 
 def _is_data_connection_state_match(log, ad, expected_data_connection_state):
@@ -1999,7 +2039,7 @@
         cur_data_connection_state = ad.droid.connectivityNetworkIsConnected()
         if is_connected == cur_data_connection_state:
             current_type = get_internet_connection_type(log, ad)
-            ad.log.info("current datat connection type: %s", current_type)
+            ad.log.info("current data connection type: %s", current_type)
             if not connection_type:
                 return True
             else:
@@ -3213,8 +3253,8 @@
 
     ad.log.info(
         "Ensure network %s %s %s. With network preference %s, "
-        "current: voice: %s(family: %s), data: %s(family: %s)",
-        generation, voice_or_data, result, network_preference,
+        "current: voice: %s(family: %s), data: %s(family: %s)", generation,
+        voice_or_data, result, network_preference,
         ad.droid.telephonyGetCurrentVoiceNetworkTypeForSubscription(sub_id),
         rat_generation_from_rat(
             ad.droid.telephonyGetCurrentVoiceNetworkTypeForSubscription(
@@ -3410,8 +3450,8 @@
             ad.log.info("network rat %s is expected %s", nw_rat, nw_gen)
             return True
         else:
-            ad.log.info("network rat %s is %s, expecting %s",
-                        nw_rat, rat_generation_from_rat(nw_rat), nw_gen)
+            ad.log.info("network rat %s is %s, expecting %s", nw_rat,
+                        rat_generation_from_rat(nw_rat), nw_gen)
             return False
 
     return False
@@ -3629,8 +3669,7 @@
         False if wifi is not connected to wifi_ssid
     """
     wifi_info = ad.droid.wifiGetConnectionInfo()
-    if wifi_info["supplicant_state"] == "completed" and wifi_info[
-            "SSID"] == wifi_ssid:
+    if wifi_info["supplicant_state"] == "completed" and wifi_info["SSID"] == wifi_ssid:
         ad.log.info("Wifi is connected to %s", wifi_ssid)
         return True
     else:
@@ -3665,9 +3704,10 @@
             return True
         else:
             ad.log.info("Connecting to wifi %s", wifi_ssid)
-            wifi_test_utils.wifi_connect(ad, network, 1, assert_on_fail=False)
+            ad.droid.wifiConnectByConfig(network)
             time.sleep(20)
             if check_is_wifi_connected(log, ad, wifi_ssid):
+                ad.log.info("Coneected to Wifi %s", wifi_ssid)
                 return True
     ad.log.info("Fail to connected to wifi %s", wifi_ssid)
     return False
@@ -4068,8 +4108,8 @@
     try:
         return (
             (network_callback_id == event['data'][NetworkCallbackContainer.ID])
-            and (network_callback_event == event['data'][
-                NetworkCallbackContainer.NETWORK_CALLBACK_EVENT]))
+            and (network_callback_event == event['data']
+                 [NetworkCallbackContainer.NETWORK_CALLBACK_EVENT]))
     except KeyError:
         return False
 
diff --git a/acts/framework/tests/acts_base_class_test.py b/acts/framework/tests/acts_base_class_test.py
index a6d8144..1093946 100755
--- a/acts/framework/tests/acts_base_class_test.py
+++ b/acts/framework/tests/acts_base_class_test.py
@@ -53,10 +53,9 @@
     def test_current_test_case_name(self):
         class MockBaseTest(base_test.BaseTestClass):
             def test_func(self):
-                asserts.assert_true(
-                    self.current_test_name == "test_func",
-                    ("Got "
-                     "unexpected test name %s.") % self.current_test_name)
+                asserts.assert_true(self.current_test_name == "test_func", (
+                    "Got "
+                    "unexpected test name %s.") % self.current_test_name)
 
         bt_cls = MockBaseTest(self.mock_test_cls_configs)
         bt_cls.run(test_names=["test_func"])
@@ -175,18 +174,16 @@
                 # This should not execute because setup_class failed.
                 never_call()
 
-            def on_fail(self, test_name, begin_time):
+            def on_blocked(self, test_name, begin_time):
                 call_check("haha")
 
         bt_cls = MockBaseTest(self.mock_test_cls_configs)
         bt_cls.run()
-        actual_record = bt_cls.results.failed[0]
-        self.assertEqual(actual_record.test_name, "setup_class")
-        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
-        self.assertIsNone(actual_record.extras)
+        actual_record = bt_cls.results.blocked[0]
+        self.assertEqual(actual_record.test_name, "test_something")
         expected_summary = (
-            "ControllerInfo {}, Executed 1, Failed 1, Passed 0, Requested 1, "
-            "Skipped 0, Unknown 0")
+            "Blocked 1, ControllerInfo {}, Executed 0, Failed 0, Passed 0,"
+            " Requested 1, Skipped 0, Unknown 0")
         self.assertEqual(bt_cls.results.summary_str(), expected_summary)
         call_check.assert_called_once_with("haha")
 
@@ -206,8 +203,8 @@
         self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
         self.assertIsNone(actual_record.extras)
         expected_summary = (
-            "ControllerInfo {}, Executed 1, Failed 0, Passed 0, Requested 1, "
-            "Skipped 0, Unknown 1")
+            "Blocked 0, ControllerInfo {}, Executed 1, Failed 0, Passed 0, "
+            "Requested 1, Skipped 0, Unknown 1")
         self.assertEqual(bt_cls.results.summary_str(), expected_summary)
 
     def test_setup_test_fail_by_test_signal(self):
@@ -226,8 +223,8 @@
         self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
         self.assertIsNone(actual_record.extras)
         expected_summary = (
-            "ControllerInfo {}, Executed 1, Failed 1, Passed 0, Requested 1, "
-            "Skipped 0, Unknown 0")
+            "Blocked 0, ControllerInfo {}, Executed 1, Failed 1, Passed 0, "
+            "Requested 1, Skipped 0, Unknown 0")
         self.assertEqual(bt_cls.results.summary_str(), expected_summary)
 
     def test_setup_test_fail_by_return_False(self):
@@ -247,8 +244,8 @@
         self.assertEqual(actual_record.details, expected_msg)
         self.assertIsNone(actual_record.extras)
         expected_summary = (
-            "ControllerInfo {}, Executed 1, Failed 1, Passed 0, Requested 1, "
-            "Skipped 0, Unknown 0")
+            "Blocked 0, ControllerInfo {}, Executed 1, Failed 1, Passed 0, "
+            "Requested 1, Skipped 0, Unknown 0")
         self.assertEqual(bt_cls.results.summary_str(), expected_summary)
 
     def test_teardown_test_assert_fail(self):
@@ -266,8 +263,8 @@
         self.assertIsNone(actual_record.details)
         self.assertIsNone(actual_record.extras)
         expected_summary = (
-            "ControllerInfo {}, Executed 1, Failed 0, Passed 0, Requested 1, "
-            "Skipped 0, Unknown 1")
+            "Blocked 0, ControllerInfo {}, Executed 1, Failed 0, Passed 0, "
+            "Requested 1, Skipped 0, Unknown 1")
         self.assertEqual(bt_cls.results.summary_str(), expected_summary)
 
     def test_teardown_test_raise_exception(self):
@@ -287,8 +284,8 @@
         expected_extra_error = {"teardown_test": MSG_EXPECTED_EXCEPTION}
         self.assertEqual(actual_record.extra_errors, expected_extra_error)
         expected_summary = (
-            "ControllerInfo {}, Executed 1, Failed 0, Passed 0, Requested 1, "
-            "Skipped 0, Unknown 1")
+            "Blocked 0, ControllerInfo {}, Executed 1, Failed 0, Passed 0, "
+            "Requested 1, Skipped 0, Unknown 1")
         self.assertEqual(bt_cls.results.summary_str(), expected_summary)
 
     def test_teardown_test_executed_if_test_pass(self):
@@ -309,8 +306,8 @@
         self.assertIsNone(actual_record.details)
         self.assertIsNone(actual_record.extras)
         expected_summary = (
-            "ControllerInfo {}, Executed 1, Failed 0, Passed 1, Requested 1, "
-            "Skipped 0, Unknown 0")
+            "Blocked 0, ControllerInfo {}, Executed 1, Failed 0, Passed 1, "
+            "Requested 1, Skipped 0, Unknown 0")
         self.assertEqual(bt_cls.results.summary_str(), expected_summary)
 
     def test_teardown_test_executed_if_setup_test_fails(self):
@@ -334,8 +331,8 @@
         self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
         self.assertIsNone(actual_record.extras)
         expected_summary = (
-            "ControllerInfo {}, Executed 1, Failed 0, Passed 0, Requested 1, "
-            "Skipped 0, Unknown 1")
+            "Blocked 0, ControllerInfo {}, Executed 1, Failed 0, Passed 0, "
+            "Requested 1, Skipped 0, Unknown 1")
         self.assertEqual(bt_cls.results.summary_str(), expected_summary)
 
     def test_teardown_test_executed_if_test_fails(self):
@@ -356,8 +353,8 @@
         self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
         self.assertIsNone(actual_record.extras)
         expected_summary = (
-            "ControllerInfo {}, Executed 1, Failed 0, Passed 0, Requested 1, "
-            "Skipped 0, Unknown 1")
+            "Blocked 0, ControllerInfo {}, Executed 1, Failed 0, Passed 0, "
+            "Requested 1, Skipped 0, Unknown 1")
         self.assertEqual(bt_cls.results.summary_str(), expected_summary)
 
     def test_on_exception_executed_if_teardown_test_fails(self):
@@ -381,8 +378,8 @@
         self.assertIsNone(actual_record.details)
         self.assertIsNone(actual_record.extras)
         expected_summary = (
-            "ControllerInfo {}, Executed 1, Failed 0, Passed 0, Requested 1, "
-            "Skipped 0, Unknown 1")
+            "Blocked 0, ControllerInfo {}, Executed 1, Failed 0, Passed 0, "
+            "Requested 1, Skipped 0, Unknown 1")
         self.assertEqual(bt_cls.results.summary_str(), expected_summary)
 
     def test_on_fail_executed_if_test_fails(self):
@@ -403,8 +400,8 @@
         self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
         self.assertIsNone(actual_record.extras)
         expected_summary = (
-            "ControllerInfo {}, Executed 1, Failed 1, Passed 0, Requested 1, "
-            "Skipped 0, Unknown 0")
+            "Blocked 0, ControllerInfo {}, Executed 1, Failed 1, Passed 0, "
+            "Requested 1, Skipped 0, Unknown 0")
         self.assertEqual(bt_cls.results.summary_str(), expected_summary)
 
     def test_on_fail_executed_if_test_setup_fails_by_exception(self):
@@ -428,8 +425,8 @@
         self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
         self.assertIsNone(actual_record.extras)
         expected_summary = (
-            "ControllerInfo {}, Executed 1, Failed 0, Passed 0, Requested 1, "
-            "Skipped 0, Unknown 1")
+            "Blocked 0, ControllerInfo {}, Executed 1, Failed 0, Passed 0, "
+            "Requested 1, Skipped 0, Unknown 1")
         self.assertEqual(bt_cls.results.summary_str(), expected_summary)
 
     def test_on_fail_executed_if_test_setup_fails_by_return_False(self):
@@ -454,8 +451,8 @@
                          'Setup for test_something failed.')
         self.assertIsNone(actual_record.extras)
         expected_summary = (
-            "ControllerInfo {}, Executed 1, Failed 1, Passed 0, Requested 1, "
-            "Skipped 0, Unknown 0")
+            "Blocked 0, ControllerInfo {}, Executed 1, Failed 1, Passed 0, "
+            "Requested 1, Skipped 0, Unknown 0")
         self.assertEqual(bt_cls.results.summary_str(), expected_summary)
 
     def test_failure_to_call_procedure_function_is_recorded(self):
@@ -474,8 +471,8 @@
         self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
         self.assertIsNone(actual_record.extras)
         expected_summary = (
-            "ControllerInfo {}, Executed 1, Failed 0, Passed 0, Requested 1, "
-            "Skipped 0, Unknown 1")
+            "Blocked 0, ControllerInfo {}, Executed 1, Failed 0, Passed 0, "
+            "Requested 1, Skipped 0, Unknown 1")
         self.assertEqual(bt_cls.results.summary_str(), expected_summary)
 
     def test_failure_in_procedure_functions_is_recorded(self):
@@ -497,8 +494,8 @@
         self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
         self.assertIsNone(actual_record.extras)
         expected_summary = (
-            "ControllerInfo {}, Executed 1, Failed 0, Passed 0, Requested 1, "
-            "Skipped 0, Unknown 1")
+            "Blocked 0, ControllerInfo {}, Executed 1, Failed 0, Passed 0, "
+            "Requested 1, Skipped 0, Unknown 1")
         self.assertEqual(bt_cls.results.summary_str(), expected_summary)
 
     def test_both_teardown_and_test_body_raise_exceptions(self):
@@ -518,8 +515,8 @@
         self.assertEqual(actual_record.extra_errors["teardown_test"],
                          "Details=This is an expected exception., Extras=None")
         expected_summary = (
-            "ControllerInfo {}, Executed 1, Failed 0, Passed 0, Requested 1, "
-            "Skipped 0, Unknown 1")
+            "Blocked 0, ControllerInfo {}, Executed 1, Failed 0, Passed 0, "
+            "Requested 1, Skipped 0, Unknown 1")
         self.assertEqual(bt_cls.results.summary_str(), expected_summary)
 
     def test_explicit_pass_but_teardown_test_raises_an_exception(self):
@@ -542,8 +539,8 @@
         self.assertEqual(actual_record.extra_errors["teardown_test"],
                          "Details=This is an expected exception., Extras=None")
         expected_summary = (
-            "ControllerInfo {}, Executed 1, Failed 0, Passed 0, Requested 1, "
-            "Skipped 0, Unknown 1")
+            "Blocked 0, ControllerInfo {}, Executed 1, Failed 0, Passed 0, "
+            "Requested 1, Skipped 0, Unknown 1")
         self.assertEqual(bt_cls.results.summary_str(), expected_summary)
 
     def test_on_pass_raise_exception(self):
@@ -564,8 +561,8 @@
         self.assertEqual(actual_record.extra_errors,
                          {'_on_pass': MSG_EXPECTED_EXCEPTION})
         expected_summary = (
-            "ControllerInfo {}, Executed 1, Failed 0, Passed 0, Requested 1, "
-            "Skipped 0, Unknown 1")
+            "Blocked 0, ControllerInfo {}, Executed 1, Failed 0, Passed 0, "
+            "Requested 1, Skipped 0, Unknown 1")
         self.assertEqual(bt_cls.results.summary_str(), expected_summary)
 
     def test_on_fail_raise_exception(self):
@@ -586,8 +583,8 @@
         self.assertEqual(actual_record.extra_errors,
                          {'_on_fail': MSG_EXPECTED_EXCEPTION})
         expected_summary = (
-            "ControllerInfo {}, Executed 1, Failed 0, Passed 0, Requested 1, "
-            "Skipped 0, Unknown 1")
+            "Blocked 0, ControllerInfo {}, Executed 1, Failed 0, Passed 0, "
+            "Requested 1, Skipped 0, Unknown 1")
         self.assertEqual(bt_cls.results.summary_str(), expected_summary)
 
     def test_abort_class(self):
@@ -608,8 +605,8 @@
         self.assertEqual(bt_cls.results.failed[0].details,
                          MSG_EXPECTED_EXCEPTION)
         self.assertEqual(bt_cls.results.summary_str(), (
-            "ControllerInfo {}, Executed 2, Failed 1, Passed 1, Requested 3, "
-            "Skipped 0, Unknown 0"))
+            "Blocked 0, ControllerInfo {}, Executed 2, Failed 1, Passed 1, "
+            "Requested 3, Skipped 0, Unknown 0"))
 
     def test_uncaught_exception(self):
         class MockBaseTest(base_test.BaseTestClass):
diff --git a/acts/framework/tests/acts_records_test.py b/acts/framework/tests/acts_records_test.py
index afaa5ef..24ba656 100755
--- a/acts/framework/tests/acts_records_test.py
+++ b/acts/framework/tests/acts_records_test.py
@@ -188,42 +188,6 @@
         with self.assertRaisesRegexp(TypeError, expected_msg):
             tr1 += "haha"
 
-    def test_result_fail_class_with_test_signal(self):
-        record1 = records.TestResultRecord(self.tn)
-        record1.test_begin()
-        s = signals.TestPass(self.details, self.float_extra)
-        record1.test_pass(s)
-        tr = records.TestResult()
-        tr.add_record(record1)
-        s = signals.TestFailure(self.details, self.float_extra)
-        record2 = records.TestResultRecord("SomeTest", s)
-        tr.fail_class(record2)
-        self.assertEqual(len(tr.passed), 1)
-        self.assertEqual(len(tr.failed), 1)
-        self.assertEqual(len(tr.executed), 2)
-
-    def test_result_fail_class_with_special_error(self):
-        """Call TestResult.fail_class with an error class that requires more
-        than one arg to instantiate.
-        """
-        record1 = records.TestResultRecord(self.tn)
-        record1.test_begin()
-        s = signals.TestPass(self.details, self.float_extra)
-        record1.test_pass(s)
-        tr = records.TestResult()
-        tr.add_record(record1)
-
-        class SpecialError(Exception):
-            def __init__(self, arg1, arg2):
-                self.msg = "%s %s" % (arg1, arg2)
-
-        se = SpecialError("haha", 42)
-        record2 = records.TestResultRecord("SomeTest", se)
-        tr.fail_class(record2)
-        self.assertEqual(len(tr.passed), 1)
-        self.assertEqual(len(tr.failed), 1)
-        self.assertEqual(len(tr.executed), 2)
-
     def test_is_all_pass(self):
         s = signals.TestPass(self.details, self.float_extra)
         record1 = records.TestResultRecord(self.tn)
@@ -253,17 +217,6 @@
         tr.add_record(record2)
         self.assertFalse(tr.is_all_pass)
 
-    def test_is_all_pass_with_fail_class(self):
-        """Verifies that is_all_pass yields correct value when fail_class is
-        used.
-        """
-        record1 = records.TestResultRecord(self.tn)
-        record1.test_begin()
-        record1.test_fail(Exception("haha"))
-        tr = records.TestResult()
-        tr.fail_class(record1)
-        self.assertFalse(tr.is_all_pass)
-
 
 if __name__ == "__main__":
     unittest.main()
\ No newline at end of file
diff --git a/acts/tests/google/ble/gatt/GattReadTest.py b/acts/tests/google/ble/gatt/GattReadTest.py
index 6225dea..764c697 100644
--- a/acts/tests/google/ble/gatt/GattReadTest.py
+++ b/acts/tests/google/ble/gatt/GattReadTest.py
@@ -148,3 +148,51 @@
                          "Read value shall be equal to value sent from server")
 
         return True
+
+    @BluetoothBaseTest.bt_test_wrap
+    def test_read_using_char_uuid(self):
+        """Test read using characteristic UUID.
+
+        Test GATT read value using characteristic UUID.
+
+        Steps:
+        1. Central: send read by UUID request.
+        2. Peripheral: receive read request .
+        3. Peripheral: send read response with status 0 (success), and
+           characteristic value.
+        4. Central: receive read response, verify it's conent matches what was
+           sent
+
+        Expected Result:
+        Verify that read request/response is properly delivered.
+
+        Returns:
+          Pass if True
+          Fail if False
+
+        TAGS: LE, GATT, Characteristic
+        Priority: 0
+        """
+        self.cen_ad.droid.gattClientReadUsingCharacteristicUuid(
+            self.bluetooth_gatt, self.READABLE_CHAR_UUID, 0x0001, 0xFFFF)
+
+        event = self._server_wait(GattEvent.CHAR_READ_REQ)
+
+        request_id = event['data']['requestId']
+        self.assertEqual(0, event['data']['offset'], "offset should be 0")
+
+        bt_device_id = 0
+        status = 0
+        char_value = [1, 2, 3, 4, 5, 6, 7, 20]
+        offset = 0
+        self.per_ad.droid.gattServerSendResponse(self.gatt_server,
+                                                 bt_device_id, request_id,
+                                                 status, offset, char_value)
+
+        event = self._client_wait(GattEvent.CHAR_READ)
+        self.assertEqual(status, event["data"]["Status"],
+                         "Write status should be 0")
+        self.assertEqual(char_value, event["data"]["CharacteristicValue"],
+                         "Read value shall be equal to value sent from server")
+
+        return True
diff --git a/acts/tests/google/tel/lab/TelLabCmasTest.py b/acts/tests/google/tel/lab/TelLabCmasTest.py
index 17ac9eb..1bdc7a7 100644
--- a/acts/tests/google/tel/lab/TelLabCmasTest.py
+++ b/acts/tests/google/tel/lab/TelLabCmasTest.py
@@ -43,6 +43,7 @@
 from acts.test_utils.tel.anritsu_utils import set_system_model_lte
 from acts.test_utils.tel.anritsu_utils import set_system_model_gsm
 from acts.test_utils.tel.anritsu_utils import set_system_model_wcdma
+from acts.test_utils.tel.anritsu_utils import set_usim_parameters
 from acts.test_utils.tel.tel_defines import NETWORK_MODE_CDMA
 from acts.test_utils.tel.tel_defines import NETWORK_MODE_GSM_ONLY
 from acts.test_utils.tel.tel_defines import NETWORK_MODE_GSM_UMTS
@@ -69,6 +70,7 @@
     def __init__(self, controllers):
         TelephonyBaseTest.__init__(self, controllers)
         self.ad = self.android_devices[0]
+        self.ad.sim_card = getattr(self.ad, "sim_card", None)
         self.md8475a_ip_address = self.user_params[
             "anritsu_md8475a_ip_address"]
         self.wlan_option = self.user_params.get("anritsu_wlan_option", False)
@@ -110,9 +112,9 @@
             c2k_urgency=CMAS_C2K_URGENCY_IMMEDIATE,
             c2k_certainty=CMAS_C2K_CERTIANTY_OBSERVED):
         try:
-            [self.bts1] = set_simulation_func(self.anritsu, self.user_params)
-            if self.ad.sim_card == "P0250Ax":
-                self.anritsu.usim_key = "000102030405060708090A0B0C0D0E0F"
+            [self.bts1] = set_simulation_func(self.anritsu, self.user_params,
+                                              self.ad.sim_card)
+            set_usim_parameters(self.anritsu, self.ad.sim_card)
             self.anritsu.start_simulation()
 
             if rat == RAT_LTE:
diff --git a/acts/tests/google/tel/lab/TelLabDataTest.py b/acts/tests/google/tel/lab/TelLabDataTest.py
new file mode 100644
index 0000000..1d9a8e6
--- /dev/null
+++ b/acts/tests/google/tel/lab/TelLabDataTest.py
@@ -0,0 +1,188 @@
+#/usr/bin/env python3.4
+#
+#   Copyright 2016 - The Android Open Source Project
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+"""
+Sanity tests for connectivity tests in telephony
+"""
+
+import time
+from acts.controllers.anritsu_lib._anritsu_utils import AnritsuError
+from acts.controllers.anritsu_lib.md8475a import MD8475A
+from acts.controllers.anritsu_lib.md8475a import VirtualPhoneStatus
+from acts.test_utils.tel.anritsu_utils import cb_serial_number
+from acts.test_utils.tel.anritsu_utils import set_system_model_1x
+from acts.test_utils.tel.anritsu_utils import set_system_model_gsm
+from acts.test_utils.tel.anritsu_utils import set_system_model_lte
+from acts.test_utils.tel.anritsu_utils import set_system_model_lte_wcdma
+from acts.test_utils.tel.anritsu_utils import set_system_model_wcdma
+from acts.test_utils.tel.anritsu_utils import sms_mo_send
+from acts.test_utils.tel.anritsu_utils import sms_mt_receive_verify
+from acts.test_utils.tel.anritsu_utils import set_usim_parameters
+from acts.test_utils.tel.tel_defines import DIRECTION_MOBILE_ORIGINATED
+from acts.test_utils.tel.tel_defines import DIRECTION_MOBILE_TERMINATED
+from acts.test_utils.tel.tel_defines import NETWORK_MODE_CDMA
+from acts.test_utils.tel.tel_defines import NETWORK_MODE_GSM_ONLY
+from acts.test_utils.tel.tel_defines import NETWORK_MODE_GSM_UMTS
+from acts.test_utils.tel.tel_defines import NETWORK_MODE_LTE_GSM_WCDMA
+from acts.test_utils.tel.tel_defines import RAT_1XRTT
+from acts.test_utils.tel.tel_defines import RAT_GSM
+from acts.test_utils.tel.tel_defines import RAT_LTE
+from acts.test_utils.tel.tel_defines import RAT_WCDMA
+from acts.test_utils.tel.tel_defines import RAT_FAMILY_CDMA2000
+from acts.test_utils.tel.tel_defines import RAT_FAMILY_GSM
+from acts.test_utils.tel.tel_defines import RAT_FAMILY_LTE
+from acts.test_utils.tel.tel_defines import RAT_FAMILY_UMTS
+from acts.test_utils.tel.tel_defines import NETWORK_SERVICE_DATA
+from acts.test_utils.tel.tel_defines import GEN_4G
+from acts.test_utils.tel.tel_test_utils import ensure_network_rat
+from acts.test_utils.tel.tel_test_utils import ensure_phones_idle
+from acts.test_utils.tel.tel_test_utils import ensure_network_generation
+from acts.test_utils.tel.tel_test_utils import toggle_airplane_mode
+from acts.test_utils.tel.tel_test_utils import iperf_test_by_adb
+from acts.test_utils.tel.TelephonyBaseTest import TelephonyBaseTest
+from acts.utils import adb_shell_ping
+from acts.utils import rand_ascii_str
+from acts.controllers import iperf_server
+from acts.utils import exe_cmd
+
+DEFAULT_PING_DURATION = 30
+
+class TelLabDataTest(TelephonyBaseTest):
+    SETTLING_TIME = 30
+    SERIAL_NO = cb_serial_number()
+
+    def __init__(self, controllers):
+        TelephonyBaseTest.__init__(self, controllers)
+        self.ad = self.android_devices[0]
+        self.ip_server = self.iperf_servers[0]
+        self.port_num = self.ip_server.port
+        self.log.info("Iperf Port is %s", self.port_num)
+        self.ad.sim_card = getattr(self.ad, "sim_card", None)
+        self.log.info("SIM Card is %s", self.ad.sim_card)
+        self.md8475a_ip_address = self.user_params[
+            "anritsu_md8475a_ip_address"]
+        self.wlan_option = self.user_params.get("anritsu_wlan_option", False)
+
+    def setup_class(self):
+        try:
+            self.anritsu = MD8475A(self.md8475a_ip_address, self.log,
+                                   self.wlan_option)
+        except AnritsuError:
+            self.log.error("Error in connecting to Anritsu Simulator")
+            return False
+        return True
+
+    def setup_test(self):
+        ensure_phones_idle(self.log, self.android_devices)
+        toggle_airplane_mode(self.log, self.ad, True)
+        return True
+
+    def teardown_test(self):
+        self.log.info("Stopping Simulation")
+        self.anritsu.stop_simulation()
+        toggle_airplane_mode(self.log, self.ad, True)
+        return True
+
+    def teardown_class(self):
+        self.anritsu.disconnect()
+        return True
+
+    def _setup_data(self,
+                   set_simulation_func,
+                   rat):
+        try:
+            set_simulation_func(self.anritsu, self.user_params,
+                                self.ad.sim_card)
+            set_usim_parameters(self.anritsu, self.ad.sim_card)
+            self.anritsu.start_simulation()
+
+            if rat == RAT_LTE:
+                preferred_network_setting = NETWORK_MODE_LTE_GSM_WCDMA
+                rat_family = RAT_FAMILY_LTE
+            elif rat == RAT_WCDMA:
+                preferred_network_setting = NETWORK_MODE_GSM_UMTS
+                rat_family = RAT_FAMILY_UMTS
+            elif rat == RAT_GSM:
+                preferred_network_setting = NETWORK_MODE_GSM_ONLY
+                rat_family = RAT_FAMILY_GSM
+            elif rat == RAT_1XRTT:
+                preferred_network_setting = NETWORK_MODE_CDMA
+                rat_family = RAT_FAMILY_CDMA2000
+            else:
+                self.log.error("No valid RAT provided for SMS test.")
+                return False
+
+            if not ensure_network_rat(self.log,
+                                      self.ad,
+                                      preferred_network_setting,
+                                      rat_family,
+                                      toggle_apm_after_setting=True):
+                self.log.error(
+                    "Failed to set rat family {}, preferred network:{}".format(
+                        rat_family, preferred_network_setting))
+                return False
+
+            self.anritsu.wait_for_registration_state()
+            time.sleep(self.SETTLING_TIME)
+            if not ensure_network_generation(self.log, self.ad,
+                                             GEN_4G, NETWORK_SERVICE_DATA):
+                self.log.error("Device not in 4G Connected Mode.")
+                return False
+
+            # Fetch IP address of the host machine
+            cmd = "|".join(("ifconfig", "grep eth0 -A1", "grep inet",
+                           "cut -d ':' -f2", "cut -d ' ' -f 1"))
+            destination_ip = exe_cmd(cmd)
+            destination_ip = (destination_ip.decode("utf-8")).split("\n")[0]
+            self.log.info("Dest IP is %s", destination_ip)
+
+            if not adb_shell_ping(self.ad, DEFAULT_PING_DURATION,
+                                  destination_ip):
+                self.log.error("Pings failed to Destination.")
+                return False
+
+            self.ip_server.start()
+            if not iperf_test_by_adb(self.log, self.ad, destination_ip,
+                                     self.port_num, True, 60):
+                self.log.error("iperf failed to Destination.")
+            self.ip_server.stop()
+
+        except AnritsuError as e:
+            self.log.error("Error in connection with Anritsu Simulator: " +
+                           str(e))
+            return False
+        except Exception as e:
+            self.log.error("Exception during Data procedure: " + str(e))
+            return False
+        return True
+
+    """ Tests Begin """
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_lte_pings_iperf(self):
+        """ Test Pings functionality on LTE
+
+        Make Sure Phone is in LTE mode
+        Ping to destination server IP
+        iperf server on host machine
+        iperf client in on adb
+        iperf DL
+
+        Returns:
+            True if pass; False if fail
+        """
+        return self._setup_data(set_system_model_lte, RAT_LTE)
+
+    """ Tests End """
diff --git a/acts/tests/google/tel/lab/TelLabEmergencyCallTest.py b/acts/tests/google/tel/lab/TelLabEmergencyCallTest.py
index 4a7db2a..b60aca1 100644
--- a/acts/tests/google/tel/lab/TelLabEmergencyCallTest.py
+++ b/acts/tests/google/tel/lab/TelLabEmergencyCallTest.py
@@ -35,6 +35,7 @@
 from acts.test_utils.tel.anritsu_utils import set_system_model_lte_wcdma
 from acts.test_utils.tel.anritsu_utils import set_system_model_lte_gsm
 from acts.test_utils.tel.anritsu_utils import set_system_model_wcdma
+from acts.test_utils.tel.anritsu_utils import set_usim_parameters
 from acts.test_utils.tel.tel_defines import CALL_TEARDOWN_PHONE
 from acts.test_utils.tel.tel_defines import DEFAULT_EMERGENCY_CALL_NUMBER
 from acts.test_utils.tel.tel_defines import EMERGENCY_CALL_NUMBERS
@@ -63,8 +64,8 @@
     def __init__(self, controllers):
         TelephonyBaseTest.__init__(self, controllers)
         try:
-            self.stress_test_number = int(
-                self.user_params["stress_test_number"])
+            self.stress_test_number = int(self.user_params[
+                "stress_test_number"])
             self.log.info("Executing {} calls per test in stress test mode".
                           format(self.stress_test_number))
         except KeyError:
@@ -74,6 +75,7 @@
             )
 
         self.ad = self.android_devices[0]
+        self.ad.sim_card = getattr(self.ad, "sim_card", None)
         self.md8475a_ip_address = self.user_params[
             "anritsu_md8475a_ip_address"]
         self.wlan_option = self.user_params.get("anritsu_wlan_option", False)
@@ -130,10 +132,9 @@
                               teardown_side=CALL_TEARDOWN_PHONE,
                               wait_time_in_call=WAIT_TIME_IN_CALL):
         try:
-            set_simulation_func(self.anritsu, self.user_params)
-
-            if getattr(self.ad, "sim_card", None) == "P0250Ax":
-                self.anritsu.usim_key = "000102030405060708090A0B0C0D0E0F"
+            set_simulation_func(self.anritsu, self.user_params,
+                                self.ad.sim_card)
+            set_usim_parameters(self.anritsu, self.ad.sim_card)
             self.virtualPhoneHandle.auto_answer = (VirtualPhoneAutoAnswer.ON,
                                                    2)
             if csfb_type:
@@ -180,8 +181,8 @@
             successes = 0
             for i in range(1, iterations + 1):
                 if self.stress_test_number:
-                    self.log.info(
-                        "Running iteration {} of {}".format(i, iterations))
+                    self.log.info("Running iteration {} of {}".format(
+                        i, iterations))
                 # FIXME: There's no good reason why this must be true;
                 # I can only assume this was done to work around a problem
                 self.ad.droid.telephonyToggleDataConnection(False)
@@ -190,8 +191,8 @@
                 sim_model = (self.anritsu.get_simulation_model()).split(",")
                 no_of_bts = len(sim_model)
                 for i in range(2, no_of_bts + 1):
-                    self.anritsu.send_command(
-                        "OUTOFSERVICE OUT,BTS{}".format(i))
+                    self.anritsu.send_command("OUTOFSERVICE OUT,BTS{}".format(
+                        i))
 
                 if phone_setup_func is not None:
                     if not phone_setup_func(self.ad):
@@ -206,8 +207,8 @@
                         continue
 
                 for i in range(2, no_of_bts + 1):
-                    self.anritsu.send_command(
-                        "OUTOFSERVICE IN,BTS{}".format(i))
+                    self.anritsu.send_command("OUTOFSERVICE IN,BTS{}".format(
+                        i))
 
                 time.sleep(WAIT_TIME_ANRITSU_REG_AND_CALL)
                 if srlte_csfb or srvcc:
diff --git a/acts/tests/google/tel/lab/TelLabEtwsTest.py b/acts/tests/google/tel/lab/TelLabEtwsTest.py
index 672ee4e..e6cda25 100644
--- a/acts/tests/google/tel/lab/TelLabEtwsTest.py
+++ b/acts/tests/google/tel/lab/TelLabEtwsTest.py
@@ -29,6 +29,7 @@
 from acts.test_utils.tel.anritsu_utils import set_system_model_gsm
 from acts.test_utils.tel.anritsu_utils import set_system_model_lte
 from acts.test_utils.tel.anritsu_utils import set_system_model_wcdma
+from acts.test_utils.tel.anritsu_utils import set_usim_parameters
 from acts.test_utils.tel.tel_defines import NETWORK_MODE_CDMA
 from acts.test_utils.tel.tel_defines import NETWORK_MODE_GSM_ONLY
 from acts.test_utils.tel.tel_defines import NETWORK_MODE_GSM_UMTS
@@ -55,6 +56,7 @@
     def __init__(self, controllers):
         TelephonyBaseTest.__init__(self, controllers)
         self.ad = self.android_devices[0]
+        self.ad.sim_card = getattr(self.ad, "sim_card", None)
         self.md8475a_ip_address = self.user_params[
             "anritsu_md8475a_ip_address"]
         self.wlan_option = self.user_params.get("anritsu_wlan_option", False)
@@ -64,7 +66,6 @@
             "wait_time_between_reg_and_msg", WAIT_TIME_BETWEEN_REG_AND_MSG)
 
     def setup_class(self):
-        super(TelLabEtwsTest, self).setup_class()
         try:
             self.anritsu = MD8475A(self.md8475a_ip_address, self.log,
                                    self.wlan_option)
@@ -90,9 +91,9 @@
     def _send_receive_etws_message(self, set_simulation_func, rat, message_id,
                                    warning_message):
         try:
-            [self.bts1] = set_simulation_func(self.anritsu, self.user_params)
-            if self.ad.sim_card == "P0250Ax":
-                self.anritsu.usim_key = "000102030405060708090A0B0C0D0E0F"
+            [self.bts1] = set_simulation_func(self.anritsu, self.user_params,
+                                              self.ad.sim_card)
+            set_usim_parameters(self.anritsu, self.ad.sim_card)
             self.anritsu.start_simulation()
 
             if rat == RAT_LTE:
diff --git a/acts/tests/google/tel/lab/TelLabVoiceTest.py b/acts/tests/google/tel/lab/TelLabVoiceTest.py
index 03595e2..e7e812a 100644
--- a/acts/tests/google/tel/lab/TelLabVoiceTest.py
+++ b/acts/tests/google/tel/lab/TelLabVoiceTest.py
@@ -35,6 +35,7 @@
 from acts.test_utils.tel.anritsu_utils import set_system_model_lte_wcdma
 from acts.test_utils.tel.anritsu_utils import set_system_model_lte_gsm
 from acts.test_utils.tel.anritsu_utils import set_system_model_wcdma
+from acts.test_utils.tel.anritsu_utils import set_usim_parameters
 from acts.test_utils.tel.tel_defines import CALL_TEARDOWN_PHONE
 from acts.test_utils.tel.tel_defines import RAT_FAMILY_CDMA2000
 from acts.test_utils.tel.tel_defines import RAT_FAMILY_GSM
@@ -63,8 +64,8 @@
     def __init__(self, controllers):
         TelephonyBaseTest.__init__(self, controllers)
         try:
-            self.stress_test_number = int(
-                self.user_params["stress_test_number"])
+            self.stress_test_number = int(self.user_params[
+                "stress_test_number"])
             self.log.info("Executing {} calls per test in stress test mode".
                           format(self.stress_test_number))
         except KeyError:
@@ -74,6 +75,7 @@
             )
 
         self.ad = self.android_devices[0]
+        self.ad.sim_card = getattr(self.ad, "sim_card", None)
         self.md8475a_ip_address = self.user_params[
             "anritsu_md8475a_ip_address"]
         self.wlan_option = self.user_params.get("anritsu_wlan_option", False)
@@ -126,10 +128,9 @@
                           teardown_side=CALL_TEARDOWN_PHONE,
                           wait_time_in_call=WAIT_TIME_IN_CALL):
         try:
-            set_simulation_func(self.anritsu, self.user_params)
-
-            if self.ad.sim_card == "P0250Ax":
-                self.anritsu.usim_key = "000102030405060708090A0B0C0D0E0F"
+            set_simulation_func(self.anritsu, self.user_params,
+                                self.ad.sim_card)
+            set_usim_parameters(self.anritsu, self.ad.sim_card)
             self.virtualPhoneHandle.auto_answer = (VirtualPhoneAutoAnswer.ON,
                                                    2)
             if srvcc != None:
@@ -150,8 +151,8 @@
             successes = 0
             for i in range(1, iterations + 1):
                 if self.stress_test_number:
-                    self.log.info(
-                        "Running iteration {} of {}".format(i, iterations))
+                    self.log.info("Running iteration {} of {}".format(
+                        i, iterations))
                 # FIXME: There's no good reason why this must be true;
                 # I can only assume this was done to work around a problem
                 self.ad.droid.telephonyToggleDataConnection(False)
@@ -160,8 +161,8 @@
                 sim_model = (self.anritsu.get_simulation_model()).split(",")
                 no_of_bts = len(sim_model)
                 for i in range(2, no_of_bts + 1):
-                    self.anritsu.send_command(
-                        "OUTOFSERVICE OUT,BTS{}".format(i))
+                    self.anritsu.send_command("OUTOFSERVICE OUT,BTS{}".format(
+                        i))
 
                 if phone_setup_func is not None:
                     if not phone_setup_func(self.ad):
@@ -176,8 +177,8 @@
                         continue
 
                 for i in range(2, no_of_bts + 1):
-                    self.anritsu.send_command(
-                        "OUTOFSERVICE IN,BTS{}".format(i))
+                    self.anritsu.send_command("OUTOFSERVICE IN,BTS{}".format(
+                        i))
 
                 time.sleep(WAIT_TIME_ANRITSU_REG_AND_CALL)
                 if srvcc:
diff --git a/acts/tests/google/tel/live/TelLiveDataTest.py b/acts/tests/google/tel/live/TelLiveDataTest.py
index 0bebcd2..6a0972e 100644
--- a/acts/tests/google/tel/live/TelLiveDataTest.py
+++ b/acts/tests/google/tel/live/TelLiveDataTest.py
@@ -56,6 +56,7 @@
 from acts.test_utils.tel.tel_data_utils import wifi_tethering_cleanup
 from acts.test_utils.tel.tel_data_utils import wifi_tethering_setup_teardown
 from acts.test_utils.tel.tel_test_utils import call_setup_teardown
+from acts.test_utils.tel.tel_test_utils import check_is_wifi_connected
 from acts.test_utils.tel.tel_test_utils import ensure_phones_default_state
 from acts.test_utils.tel.tel_test_utils import ensure_phones_idle
 from acts.test_utils.tel.tel_test_utils import ensure_network_generation
@@ -71,7 +72,7 @@
 from acts.test_utils.tel.tel_test_utils import stop_wifi_tethering
 from acts.test_utils.tel.tel_test_utils import toggle_airplane_mode
 from acts.test_utils.tel.tel_test_utils import toggle_volte
-from acts.test_utils.tel.tel_test_utils import verify_http_connection
+from acts.test_utils.tel.tel_test_utils import verify_internet_connection
 from acts.test_utils.tel.tel_test_utils import verify_incall_state
 from acts.test_utils.tel.tel_test_utils import wait_for_cell_data_connection
 from acts.test_utils.tel.tel_test_utils import wait_for_network_rat
@@ -103,11 +104,9 @@
 
         self.stress_test_number = self.get_stress_test_number()
         self.wifi_network_ssid = self.user_params.get(
-            "wifi_network_ssid") or self.user_params.get(
-                "wifi_network_ssid_2g")
+            "wifi_network_ssid") or self.user_params.get("wifi_network_ssid_2g")
         self.wifi_network_pass = self.user_params.get(
-            "wifi_network_pass") or self.user_params.get(
-                "wifi_network_pass_2g")
+            "wifi_network_pass") or self.user_params.get("wifi_network_pass_2g")
 
     @TelephonyBaseTest.tel_test_wrap
     def test_airplane_mode(self):
@@ -281,10 +280,10 @@
                 i, result_str, success_count, self.stress_test_number))
 
         self.log.info("Final Count - Success: {}, Failure: {} - {}%".format(
-            success_count, fail_count, str(100 * success_count / (
-                success_count + fail_count))))
-        if success_count / (success_count + fail_count
-                            ) >= MINIMUM_SUCCESS_RATE:
+            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
@@ -320,10 +319,10 @@
                 i, result_str, success_count, self.stress_test_number))
 
         self.log.info("Final Count - Success: {}, Failure: {} - {}%".format(
-            success_count, fail_count, str(100 * success_count / (
-                success_count + fail_count))))
-        if success_count / (success_count + fail_count
-                            ) >= MINIMUM_SUCCESS_RATE:
+            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
@@ -358,16 +357,16 @@
         ensure_phones_idle(self.log, ad_list)
 
         if not ensure_network_generation_for_subscription(
-                self.log, self.android_devices[0], self.android_devices[
-                    0].droid.subscriptionGetDefaultDataSubId(), nw_gen,
+                self.log, self.android_devices[0], self.android_devices[0]
+                .droid.subscriptionGetDefaultDataSubId(), nw_gen,
                 MAX_WAIT_TIME_NW_SELECTION, NETWORK_SERVICE_DATA):
             self.log.error("Device failed to reselect in {}s.".format(
                 MAX_WAIT_TIME_NW_SELECTION))
             return False
 
         if not wait_for_voice_attach_for_subscription(
-                self.log, self.android_devices[0], self.android_devices[
-                    0].droid.subscriptionGetDefaultVoiceSubId(),
+                self.log, self.android_devices[0], self.android_devices[0]
+                .droid.subscriptionGetDefaultVoiceSubId(),
                 MAX_WAIT_TIME_NW_SELECTION):
             return False
 
@@ -377,7 +376,8 @@
         self.android_devices[0].droid.telephonyToggleDataConnection(True)
         if (not wait_for_cell_data_connection(self.log,
                                               self.android_devices[0], True) or
-                not verify_http_connection(self.log, self.android_devices[0])):
+                not verify_internet_connection(self.log,
+                                               self.android_devices[0])):
             self.log.error("Data not available on cell")
             return False
 
@@ -391,14 +391,14 @@
                 ad_callee = self.android_devices[0]
             if not call_setup_teardown(self.log, ad_caller, ad_callee, None,
                                        None, None):
-                self.log.error("Failed to Establish {} Voice Call".format(
-                    call_direction))
+                self.log.error(
+                    "Failed to Establish {} Voice Call".format(call_direction))
                 return False
             if simultaneous_voice_data:
                 self.log.info("Step3 Verify internet.")
                 time.sleep(WAIT_TIME_ANDROID_STATE_SETTLING)
-                if not verify_http_connection(self.log,
-                                              self.android_devices[0]):
+                if not verify_internet_connection(self.log,
+                                                  self.android_devices[0]):
                     raise _LocalException("Internet Inaccessible when Enabled")
 
                 self.log.info("Step4 Turn off data and verify not connected.")
@@ -408,7 +408,8 @@
                         self.log, self.android_devices[0], False):
                     raise _LocalException("Failed to Disable Cellular Data")
 
-                if verify_http_connection(self.log, self.android_devices[0]):
+                if verify_internet_connection(self.log,
+                                              self.android_devices[0]):
                     raise _LocalException("Internet Accessible when Disabled")
 
                 self.log.info("Step5 Re-enable data.")
@@ -417,24 +418,25 @@
                 if not wait_for_cell_data_connection(
                         self.log, self.android_devices[0], True):
                     raise _LocalException("Failed to Re-Enable Cellular Data")
-                if not verify_http_connection(self.log,
-                                              self.android_devices[0]):
+                if not verify_internet_connection(self.log,
+                                                  self.android_devices[0]):
                     raise _LocalException("Internet Inaccessible when Enabled")
             else:
                 self.log.info("Step3 Verify no Internet and skip step 4-5.")
-                if verify_http_connection(
+                if verify_internet_connection(
                         self.log, self.android_devices[0], retry=0):
                     raise _LocalException("Internet Accessible.")
 
             self.log.info("Step6 Verify phones still in call and Hang up.")
-            if not verify_incall_state(
-                    self.log,
-                [self.android_devices[0], self.android_devices[1]], True):
+            if not verify_incall_state(self.log, [
+                    self.android_devices[0], self.android_devices[1]
+            ], True):
                 return False
             if not hangup_call(self.log, self.android_devices[0]):
                 self.log.error("Failed to hang up call")
                 return False
-            if not verify_http_connection(self.log, self.android_devices[0]):
+            if not verify_internet_connection(self.log,
+                                              self.android_devices[0]):
                 raise _LocalException("Internet Inaccessible when Enabled")
 
         except _LocalException as e:
@@ -600,10 +602,10 @@
                 i, result_str, success_count, self.stress_test_number))
 
         self.log.info("Final Count - Success: {}, Failure: {} - {}%".format(
-            success_count, fail_count, str(100 * success_count / (
-                success_count + fail_count))))
-        if success_count / (success_count + fail_count
-                            ) >= MINIMUM_SUCCESS_RATE:
+            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
@@ -642,15 +644,15 @@
                 i, result_str, success_count, self.stress_test_number))
 
         self.log.info("Final Count - Success: {}, Failure: {} - {}%".format(
-            success_count, fail_count, str(100 * success_count / (
-                success_count + fail_count))))
-        if success_count / (success_count + fail_count
-                            ) >= MINIMUM_SUCCESS_RATE:
+            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
 
-    def _test_setup_tethering(self, ads, network_generation=None):
+    def _test_setup_tethering(self, network_generation=None):
         """Pre setup steps for WiFi tethering test.
 
         Ensure all ads are idle.
@@ -662,35 +664,35 @@
             True if success.
             False if failed.
         """
-        ensure_phones_idle(self.log, ads)
-
-        if network_generation is not None:
-            if not ensure_network_generation_for_subscription(
-                    self.log, self.android_devices[0], self.android_devices[
-                        0].droid.subscriptionGetDefaultDataSubId(),
-                    network_generation, MAX_WAIT_TIME_NW_SELECTION,
-                    NETWORK_SERVICE_DATA):
-                self.log.error("Device failed to reselect in {}s.".format(
-                    MAX_WAIT_TIME_NW_SELECTION))
+        ensure_phones_idle(self.log, self.android_devices)
+        provider = self.android_devices[0]
+        if network_generation:
+            if not ensure_network_generation(
+                    self.log, provider, network_generation,
+                    MAX_WAIT_TIME_NW_SELECTION, NETWORK_SERVICE_DATA):
+                provider.log.error("Device failed to connect to %s.",
+                                   network_generation)
                 return False
 
         self.log.info("Airplane Off, Wifi Off, Data On.")
-        toggle_airplane_mode(self.log, self.android_devices[0], False)
-        wifi_toggle_state(self.log, self.android_devices[0], False)
-        self.android_devices[0].droid.telephonyToggleDataConnection(True)
-        if not wait_for_cell_data_connection(self.log, self.android_devices[0],
-                                             True):
-            self.log.error("Failed to enable data connection.")
+        toggle_airplane_mode(self.log, provider, False)
+        wifi_toggle_state(self.log, provider, False)
+        provider.droid.telephonyToggleDataConnection(True)
+        for ad in self.android_devices[1:]:
+            ad.droid.telephonyToggleDataConnection(False)
+
+        if not wait_for_cell_data_connection(self.log, provider, True):
+            provider.log.error("Provider failed to enable data connection.")
             return False
 
         self.log.info("Verify internet")
-        if not verify_http_connection(self.log, self.android_devices[0]):
-            self.log.error("Data not available on cell.")
+        if not verify_internet_connection(self.log, provider):
+            provider.log.error("Data not available on cell.")
             return False
 
         # Turn off active SoftAP if any.
-        if ads[0].droid.wifiIsApEnabled():
-            stop_wifi_tethering(self.log, ads[0])
+        if provider.droid.wifiIsApEnabled():
+            stop_wifi_tethering(self.log, provider)
 
         return True
 
@@ -708,7 +710,7 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads, RAT_4G):
+        if not self._test_setup_tethering(RAT_4G):
             self.log.error("Verify 4G Internet access failed.")
             return False
 
@@ -733,7 +735,7 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads, RAT_4G):
+        if not self._test_setup_tethering(RAT_4G):
             self.log.error("Verify 4G Internet access failed.")
             return False
 
@@ -758,7 +760,7 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads, RAT_3G):
+        if not self._test_setup_tethering(RAT_3G):
             self.log.error("Verify 3G Internet access failed.")
             return False
 
@@ -783,7 +785,7 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads, RAT_3G):
+        if not self._test_setup_tethering(RAT_3G):
             self.log.error("Verify 3G Internet access failed.")
             return False
 
@@ -808,7 +810,7 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads, RAT_4G):
+        if not self._test_setup_tethering(RAT_4G):
             self.log.error("Verify 4G Internet access failed.")
             return False
 
@@ -833,7 +835,7 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads, RAT_2G):
+        if not self._test_setup_tethering(RAT_2G):
             self.log.error("Verify 2G Internet access failed.")
             return False
 
@@ -858,7 +860,7 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads, RAT_2G):
+        if not self._test_setup_tethering(RAT_2G):
             self.log.error("Verify 2G Internet access failed.")
             return False
 
@@ -874,7 +876,7 @@
         """WiFi Tethering test: WiFI connected to 2.4G network,
         start (LTE) 2.4G WiFi tethering, then stop tethering
 
-        1. DUT in LTE mode, idle. WiFi connected to 2.4G Network
+        1. DUT in data connected, idle. WiFi connected to 2.4G Network
         2. DUT start 2.4G WiFi Tethering
         3. PhoneB disable data, connect to DUT's softAP
         4. Verify Internet access on DUT and PhoneB
@@ -886,8 +888,8 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads, RAT_4G):
-            self.log.error("Verify 4G Internet access failed.")
+        if not self._test_setup_tethering():
+            self.log.error("Verify provider Internet access failed.")
             return False
         self.log.info("Connect WiFi.")
         if not ensure_wifi_connected(self.log, ads[0], self.wifi_network_ssid,
@@ -902,7 +904,7 @@
             return False
 
         if (not wait_for_wifi_data_connection(self.log, ads[0], True) or
-                not verify_http_connection(self.log, ads[0])):
+                not verify_internet_connection(self.log, ads[0])):
             self.log.error("Provider data did not return to Wifi")
             return False
         return True
@@ -911,7 +913,7 @@
     def test_toggle_data_during_active_wifi_tethering(self):
         """WiFi Tethering test: Toggle Data during active WiFi Tethering
 
-        1. DUT in LTE mode, idle.
+        1. DUT data connection is on and idle.
         2. DUT start 2.4G WiFi Tethering
         3. PhoneB disable data, connect to DUT's softAP
         4. Verify Internet access on DUT and PhoneB
@@ -923,8 +925,8 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads, RAT_4G):
-            self.log.error("Verify 4G Internet access failed.")
+        if not self._test_setup_tethering():
+            self.log.error("Provider Internet access check failed.")
             return False
         try:
             ssid = rand_ascii_str(10)
@@ -940,45 +942,39 @@
                 return False
 
             if not ads[0].droid.wifiIsApEnabled():
-                self.log.error("Provider WiFi tethering stopped.")
+                ads[0].log.error("Provider WiFi tethering stopped.")
                 return False
 
-            self.log.info(
+            ads[0].log.info(
                 "Disable Data on Provider, verify no data on Client.")
             ads[0].droid.telephonyToggleDataConnection(False)
             time.sleep(WAIT_TIME_DATA_STATUS_CHANGE_DURING_WIFI_TETHERING)
-            if verify_http_connection(self.log, ads[0]):
-                self.log.error("Disable data on provider failed.")
+            if verify_internet_connection(self.log, ads[0]):
+                ads[0].log.error("Disable data on provider failed.")
                 return False
             if not ads[0].droid.wifiIsApEnabled():
-                self.log.error("Provider WiFi tethering stopped.")
+                ads[0].log.error("Provider WiFi tethering stopped.")
                 return False
-            wifi_info = ads[1].droid.wifiGetConnectionInfo()
-
-            if wifi_info[WIFI_SSID_KEY] != ssid:
-                self.log.error("WiFi error. Info: {}".format(wifi_info))
-                return False
-            if verify_http_connection(self.log, ads[1]):
-                self.log.error("Client should not have Internet connection.")
+            if not check_is_wifi_connected(self.log, ads[1], ssid):
+                ads[1].log.error("Client WiFi is not connected")
                 return False
 
             self.log.info(
                 "Enable Data on Provider, verify data available on Client.")
             ads[0].droid.telephonyToggleDataConnection(True)
-            time.sleep(WAIT_TIME_DATA_STATUS_CHANGE_DURING_WIFI_TETHERING)
-            if not verify_http_connection(self.log, ads[0]):
-                self.log.error("Enable data on provider failed.")
+            if not wait_for_cell_data_connection(self.log, ads[0], True):
+                ads[0].log.error("Provider failed to enable data connection.")
+                return False
+            if not verify_internet_connection(self.log, ads[0]):
+                ads[0].log.error("Provider internet connection check failed.")
                 return False
             if not ads[0].droid.wifiIsApEnabled():
                 self.log.error("Provider WiFi tethering stopped.")
                 return False
-            wifi_info = ads[1].droid.wifiGetConnectionInfo()
 
-            if wifi_info[WIFI_SSID_KEY] != ssid:
-                self.log.error("WiFi error. Info: {}".format(wifi_info))
-                return False
-            if not verify_http_connection(self.log, ads[1]):
-                self.log.error("Client have no Internet connection!")
+            if not check_is_wifi_connected(self.log, ads[1], ssid) or (
+                    not verify_internet_connection(self.log, ads[1])):
+                ads[1].log.error("Client wifi connection check failed!")
                 return False
         finally:
             if not wifi_tethering_cleanup(self.log, ads[0], [ads[1]]):
@@ -1004,7 +1000,7 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads, RAT_4G):
+        if not self._test_setup_tethering(RAT_4G):
             self.log.error("Verify 4G Internet access failed.")
             return False
         try:
@@ -1032,7 +1028,7 @@
                 self.log.error("Provider failed to reselect to 3G.")
                 return False
             time.sleep(WAIT_TIME_DATA_STATUS_CHANGE_DURING_WIFI_TETHERING)
-            if not verify_http_connection(self.log, ads[0]):
+            if not verify_internet_connection(self.log, ads[0]):
                 self.log.error("Data not available on Provider.")
                 return False
             if not ads[0].droid.wifiIsApEnabled():
@@ -1065,7 +1061,7 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads, RAT_3G):
+        if not self._test_setup_tethering(RAT_3G):
             self.log.error("Verify 3G Internet access failed.")
             return False
         try:
@@ -1093,7 +1089,7 @@
                 self.log.error("Provider failed to reselect to 4G.")
                 return False
             time.sleep(WAIT_TIME_DATA_STATUS_CHANGE_DURING_WIFI_TETHERING)
-            if not verify_http_connection(self.log, ads[0]):
+            if not verify_internet_connection(self.log, ads[0]):
                 self.log.error("Data not available on Provider.")
                 return False
             if not ads[0].droid.wifiIsApEnabled():
@@ -1123,7 +1119,7 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads, RAT_4G):
+        if not self._test_setup_tethering(RAT_4G):
             self.log.error("Verify 4G Internet access failed.")
             return False
         try:
@@ -1152,7 +1148,7 @@
             if ads[0].droid.wifiIsApEnabled():
                 self.log.error("Provider WiFi tethering not stopped.")
                 return False
-            if verify_http_connection(self.log, ads[1]):
+            if verify_internet_connection(self.log, ads[1]):
                 self.log.error("Client should not have Internet connection.")
                 return False
             wifi_info = ads[1].droid.wifiGetConnectionInfo()
@@ -1171,7 +1167,7 @@
             if ads[0].droid.wifiIsApEnabled():
                 self.log.error("Provider WiFi tethering should not on.")
                 return False
-            if not verify_http_connection(self.log, ads[0]):
+            if not verify_internet_connection(self.log, ads[0]):
                 self.log.error("Provider should have Internet connection.")
                 return False
         finally:
@@ -1192,7 +1188,8 @@
 
         if (not wait_for_cell_data_connection(self.log,
                                               self.android_devices[0], True) or
-                not verify_http_connection(self.log, self.android_devices[0])):
+                not verify_internet_connection(self.log,
+                                               self.android_devices[0])):
             self.log.error("Failed cell data call for entitlement check.")
             return False
 
@@ -1232,10 +1229,10 @@
                 i, result_str, success_count, self.stress_test_number))
 
         self.log.info("Final Count - Success: {}, Failure: {} - {}%".format(
-            success_count, fail_count, str(100 * success_count / (
-                success_count + fail_count))))
-        if success_count / (success_count + fail_count
-                            ) >= MINIMUM_SUCCESS_RATE:
+            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
@@ -1252,12 +1249,12 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads):
+        if not self._test_setup_tethering():
             self.log.error("Verify Internet access failed.")
             return False
         ssid = "\"" + rand_ascii_str(10) + "\""
-        self.log.info("Starting WiFi Tethering test with ssid: {}".format(
-            ssid))
+        self.log.info(
+            "Starting WiFi Tethering test with ssid: {}".format(ssid))
 
         return wifi_tethering_setup_teardown(
             self.log,
@@ -1280,13 +1277,13 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads):
+        if not self._test_setup_tethering():
             self.log.error("Verify Internet access failed.")
             return False
 
         password = '"DQ=/{Yqq;M=(^_3HzRvhOiL8S%`]w&l<Qp8qH)bs<4E9v_q=HLr^)}w$blA0Kg'
-        self.log.info("Starting WiFi Tethering test with password: {}".format(
-            password))
+        self.log.info(
+            "Starting WiFi Tethering test with password: {}".format(password))
 
         return wifi_tethering_setup_teardown(
             self.log,
@@ -1328,8 +1325,8 @@
             self.log.error("Client connect to WiFi failed.")
             result = False
         if not wifi_reset(self.log, ad_client):
-            self.log.error("Reset client WiFi failed. {}".format(
-                ad_client.serial))
+            self.log.error(
+                "Reset client WiFi failed. {}".format(ad_client.serial))
             result = False
         if not stop_wifi_tethering(self.log, ad_host):
             self.log.error("Stop WiFi tethering failed.")
@@ -1348,18 +1345,19 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads, RAT_4G):
+        if not self._test_setup_tethering(RAT_4G):
             self.log.error("Setup Failed.")
             return False
-        ssid_list = [" !\"#$%&'()*+,-./0123456789:;<=>?",
-                     "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_",
-                     "`abcdefghijklmnopqrstuvwxyz{|}~", " a ", "!b!", "#c#",
-                     "$d$", "%e%", "&f&", "'g'", "(h(", ")i)", "*j*", "+k+",
-                     "-l-", ".m.", "/n/", "_",
-                     " !\"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}",
-                     "\u0644\u062c\u0648\u062c", "\u8c37\u6b4c", "\uad6c\uae00"
-                     "\u30b0\u30fc\u30eb",
-                     "\u0417\u0434\u0440\u0430\u0432\u0441\u0442\u0443\u0439"]
+        ssid_list = [
+            " !\"#$%&'()*+,-./0123456789:;<=>?",
+            "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_",
+            "`abcdefghijklmnopqrstuvwxyz{|}~", " a ", "!b!", "#c#", "$d$",
+            "%e%", "&f&", "'g'", "(h(", ")i)", "*j*", "+k+", "-l-", ".m.",
+            "/n/", "_", " !\"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}",
+            "\u0644\u062c\u0648\u062c", "\u8c37\u6b4c", "\uad6c\uae00"
+            "\u30b0\u30fc\u30eb",
+            "\u0417\u0434\u0440\u0430\u0432\u0441\u0442\u0443\u0439"
+        ]
         fail_list = {}
 
         for ssid in ssid_list:
@@ -1387,7 +1385,7 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads, RAT_4G):
+        if not self._test_setup_tethering(RAT_4G):
             self.log.error("Setup Failed.")
             return False
         password_list = [
@@ -1416,11 +1414,12 @@
         else:
             return True
 
-    def _test_tethering_wifi_and_voice_call(
-            self, provider, client, provider_data_rat, provider_setup_func,
-            provider_in_call_check_func):
-        if not self._test_setup_tethering([provider, client],
-                                          provider_data_rat):
+    def _test_tethering_wifi_and_voice_call(self, provider_data_rat,
+                                            provider_setup_func,
+                                            provider_in_call_check_func):
+        provider = self.android_devices[0]
+        client = self.android_devices[1]
+        if not self._test_setup_tethering(provider_data_rat):
             self.log.error("Verify 4G Internet access failed.")
             return False
 
@@ -1451,9 +1450,9 @@
                 self.log.error("Setup Call Failed.")
                 return False
             self.log.info("3. Verify data.")
-            if not verify_http_connection(self.log, provider):
+            if not verify_internet_connection(self.log, provider):
                 self.log.error("Provider have no Internet access.")
-            if not verify_http_connection(self.log, client):
+            if not verify_internet_connection(self.log, client):
                 self.log.error("Client have no Internet access.")
             hangup_call(self.log, provider)
 
@@ -1469,9 +1468,9 @@
                 self.log.error("Setup Call Failed.")
                 return False
             self.log.info("5. Verify data.")
-            if not verify_http_connection(self.log, provider):
+            if not verify_internet_connection(self.log, provider):
                 self.log.error("Provider have no Internet access.")
-            if not verify_http_connection(self.log, client):
+            if not verify_internet_connection(self.log, client):
                 self.log.error("Client have no Internet access.")
             hangup_call(self.log, provider)
 
@@ -1495,8 +1494,7 @@
             False if failed.
         """
         return self._test_tethering_wifi_and_voice_call(
-            self.android_devices[0], self.android_devices[1], RAT_4G,
-            phone_setup_volte, is_phone_in_call_volte)
+            RAT_4G, phone_setup_volte, is_phone_in_call_volte)
 
     @TelephonyBaseTest.tel_test_wrap
     def test_tethering_wifi_csfb_call(self):
@@ -1513,8 +1511,7 @@
             False if failed.
         """
         return self._test_tethering_wifi_and_voice_call(
-            self.android_devices[0], self.android_devices[1], RAT_4G,
-            phone_setup_csfb, is_phone_in_call_csfb)
+            RAT_4G, phone_setup_csfb, is_phone_in_call_csfb)
 
     @TelephonyBaseTest.tel_test_wrap
     def test_tethering_wifi_3g_call(self):
@@ -1531,8 +1528,7 @@
             False if failed.
         """
         return self._test_tethering_wifi_and_voice_call(
-            self.android_devices[0], self.android_devices[1], RAT_3G,
-            phone_setup_voice_3g, is_phone_in_call_3g)
+            RAT_3G, phone_setup_voice_3g, is_phone_in_call_3g)
 
     @TelephonyBaseTest.tel_test_wrap
     def test_tethering_wifi_no_password(self):
@@ -1548,7 +1544,7 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads):
+        if not self._test_setup_tethering():
             self.log.error("Verify Internet access failed.")
             return False
 
@@ -1576,7 +1572,7 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads):
+        if not self._test_setup_tethering():
             self.log.error("Verify Internet access failed.")
             return False
         try:
@@ -1628,7 +1624,7 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads):
+        if not self._test_setup_tethering():
             self.log.error("Verify Internet access failed.")
             return False
 
@@ -1636,7 +1632,7 @@
         if ((not ensure_wifi_connected(self.log, ads[0],
                                        self.wifi_network_ssid,
                                        self.wifi_network_pass)) or
-            (not verify_http_connection(self.log, ads[0]))):
+            (not verify_internet_connection(self.log, ads[0]))):
             self.log.error("WiFi connect fail.")
             return False
 
@@ -1667,7 +1663,7 @@
 
             self.log.info("Make sure WiFi can connect automatically.")
             if (not wait_for_wifi_data_connection(self.log, ads[0], True) or
-                    not verify_http_connection(self.log, ads[0])):
+                    not verify_internet_connection(self.log, ads[0])):
                 self.log.error("Data did not return to WiFi")
                 return False
 
@@ -1696,7 +1692,7 @@
         """
         ads = self.android_devices
 
-        if not self._test_setup_tethering(ads):
+        if not self._test_setup_tethering():
             self.log.error("Verify Internet access failed.")
             return False
 
@@ -1704,7 +1700,7 @@
         if ((not ensure_wifi_connected(self.log, ads[0],
                                        self.wifi_network_ssid,
                                        self.wifi_network_pass)) or
-            (not verify_http_connection(self.log, ads[0]))):
+            (not verify_internet_connection(self.log, ads[0]))):
             self.log.error("WiFi connect fail.")
             return False
 
@@ -1738,7 +1734,7 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads):
+        if not self._test_setup_tethering():
             self.log.error("Verify Internet access failed.")
             return False
         try:
@@ -1756,21 +1752,21 @@
                 self.log.error("Provider WiFi tethering stopped.")
                 return False
 
-            self.log.info("Turn off screen on provider: <{}>.".format(ads[0]
-                                                                      .serial))
+            self.log.info(
+                "Turn off screen on provider: <{}>.".format(ads[0].serial))
             ads[0].droid.goToSleepNow()
             time.sleep(60)
-            if not verify_http_connection(self.log, ads[1]):
+            if not verify_internet_connection(self.log, ads[1]):
                 self.log.error("Client have no Internet access.")
                 return False
 
-            self.log.info("Enable doze mode on provider: <{}>.".format(ads[
-                0].serial))
+            self.log.info(
+                "Enable doze mode on provider: <{}>.".format(ads[0].serial))
             if not enable_doze(ads[0]):
                 self.log.error("Failed to enable doze mode.")
                 return False
             time.sleep(60)
-            if not verify_http_connection(self.log, ads[1]):
+            if not verify_internet_connection(self.log, ads[1]):
                 self.log.error("Client have no Internet access.")
                 return False
         finally:
@@ -1801,8 +1797,8 @@
         """
         ad = self.android_devices[0]
         current_data_sub_id = ad.droid.subscriptionGetDefaultDataSubId()
-        current_sim_slot_index = get_slot_index_from_subid(self.log, ad,
-                                                           current_data_sub_id)
+        current_sim_slot_index = get_slot_index_from_subid(
+            self.log, ad, current_data_sub_id)
         if current_sim_slot_index == SIM1_SLOT_INDEX:
             next_sim_slot_index = SIM2_SLOT_INDEX
         else:
@@ -1819,7 +1815,7 @@
                 voice_or_data=NETWORK_SERVICE_DATA):
             self.log.error("Device data does not attach to 2G.")
             return False
-        if not verify_http_connection(self.log, ad):
+        if not verify_internet_connection(self.log, ad):
             self.log.error("No Internet access on default Data SIM.")
             return False
 
@@ -1860,9 +1856,10 @@
         """
         ad = self.android_devices[0]
 
-        wifi_toggles = [True, False, True, False, False, True, False, False,
-                        False, False, True, False, False, False, False, False,
-                        False, False, False]
+        wifi_toggles = [
+            True, False, True, False, False, True, False, False, False, False,
+            True, False, False, False, False, False, False, False, False
+        ]
 
         for toggle in wifi_toggles:
 
@@ -1873,8 +1870,8 @@
                 self.log.error("Failed wifi connection, aborting!")
                 return False
 
-            if not verify_http_connection(self.log, ad,
-                                          'http://www.google.com', 100, .1):
+            if not verify_internet_connection(
+                    self.log, ad, 'http://www.google.com', 100, .1):
                 self.log.error("Failed to get user-plane traffic, aborting!")
                 return False
 
@@ -1889,8 +1886,8 @@
                 self.log.error("Failed wifi connection, aborting!")
                 return False
 
-            if not verify_http_connection(self.log, ad,
-                                          'http://www.google.com', 100, .1):
+            if not verify_internet_connection(
+                    self.log, ad, 'http://www.google.com', 100, .1):
                 self.log.error("Failed to get user-plane traffic, aborting!")
                 return False
         return True
@@ -1916,8 +1913,9 @@
 
         ad = self.android_devices[0]
         if not ensure_network_generation_for_subscription(
-                self.log, ad, ad.droid.subscriptionGetDefaultDataSubId(),
-                GEN_4G, MAX_WAIT_TIME_NW_SELECTION, NETWORK_SERVICE_DATA):
+                self.log, ad,
+                ad.droid.subscriptionGetDefaultDataSubId(), GEN_4G,
+                MAX_WAIT_TIME_NW_SELECTION, NETWORK_SERVICE_DATA):
             self.log.error("Device {} failed to reselect in {}s.".format(
                 ad.serial, MAX_WAIT_TIME_NW_SELECTION))
             return False
@@ -1944,8 +1942,9 @@
 
         ad = self.android_devices[0]
         if not ensure_network_generation_for_subscription(
-                self.log, ad, ad.droid.subscriptionGetDefaultDataSubId(),
-                GEN_3G, MAX_WAIT_TIME_NW_SELECTION, NETWORK_SERVICE_DATA):
+                self.log, ad,
+                ad.droid.subscriptionGetDefaultDataSubId(), GEN_3G,
+                MAX_WAIT_TIME_NW_SELECTION, NETWORK_SERVICE_DATA):
             self.log.error("Device {} failed to reselect in {}s.".format(
                 ad.serial, MAX_WAIT_TIME_NW_SELECTION))
             return False
@@ -1971,8 +1970,9 @@
         """
         ad = self.android_devices[0]
         if not ensure_network_generation_for_subscription(
-                self.log, ad, ad.droid.subscriptionGetDefaultDataSubId(),
-                GEN_2G, MAX_WAIT_TIME_NW_SELECTION, NETWORK_SERVICE_DATA):
+                self.log, ad,
+                ad.droid.subscriptionGetDefaultDataSubId(), GEN_2G,
+                MAX_WAIT_TIME_NW_SELECTION, NETWORK_SERVICE_DATA):
             self.log.error("Device {} failed to reselect in {}s.".format(
                 ad.serial, MAX_WAIT_TIME_NW_SELECTION))
             return False
@@ -2004,7 +2004,7 @@
             False if failed.
         """
         ads = self.android_devices
-        if not self._test_setup_tethering(ads, network_generation):
+        if not self._test_setup_tethering(network_generation):
             self.log.error("Verify Internet access failed.")
             return False
         try:
@@ -2041,11 +2041,11 @@
                 self.log.error("Provider WiFi tethering stopped.")
                 return False
             if not is_data_available_during_call:
-                if verify_http_connection(self.log, ads[1], retry=0):
+                if verify_internet_connection(self.log, ads[1], retry=0):
                     self.log.error("Client should not have Internet Access.")
                     return False
             else:
-                if not verify_http_connection(self.log, ads[1]):
+                if not verify_internet_connection(self.log, ads[1]):
                     self.log.error("Client should have Internet Access.")
                     return False
 
@@ -2056,7 +2056,7 @@
             if not ads[0].droid.wifiIsApEnabled():
                 self.log.error("Provider WiFi tethering stopped.")
                 return False
-            if not verify_http_connection(self.log, ads[1]):
+            if not verify_internet_connection(self.log, ads[1]):
                 self.log.error("Client should have Internet Access.")
                 return False
         finally:
@@ -2137,11 +2137,11 @@
         """
         ads = self.android_devices
         current_data_sub_id = ads[0].droid.subscriptionGetDefaultDataSubId()
-        current_sim_slot_index = get_slot_index_from_subid(self.log, ads[0],
-                                                           current_data_sub_id)
+        current_sim_slot_index = get_slot_index_from_subid(
+            self.log, ads[0], current_data_sub_id)
         self.log.info("Current Data is on subId: {}, SIM slot: {}".format(
             current_data_sub_id, current_sim_slot_index))
-        if not self._test_setup_tethering(ads):
+        if not self._test_setup_tethering():
             self.log.error("Verify Internet access failed.")
             return False
         try:
@@ -2159,14 +2159,14 @@
                 next_sim_slot_index = \
                     {SIM1_SLOT_INDEX : SIM2_SLOT_INDEX,
                      SIM2_SLOT_INDEX : SIM1_SLOT_INDEX}[current_sim_slot_index]
-                self.log.info("Change Data to SIM slot: {}".format(
-                    next_sim_slot_index))
+                self.log.info(
+                    "Change Data to SIM slot: {}".format(next_sim_slot_index))
                 if not change_data_sim_and_verify_data(self.log, ads[0],
                                                        next_sim_slot_index):
                     self.log.error("Failed to change data SIM.")
                     return False
                 current_sim_slot_index = next_sim_slot_index
-                if not verify_http_connection(self.log, ads[1]):
+                if not verify_internet_connection(self.log, ads[1]):
                     self.log.error("Client should have Internet Access.")
                     return False
         finally:
@@ -2196,8 +2196,8 @@
         """
         ad = self.android_devices[0]
         current_data_sub_id = ad.droid.subscriptionGetDefaultDataSubId()
-        current_sim_slot_index = get_slot_index_from_subid(self.log, ad,
-                                                           current_data_sub_id)
+        current_sim_slot_index = get_slot_index_from_subid(
+            self.log, ad, current_data_sub_id)
         if current_sim_slot_index == SIM1_SLOT_INDEX:
             next_sim_slot_index = SIM2_SLOT_INDEX
         else:
@@ -2214,7 +2214,7 @@
                 voice_or_data=NETWORK_SERVICE_DATA):
             self.log.error("Device data does not attach to 2G.")
             return False
-        if not verify_http_connection(self.log, ad):
+        if not verify_internet_connection(self.log, ad):
             self.log.error("No Internet access on default Data SIM.")
             return False
 
@@ -2224,7 +2224,7 @@
             self.log.error("WiFi connect fail.")
             return False
         if (not wait_for_wifi_data_connection(self.log, ad, True) or
-                not verify_http_connection(self.log, ad)):
+                not verify_internet_connection(self.log, ad)):
             self.log.error("Data is not on WiFi")
             return False
 
@@ -2239,7 +2239,7 @@
                 self.log.error("Failed to attach data on subId:{}".format(
                     next_data_sub_id))
                 return False
-            if not verify_http_connection(self.log, ad):
+            if not verify_internet_connection(self.log, ad):
                 self.log.error("No Internet access after changing Data SIM.")
                 return False
 
@@ -2267,8 +2267,8 @@
         """
         ad = self.android_devices[0]
         current_data_sub_id = ad.droid.subscriptionGetDefaultDataSubId()
-        current_sim_slot_index = get_slot_index_from_subid(self.log, ad,
-                                                           current_data_sub_id)
+        current_sim_slot_index = get_slot_index_from_subid(
+            self.log, ad, current_data_sub_id)
         if current_sim_slot_index == SIM1_SLOT_INDEX:
             non_active_sim_slot_index = SIM2_SLOT_INDEX
         else:
@@ -2286,7 +2286,7 @@
                 voice_or_data=NETWORK_SERVICE_DATA):
             self.log.error("Device data does not attach to 2G.")
             return False
-        if not verify_http_connection(self.log, ad):
+        if not verify_internet_connection(self.log, ad):
             self.log.error("No Internet access on default Data SIM.")
             return False
 
diff --git a/acts/tests/google/tel/live/TelLiveSmsTest.py b/acts/tests/google/tel/live/TelLiveSmsTest.py
index 1e9468f..3032ce4 100644
--- a/acts/tests/google/tel/live/TelLiveSmsTest.py
+++ b/acts/tests/google/tel/live/TelLiveSmsTest.py
@@ -449,8 +449,8 @@
         else:
             return self._mms_test_mt_after_call_hangup(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="480b6ba2-1e5f-4a58-9d88-9b75c8fab1b6")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_general(self):
         """Test SMS basic function between two phone. Phones in any network.
 
@@ -472,8 +472,8 @@
 
         return self._sms_test_mo(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="aa87fe73-8236-44c7-865c-3fe3b733eeb4")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mt_general(self):
         """Test SMS basic function between two phone. Phones in any network.
 
@@ -495,8 +495,8 @@
 
         return self._sms_test_mt(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="57db830c-71eb-46b3-adaa-915c641de18d")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_general(self):
         """Test MMS basic function between two phone. Phones in any network.
 
@@ -518,8 +518,8 @@
 
         return self._mms_test_mo(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="f2779e1e-7d09-43f0-8b5c-87eae5d146be")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_general(self):
         """Test MMS basic function between two phone. Phones in any network.
 
@@ -541,8 +541,8 @@
 
         return self._mms_test_mt(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="2c229a4b-c954-4ba3-94ba-178dc7784d03")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_2g(self):
         """Test SMS basic function between two phone. Phones in 3g network.
 
@@ -564,8 +564,8 @@
 
         return self._sms_test_mo(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="17fafc41-7e12-47ab-a4cc-fb9bd94e79b9")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mt_2g(self):
         """Test SMS basic function between two phone. Phones in 3g network.
 
@@ -587,8 +587,8 @@
 
         return self._sms_test_mt(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="b4919317-18b5-483c-82f4-ced37a04f28d")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_2g(self):
         """Test MMS basic function between two phone. Phones in 3g network.
 
@@ -610,8 +610,8 @@
 
         return self._mms_test_mo(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="cd56bb8a-0794-404d-95bd-c5fd00f4b35a")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_2g(self):
         """Test MMS basic function between two phone. Phones in 3g network.
 
@@ -633,8 +633,8 @@
 
         return self._mms_test_mt(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="b39fbc30-9cc2-4d86-a9f4-6f0c1dd0a905")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_2g_wifi(self):
         """Test MMS basic function between two phone. Phones in 3g network.
 
@@ -659,8 +659,8 @@
 
         return self._mms_test_mo(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="b158a0a7-9697-4b3b-8d5b-f9b6b6bc1c03")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_2g_wifi(self):
         """Test MMS basic function between two phone. Phones in 3g network.
 
@@ -685,8 +685,8 @@
 
         return self._mms_test_mt(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="f094e3da-2523-4f92-a1f3-7cf9edcff850")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_3g(self):
         """Test SMS basic function between two phone. Phones in 3g network.
 
@@ -709,8 +709,8 @@
 
         return self._sms_test_mo(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="2186e152-bf83-4d6e-93eb-b4bf9ae2d76e")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mt_3g(self):
         """Test SMS basic function between two phone. Phones in 3g network.
 
@@ -733,8 +733,8 @@
 
         return self._sms_test_mt(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="e716c678-eee9-4a0d-a9cd-ca9eae4fea51")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_3g(self):
         """Test MMS basic function between two phone. Phones in 3g network.
 
@@ -757,8 +757,8 @@
 
         return self._mms_test_mo(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="e864a99e-d935-4bd9-95f6-8183cdd3d760")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_3g(self):
         """Test MMS basic function between two phone. Phones in 3g network.
 
@@ -781,8 +781,8 @@
 
         return self._mms_test_mt(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="c6cfba55-6cde-41cd-93bb-667c317a0127")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_3g_wifi(self):
         """Test MMS basic function between two phone. Phones in 3g network.
 
@@ -808,8 +808,8 @@
 
         return self._mms_test_mo(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="83c5dd99-f2fe-433d-9775-80a36d0d493b")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_3g_wifi(self):
         """Test MMS basic function between two phone. Phones in 3g network.
 
@@ -835,8 +835,8 @@
 
         return self._mms_test_mt(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="c97687e2-155a-4cf3-9f51-22543b89d53e")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_4g(self):
         """Test SMS basic function between two phone. Phones in LTE network.
 
@@ -860,8 +860,8 @@
 
         return self._sms_test_mo(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="e2e01a47-2b51-4d00-a7b2-dbd3c8ffa6ae")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mt_4g(self):
         """Test SMS basic function between two phone. Phones in LTE network.
 
@@ -886,8 +886,8 @@
 
         return self._sms_test_mt(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="5795143c-5252-4536-9fd3-b28e83124e1c")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_4g(self):
         """Test MMS text function between two phone. Phones in LTE network.
 
@@ -910,8 +910,8 @@
 
         return self._mms_test_mo(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="dc24361c-713f-45eb-ac7b-a34c649f1c36")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_4g(self):
         """Test MMS text function between two phone. Phones in LTE network.
 
@@ -934,8 +934,8 @@
 
         return self._mms_test_mt(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="c7349fdf-a376-4846-b466-1f329bd1557f")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_4g_wifi(self):
         """Test MMS text function between two phone. Phones in LTE network.
 
@@ -960,8 +960,8 @@
                               self.wifi_network_pass)
         return self._mms_test_mo(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="1affab34-e03c-49dd-9062-e9ed8eac406b")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_4g_wifi(self):
         """Test MMS text function between two phone. Phones in LTE network.
 
@@ -987,8 +987,8 @@
 
         return self._mms_test_mt(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="7ee57edb-2962-4d20-b6eb-79cebce91fff")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_in_call_volte(self):
         """ Test MO SMS during a MO VoLTE call.
 
@@ -1023,8 +1023,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="5576276b-4ca1-41cc-bb74-31ccd71f9f96")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mt_in_call_volte(self):
         """ Test MT SMS during a MO VoLTE call.
 
@@ -1059,8 +1059,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="3bf8ff74-baa6-4dc6-86eb-c13816fa9bc8")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_in_call_volte(self):
         """ Test MO MMS during a MO VoLTE call.
 
@@ -1095,8 +1095,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="289e6516-5f66-403a-b292-50d067151730")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_in_call_volte(self):
         """ Test MT MMS during a MO VoLTE call.
 
@@ -1131,8 +1131,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="5654d974-3c32-4cce-9d07-0c96213dacc5")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_in_call_volte_wifi(self):
         """ Test MO MMS during a MO VoLTE call.
 
@@ -1170,8 +1170,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="cbd5ab3d-d76a-4ece-ac09-62efeead7550")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_in_call_volte_wifi(self):
         """ Test MT MMS during a MO VoLTE call.
 
@@ -1209,8 +1209,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="516457ae-5f99-41c1-b145-bfe72876b872")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_in_call_wcdma(self):
         """ Test MO SMS during a MO wcdma call.
 
@@ -1235,8 +1235,8 @@
 
         return self._mo_sms_in_3g_call(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="d99697f4-5be2-46f2-9d95-aa73b5d9cebc")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mt_in_call_wcdma(self):
         """ Test MT SMS during a MO wcdma call.
 
@@ -1261,8 +1261,8 @@
 
         return self._mt_sms_in_3g_call(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="2a2d64cc-88db-4ec0-9c2d-1da24a0f9eaf")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_in_call_wcdma(self):
         """ Test MO MMS during a MO wcdma call.
 
@@ -1287,8 +1287,8 @@
 
         return self._mo_mms_in_3g_call(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="20df9556-a8af-4346-97b8-b97596d146a4")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_in_call_wcdma(self):
         """ Test MT MMS during a MO wcdma call.
 
@@ -1313,8 +1313,8 @@
 
         return self._mt_mms_in_3g_call(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="c4a39519-44d8-4194-8dfc-68b1dd723b39")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_in_call_wcdma_wifi(self):
         """ Test MO MMS during a MO wcdma call.
 
@@ -1342,8 +1342,8 @@
 
         return self._mo_mms_in_3g_call(ads, wifi=True)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="bcc5b02d-2fef-431a-8c0b-f31c98999bfb")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_in_call_wcdma_wifi(self):
         """ Test MT MMS during a MO wcdma call.
 
@@ -1371,8 +1371,8 @@
                               self.wifi_network_pass)
         return self._mt_mms_in_3g_call(ads, wifi=True)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="b6e9ce80-8577-48e5-baa7-92780932f278")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_in_call_csfb(self):
         """ Test MO SMS during a MO csfb wcdma/gsm call.
 
@@ -1397,8 +1397,8 @@
 
         return self._mo_sms_in_csfb_call(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="93f0b58a-01e9-4bc9-944f-729d455597dd")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mt_in_call_csfb(self):
         """ Test MT SMS during a MO csfb wcdma/gsm call.
 
@@ -1423,8 +1423,8 @@
 
         return self._mt_sms_in_csfb_call(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="bd8e9e80-1955-429f-b122-96b127771bbb")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_in_call_csfb(self):
         """ Test MO MMS during a MO csfb wcdma/gsm call.
 
@@ -1449,8 +1449,8 @@
 
         return self._mo_mms_in_csfb_call(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="89d65fd2-fc75-4fc5-a018-2d05a4364304")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_in_call_csfb(self):
         """ Test MT MMS during a MO csfb wcdma/gsm call.
 
@@ -1475,8 +1475,8 @@
 
         return self._mt_mms_in_csfb_call(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="9c542b5d-3b8f-4d4a-80de-fb804f066c3d")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_in_call_csfb_wifi(self):
         """ Test MO MMS during a MO csfb wcdma/gsm call.
 
@@ -1504,8 +1504,8 @@
 
         return self._mo_mms_in_csfb_call(ads, wifi=True)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="c1bed6f5-f65c-4f4d-aa06-0e9f5c867819")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_in_call_csfb_wifi(self):
         """ Test MT MMS during a MO csfb wcdma/gsm call.
 
@@ -1533,8 +1533,8 @@
 
         return self._mt_mms_in_csfb_call(ads, wifi=True)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="60996028-b4b2-4a16-9e4b-eb6ef80179a7")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_in_call_1x(self):
         """ Test MO SMS during a MO 1x call.
 
@@ -1559,8 +1559,8 @@
 
         return self._mo_sms_in_1x_call(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="6b352aac-9b4e-4062-8980-3b1c0e61015b")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mt_in_call_1x(self):
         """ Test MT SMS during a MO 1x call.
 
@@ -1585,8 +1585,8 @@
 
         return self._mt_sms_in_1x_call(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="cfae3613-c490-4ce0-b00b-c13286d85027")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_in_call_1x(self):
         """ Test MO MMS during a MO 1x call.
 
@@ -1612,8 +1612,8 @@
 
         return self._mo_mms_in_1x_call(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="4311cb8c-626d-48a9-955b-6505b41c7519")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_in_call_1x(self):
         """ Test MT MMS during a MO 1x call.
 
@@ -1638,8 +1638,8 @@
 
         return self._mt_mms_in_1x_call(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="18093f87-aab5-4d86-b178-8085a1651828")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_in_call_1x_wifi(self):
         """ Test MO MMS during a MO 1x call.
 
@@ -1667,8 +1667,8 @@
 
         return self._mo_mms_in_1x_call(ads, wifi=True)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="8fe3359a-0857-401f-a043-c47a2a2acb47")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_in_call_1x_wifi(self):
         """ Test MT MMS during a MO 1x call.
 
@@ -1695,8 +1695,8 @@
 
         return self._mt_mms_in_1x_call(ads, wifi=True)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="96214c7c-2843-4242-8cfa-1d08241514b0")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_in_call_csfb_1x(self):
         """ Test MO SMS during a MO csfb 1x call.
 
@@ -1721,8 +1721,8 @@
 
         return self._mo_sms_in_1x_call(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="3780a8e5-2649-45e6-bf6b-9ab1e86456eb")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mt_in_call_csfb_1x(self):
         """ Test MT SMS during a MO csfb 1x call.
 
@@ -1747,8 +1747,8 @@
 
         return self._mt_sms_in_1x_call(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="5de29f86-1aa8-46ff-a679-97309c314fe2")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_in_call_csfb_1x(self):
         """ Test MO MMS during a MO csfb 1x call.
 
@@ -1773,8 +1773,8 @@
 
         return self._mo_mms_in_1x_call(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="29ed3fea-0409-4b43-9caf-dbbaac7d430f")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_in_call_csfb_1x(self):
         """ Test MT MMS during a MO csfb 1x call.
 
@@ -1799,8 +1799,8 @@
 
         return self._mt_mms_in_1x_call(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="12e05635-7934-4f14-a27e-430d0fc52edb")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_in_call_csfb_1x_wifi(self):
         """ Test MO MMS during a MO csfb 1x call.
 
@@ -1827,8 +1827,8 @@
 
         return self._mo_mms_in_1x_call(ads, wifi=True)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="bd884be7-756b-4f0f-b233-052dc79233c0")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_in_call_csfb_1x_wifi(self):
         """ Test MT MMS during a MO csfb 1x call.
 
@@ -1855,8 +1855,8 @@
 
         return self._mt_mms_in_1x_call(ads, wifi=True)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="ed720013-e366-448b-8901-bb09d26cea05")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_iwlan(self):
         """ Test MO SMS, Phone in APM, WiFi connected, WFC WiFi Preferred mode.
 
@@ -1881,8 +1881,8 @@
 
         return self._sms_test_mo(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="4d4b0b7b-bf00-44f6-a0ed-23b438c30fc2")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mt_iwlan(self):
         """ Test MT SMS, Phone in APM, WiFi connected, WFC WiFi Preferred mode.
 
@@ -1907,8 +1907,8 @@
 
         return self._sms_test_mt(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="30139605-fdb0-4f8f-8772-2f56addb6f21")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_iwlan(self):
         """ Test MO MMS, Phone in APM, WiFi connected, WFC WiFi Preferred mode.
 
@@ -1933,8 +1933,8 @@
 
         return self._mms_test_mo(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="d1e1b686-fa16-4715-9506-be2e2b1e1a96")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_iwlan(self):
         """ Test MT MMS, Phone in APM, WiFi connected, WFC WiFi Preferred mode.
 
@@ -1959,8 +1959,8 @@
 
         return self._mms_test_mt(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="075933a2-df7f-4374-a405-92f96bcc7770")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_apm_wifi_wfc_off(self):
         """ Test MO SMS, Phone in APM, WiFi connected, WFC off.
 
@@ -1983,8 +1983,8 @@
 
         return self._sms_test_mo(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="637af228-29fc-4b74-a963-883f66ddf080")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mt_apm_wifi_wfc_off(self):
         """ Test MT SMS, Phone in APM, WiFi connected, WFC off.
 
@@ -2007,8 +2007,8 @@
 
         return self._sms_test_mt(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="502aba0d-8895-4807-b394-50a44208ecf7")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_apm_wifi_wfc_off(self):
         """ Test MO MMS, Phone in APM, WiFi connected, WFC off.
 
@@ -2031,8 +2031,8 @@
 
         return self._mms_test_mo(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="235bfdbf-4275-4d89-99f5-41b5b7de8345")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_apm_wifi_wfc_off(self):
         """ Test MT MMS, Phone in APM, WiFi connected, WFC off.
 
@@ -2055,8 +2055,8 @@
 
         return self._mms_test_mt(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="e5a31b94-1cb6-4770-a2bc-5a0ddba51502")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_in_call_iwlan(self):
         """ Test MO SMS, Phone in APM, WiFi connected, WFC WiFi Preferred mode.
 
@@ -2092,8 +2092,8 @@
 
         return self._sms_test_mo(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="d6d30cc5-f75b-42df-b517-401456ee8466")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mt_in_call_iwlan(self):
         """ Test MT SMS, Phone in APM, WiFi connected, WFC WiFi Preferred mode.
 
@@ -2129,8 +2129,8 @@
 
         return self._sms_test_mt(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="54e4244a-2c8b-4350-9b2c-ade6e05b1494")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_in_call_iwlan(self):
         """ Test MO MMS, Phone in APM, WiFi connected, WFC WiFi Preferred mode.
 
@@ -2166,8 +2166,8 @@
 
         return self._mms_test_mo(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="6cf9d2a3-b476-4855-95d7-ce4b426a0a2f")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_in_call_iwlan(self):
         """ Test MT MMS, Phone in APM, WiFi connected, WFC WiFi Preferred mode.
 
@@ -2203,8 +2203,8 @@
 
         return self._mms_test_mt(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="9f1933bb-c4cb-4655-8655-327c1f38e8ee")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_in_call_vt(self):
         """ Test MO SMS, Phone in ongoing VT call.
 
@@ -2236,8 +2236,8 @@
 
         return self._sms_test_mo(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="0a07e737-4862-4492-9b48-8d94799eab91")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mt_in_call_vt(self):
         """ Test MT SMS, Phone in ongoing VT call.
 
@@ -2269,8 +2269,8 @@
 
         return self._sms_test_mt(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="80254125-861f-4f3d-9164-eb9a2699152e")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_in_call_vt(self):
         """ Test MO MMS, Phone in ongoing VT call.
 
@@ -2302,8 +2302,8 @@
 
         return self._mms_test_mo(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="a46074f0-304b-4bb0-a2da-5102ee2be619")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_in_call_vt(self):
         """ Test MT MMS, Phone in ongoing VT call.
 
@@ -2335,8 +2335,8 @@
 
         return self._mms_test_mt(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="c60c89ba-ff72-425d-9ac0-93cb2ee5a0bc")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mo_in_call_gsm(self):
         """ Test MO SMS during a MO gsm call.
 
@@ -2375,8 +2375,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="ba55daf2-89b9-450c-9832-732fd9413410")
+    @TelephonyBaseTest.tel_test_wrap
     def test_sms_mt_in_call_gsm(self):
         """ Test MT SMS during a MO gsm call.
 
@@ -2415,8 +2415,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="2bd94d69-3621-4b94-abc7-bd24c4325485")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_in_call_gsm(self):
         """ Test MO MMS during a MO gsm call.
 
@@ -2441,8 +2441,8 @@
 
         return self._mo_mms_in_2g_call(ads)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="e20be70d-99d6-4344-a742-f69581b66d8f")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_in_call_gsm(self):
         """ Test MT MMS during a MO gsm call.
 
@@ -2468,6 +2468,7 @@
         return self._mt_mms_in_2g_call(ads)
 
     @test_tracker_info(uuid="3510d368-4b16-4716-92a3-9dd01842ba79")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mo_in_call_gsm_wifi(self):
         """ Test MO MMS during a MO gsm call.
 
@@ -2494,8 +2495,8 @@
 
         return self._mo_mms_in_2g_call(ads, wifi=True)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="060def89-01bd-4b44-a49b-a4536fe39165")
+    @TelephonyBaseTest.tel_test_wrap
     def test_mms_mt_in_call_gsm_wifi(self):
         """ Test MT MMS during a MO gsm call.
 
diff --git a/acts/tests/google/tel/live/TelLiveVoiceTest.py b/acts/tests/google/tel/live/TelLiveVoiceTest.py
index e843cfc..fa9db92 100644
--- a/acts/tests/google/tel/live/TelLiveVoiceTest.py
+++ b/acts/tests/google/tel/live/TelLiveVoiceTest.py
@@ -110,7 +110,8 @@
 from acts.test_utils.tel.tel_voice_utils import two_phone_call_short_seq
 
 DEFAULT_LONG_DURATION_CALL_TOTAL_DURATION = 1 * 60 * 60  # default value 1 hour
-DEFAULT_PING_DURATION = 120 # in seconds
+DEFAULT_PING_DURATION = 120  # in seconds
+
 
 class TelLiveVoiceTest(TelephonyBaseTest):
     def __init__(self, controllers):
@@ -174,8 +175,8 @@
         return two_phone_call_short_seq(self.log, ads[1], None, None, ads[0],
                                         None, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -200,8 +201,8 @@
             phone_idle_volte, is_phone_in_call_volte, None,
             WAIT_TIME_IN_CALL_FOR_IMS)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -225,17 +226,16 @@
                                                        7)
         try:
             set_phone_number(self.log, ads[1], caller_dialing_number)
-            result = call_setup_teardown(
+            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)
         except Exception as e:
             self.log.error("Exception happened: {}".format(e))
         finally:
             set_phone_number(self.log, ads[1], callee_default_number)
-        return result
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -259,17 +259,16 @@
                                                        10)
         try:
             set_phone_number(self.log, ads[1], caller_dialing_number)
-            result = call_setup_teardown(
+            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)
         except Exception as e:
             self.log.error("Exception happened: {}".format(e))
         finally:
             set_phone_number(self.log, ads[1], callee_default_number)
-        return result
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -293,17 +292,16 @@
                                                        11)
         try:
             set_phone_number(self.log, ads[1], caller_dialing_number)
-            result = call_setup_teardown(
+            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)
         except Exception as e:
             self.log.error("Exception happened: {}".format(e))
         finally:
             set_phone_number(self.log, ads[1], callee_default_number)
-        return result
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -327,17 +325,16 @@
                                                        12)
         try:
             set_phone_number(self.log, ads[1], caller_dialing_number)
-            result = call_setup_teardown(
+            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)
         except Exception as e:
             self.log.error("Exception happened: {}".format(e))
         finally:
             set_phone_number(self.log, ads[1], callee_default_number)
-        return result
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -361,8 +358,8 @@
             self.log, ads[0], phone_idle_volte, is_phone_in_call_volte, ads[1],
             phone_idle_csfb, is_phone_in_call_csfb, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -386,8 +383,8 @@
                                         None, ads[1], phone_idle_csfb,
                                         is_phone_in_call_csfb, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -418,8 +415,8 @@
             self.log, ads[0], phone_idle_volte, is_phone_in_call_volte, ads[1],
             phone_idle_csfb, is_phone_in_call_1x, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -450,8 +447,8 @@
             self.log, ads[0], phone_idle_volte, is_phone_in_call_volte, ads[1],
             phone_idle_csfb, is_phone_in_call_csfb, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -475,8 +472,8 @@
             self.log, ads[0], phone_idle_volte, is_phone_in_call_volte, ads[1],
             phone_idle_3g, is_phone_in_call_3g, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -506,8 +503,8 @@
             self.log, ads[0], phone_idle_volte, is_phone_in_call_volte, ads[1],
             phone_idle_3g, is_phone_in_call_1x, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -538,8 +535,8 @@
             self.log, ads[0], phone_idle_volte, is_phone_in_call_volte, ads[1],
             phone_idle_3g, is_phone_in_call_wcdma, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -586,10 +583,10 @@
         Returns:
             True if pass; False if fail.
         """
-        tasks = [(phone_setup_iwlan,
-                  (self.log, ads[0], apm_mode, wfc_mode, wifi_ssid, wifi_pwd)),
-                 (phone_setup_iwlan,
-                  (self.log, ads[1], apm_mode, wfc_mode, wifi_ssid, wifi_pwd))]
+        tasks = [(phone_setup_iwlan, (self.log, ads[0], apm_mode, wfc_mode,
+                                      wifi_ssid, wifi_pwd)),
+                 (phone_setup_iwlan, (self.log, ads[1], apm_mode, wfc_mode,
+                                      wifi_ssid, wifi_pwd))]
         if not multithread_func(self.log, tasks):
             self.log.error("Phone Failed to Set Up Properly.")
             return False
@@ -613,8 +610,8 @@
             self.log.error("ICMP transfer failed with parallel phone call.")
             return False
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -630,8 +627,8 @@
             self.android_devices, False, WFC_MODE_WIFI_ONLY,
             self.wifi_network_ssid, self.wifi_network_pass)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -647,8 +644,8 @@
             self.android_devices, False, WFC_MODE_WIFI_PREFERRED,
             self.wifi_network_ssid, self.wifi_network_pass)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -674,8 +671,8 @@
             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)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -691,8 +688,8 @@
             self.android_devices, True, WFC_MODE_WIFI_ONLY,
             self.wifi_network_ssid, self.wifi_network_pass)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -708,8 +705,8 @@
             self.android_devices, True, WFC_MODE_WIFI_PREFERRED,
             self.wifi_network_ssid, self.wifi_network_pass)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -725,8 +722,8 @@
             self.android_devices, True, WFC_MODE_CELLULAR_PREFERRED,
             self.wifi_network_ssid, self.wifi_network_pass)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -753,8 +750,8 @@
             phone_idle_volte, is_phone_in_call_volte, None,
             WAIT_TIME_IN_CALL_FOR_IMS)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -781,8 +778,8 @@
             phone_idle_volte, is_phone_in_call_volte, None,
             WAIT_TIME_IN_CALL_FOR_IMS)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -809,8 +806,8 @@
             phone_idle_volte, is_phone_in_call_volte, None,
             WAIT_TIME_IN_CALL_FOR_IMS)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -837,8 +834,8 @@
             phone_idle_volte, is_phone_in_call_volte, None,
             WAIT_TIME_IN_CALL_FOR_IMS)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -864,8 +861,8 @@
             self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
             phone_idle_csfb, is_phone_in_call_csfb, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -891,8 +888,8 @@
             self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
             phone_idle_csfb, is_phone_in_call_csfb, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -918,8 +915,8 @@
             self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
             phone_idle_csfb, is_phone_in_call_csfb, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -945,8 +942,8 @@
             self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
             phone_idle_csfb, is_phone_in_call_csfb, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -972,8 +969,8 @@
             self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
             phone_idle_3g, is_phone_in_call_3g, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -999,8 +996,8 @@
             self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
             phone_idle_3g, is_phone_in_call_3g, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -1026,8 +1023,8 @@
             self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
             phone_idle_3g, is_phone_in_call_3g, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -1053,8 +1050,8 @@
             self.log, ads[0], phone_idle_iwlan, is_phone_in_call_iwlan, ads[1],
             phone_idle_3g, is_phone_in_call_3g, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -1078,8 +1075,8 @@
             self.log, ads[0], phone_idle_csfb, is_phone_in_call_csfb, ads[1],
             phone_idle_csfb, is_phone_in_call_csfb, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -1103,8 +1100,8 @@
             self.log, ads[0], phone_idle_3g, is_phone_in_call_3g, ads[1],
             phone_idle_3g, is_phone_in_call_3g, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -1131,8 +1128,8 @@
             phone_idle_volte, is_phone_in_call_volte, None,
             WAIT_TIME_IN_CALL_FOR_IMS)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -1163,8 +1160,8 @@
             phone_idle_iwlan, is_phone_in_call_iwlan, None,
             WAIT_TIME_IN_CALL_FOR_IMS)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="7049de19-3abf-48df-868f-18d0af829393")
+    @TelephonyBaseTest.tel_test_wrap
     def test_call_epdg_to_epdg_long_wfc_wifi_preferred(self):
         """ WiFi Preferred, WiFi calling to WiFi Calling test
 
@@ -1195,8 +1192,8 @@
             phone_idle_iwlan, is_phone_in_call_iwlan, None,
             WAIT_TIME_IN_CALL_FOR_IMS)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -1227,8 +1224,8 @@
             phone_idle_iwlan, is_phone_in_call_iwlan, None,
             WAIT_TIME_IN_CALL_FOR_IMS)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="2b926e4a-f493-41fa-98af-20d25ec132bb")
+    @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
 
@@ -1259,8 +1256,8 @@
             phone_idle_iwlan, is_phone_in_call_iwlan, None,
             WAIT_TIME_IN_CALL_FOR_IMS)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="30d5d573-043f-4d8b-98e0-e7f7bc9b8d6f")
+    @TelephonyBaseTest.tel_test_wrap
     def test_call_csfb_3g_to_csfb_3g_long(self):
         """ CSFB 3G to CSFB 3G call test
 
@@ -1286,8 +1283,8 @@
             self.log, ads[0], phone_idle_csfb, is_phone_in_call_csfb, ads[1],
             phone_idle_csfb, is_phone_in_call_csfb, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -1313,8 +1310,8 @@
             self.log, ads[0], phone_idle_3g, is_phone_in_call_3g, ads[1],
             phone_idle_3g, is_phone_in_call_3g, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="")
+    @TelephonyBaseTest.tel_test_wrap
     def test_call_volte_to_volte_loop(self):
         """ Stress test: VoLTE to VoLTE call test
 
@@ -1362,14 +1359,14 @@
         self.log.info("Final Count - Success: {}, Failure: {} - {}%".format(
             success_count, fail_count,
             str(100 * success_count / (success_count + fail_count))))
-        if success_count / (success_count + fail_count
-                            ) >= MINIMUM_SUCCESS_RATE:
+        if success_count / (
+                success_count + fail_count) >= MINIMUM_SUCCESS_RATE:
             return True
         else:
             return False
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -1421,14 +1418,14 @@
         self.log.info("Final Count - Success: {}, Failure: {} - {}%".format(
             success_count, fail_count,
             str(100 * success_count / (success_count + fail_count))))
-        if success_count / (success_count + fail_count
-                            ) >= MINIMUM_SUCCESS_RATE:
+        if success_count / (
+                success_count + fail_count) >= MINIMUM_SUCCESS_RATE:
             return True
         else:
             return False
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -1480,14 +1477,14 @@
         self.log.info("Final Count - Success: {}, Failure: {} - {}%".format(
             success_count, fail_count,
             str(100 * success_count / (success_count + fail_count))))
-        if success_count / (success_count + fail_count
-                            ) >= MINIMUM_SUCCESS_RATE:
+        if success_count / (
+                success_count + fail_count) >= MINIMUM_SUCCESS_RATE:
             return True
         else:
             return False
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -1539,14 +1536,14 @@
         self.log.info("Final Count - Success: {}, Failure: {} - {}%".format(
             success_count, fail_count,
             str(100 * success_count / (success_count + fail_count))))
-        if success_count / (success_count + fail_count
-                            ) >= MINIMUM_SUCCESS_RATE:
+        if success_count / (
+                success_count + fail_count) >= MINIMUM_SUCCESS_RATE:
             return True
         else:
             return False
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -1598,14 +1595,14 @@
         self.log.info("Final Count - Success: {}, Failure: {} - {}%".format(
             success_count, fail_count,
             str(100 * success_count / (success_count + fail_count))))
-        if success_count / (success_count + fail_count
-                            ) >= MINIMUM_SUCCESS_RATE:
+        if success_count / (
+                success_count + fail_count) >= MINIMUM_SUCCESS_RATE:
             return True
         else:
             return False
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -1651,14 +1648,14 @@
 
         self.log.info("Final Count - Success: {}, Failure: {}".format(
             success_count, fail_count))
-        if success_count / (success_count + fail_count
-                            ) >= MINIMUM_SUCCESS_RATE:
+        if success_count / (
+                success_count + fail_count) >= MINIMUM_SUCCESS_RATE:
             return True
         else:
             return False
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="")
+    @TelephonyBaseTest.tel_test_wrap
     def test_call_3g_to_3g_loop(self):
         """ Stress test: 3G to 3G call test
 
@@ -1704,8 +1701,8 @@
 
         self.log.info("Final Count - Success: {}, Failure: {}".format(
             success_count, fail_count))
-        if success_count / (success_count + fail_count
-                            ) >= MINIMUM_SUCCESS_RATE:
+        if success_count / (
+                success_count + fail_count) >= MINIMUM_SUCCESS_RATE:
             return True
         else:
             return False
@@ -1767,8 +1764,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -1812,8 +1809,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -1857,8 +1854,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -1902,8 +1899,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -1947,8 +1944,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -1992,8 +1989,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -2037,8 +2034,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -2082,8 +2079,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -2127,8 +2124,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -2170,8 +2167,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -2213,8 +2210,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -2260,8 +2257,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -2307,8 +2304,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -2354,8 +2351,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -2401,8 +2398,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @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,
@@ -2430,8 +2427,8 @@
         return call_voicemail_erase_all_pending_voicemail(
             self.log, self.android_devices[1])
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
@@ -2458,8 +2455,8 @@
         return two_phone_call_leave_voice_mail(self.log, ads[0], None, None,
                                                ads[1], phone_idle_volte)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
@@ -2486,8 +2483,8 @@
         return two_phone_call_leave_voice_mail(self.log, ads[0], None, None,
                                                ads[1], phone_idle_csfb)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
@@ -2514,8 +2511,8 @@
         return two_phone_call_leave_voice_mail(self.log, ads[0], None, None,
                                                ads[1], phone_idle_3g)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
@@ -2542,8 +2539,8 @@
         return two_phone_call_leave_voice_mail(self.log, ads[1], None, None,
                                                ads[0], phone_idle_2g)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
@@ -2572,8 +2569,8 @@
         return two_phone_call_leave_voice_mail(self.log, ads[0], None, None,
                                                ads[1], phone_idle_iwlan)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
@@ -2602,8 +2599,8 @@
         return two_phone_call_leave_voice_mail(self.log, ads[0], None, None,
                                                ads[1], phone_idle_iwlan)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="cfc94b2c-8e28-4e6f-b4d3-1cc8af18a52b")
+    @TelephonyBaseTest.tel_test_wrap
     def test_call_2g_to_2g(self):
         """ Test 2g<->2g call functionality.
 
@@ -2627,8 +2624,8 @@
             self.log, ads[0], phone_idle_2g, is_phone_in_call_2g, ads[1],
             phone_idle_2g, is_phone_in_call_2g, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="057a2213-8b78-497b-8d65-e6ed87d337cb")
+    @TelephonyBaseTest.tel_test_wrap
     def test_call_2g_to_2g_long(self):
         """ Test 2g<->2g call functionality.
 
@@ -2654,8 +2651,8 @@
             self.log, ads[0], phone_idle_2g, is_phone_in_call_2g, ads[1],
             phone_idle_2g, is_phone_in_call_2g, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="6e24e64f-aa0e-4101-89ed-4cc30c738c7e")
+    @TelephonyBaseTest.tel_test_wrap
     def test_call_3g_to_2g_long(self):
         """ Test 3g<->2g call functionality.
 
@@ -2681,8 +2678,8 @@
             self.log, ads[0], phone_idle_2g, is_phone_in_call_3g, ads[1],
             phone_idle_2g, is_phone_in_call_2g, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @test_tracker_info(uuid="0db7fc8b-4f83-4e30-80ab-cc53c8eff99f")
+    @TelephonyBaseTest.tel_test_wrap
     def test_call_2g_to_3g_long(self):
         """ Test 2g<->3g call functionality.
 
@@ -2708,8 +2705,8 @@
             self.log, ads[0], phone_idle_2g, is_phone_in_call_2g, ads[1],
             phone_idle_2g, is_phone_in_call_3g, None)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
 
@@ -2754,8 +2751,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
 
@@ -2812,8 +2809,8 @@
             verify_caller_func=dut_incall_check_func,
             wait_time_in_call=total_duration)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
 
@@ -2840,8 +2837,8 @@
         return self._test_call_long_duration(
             is_phone_in_call_volte, self.long_duration_call_total_duration)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
 
@@ -2870,8 +2867,8 @@
         return self._test_call_long_duration(
             is_phone_in_call_iwlan, self.long_duration_call_total_duration)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
 
@@ -2941,8 +2938,8 @@
 
         return True
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -2957,8 +2954,8 @@
         return self._test_call_hangup_while_ringing(self.android_devices[0],
                                                     self.android_devices[1])
 
-    @TelephonyBaseTest.tel_test_wrap
     @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
 
@@ -3043,14 +3040,13 @@
             self.log.info("Data transfer succeeded.")
             return True
         elif not allow_data_transfer_interruption:
-            self.log.error(
-                "Data transfer failed with parallel phone call.")
+            self.log.error("Data transfer failed with parallel phone call.")
             return False
         self.log.info("Retry data transfer after call hung up")
         return download_task[0](*download_task[1])
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
 
@@ -3070,8 +3066,8 @@
         return self._test_call_setup_in_active_data_transfer(
             None, DIRECTION_MOBILE_ORIGINATED)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
 
@@ -3091,8 +3087,8 @@
         return self._test_call_setup_in_active_data_transfer(
             None, DIRECTION_MOBILE_TERMINATED)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
 
@@ -3115,8 +3111,8 @@
         return self._test_call_setup_in_active_data_transfer(
             GEN_4G, DIRECTION_MOBILE_ORIGINATED)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
 
@@ -3139,8 +3135,8 @@
         return self._test_call_setup_in_active_data_transfer(
             GEN_4G, DIRECTION_MOBILE_TERMINATED)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
 
@@ -3165,8 +3161,8 @@
             DIRECTION_MOBILE_ORIGINATED,
             allow_data_transfer_interruption=True)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
 
@@ -3191,8 +3187,8 @@
             DIRECTION_MOBILE_TERMINATED,
             allow_data_transfer_interruption=True)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
 
@@ -3217,8 +3213,8 @@
             DIRECTION_MOBILE_ORIGINATED,
             allow_data_transfer_interruption=True)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
 
@@ -3243,8 +3239,8 @@
             DIRECTION_MOBILE_TERMINATED,
             allow_data_transfer_interruption=True)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
 
@@ -3269,8 +3265,8 @@
             DIRECTION_MOBILE_ORIGINATED,
             allow_data_transfer_interruption=True)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
 
@@ -3295,8 +3291,8 @@
             DIRECTION_MOBILE_TERMINATED,
             allow_data_transfer_interruption=True)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
 
@@ -3319,8 +3315,8 @@
         return self._test_call_setup_in_active_data_transfer(
             None, DIRECTION_MOBILE_ORIGINATED)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
 
@@ -3343,8 +3339,8 @@
         return self._test_call_setup_in_active_data_transfer(
             None, DIRECTION_MOBILE_TERMINATED)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
 
@@ -3367,8 +3363,8 @@
         return self._test_call_setup_in_active_data_transfer(
             None, DIRECTION_MOBILE_ORIGINATED)
 
-    @TelephonyBaseTest.tel_test_wrap
     @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.
 
diff --git a/acts/tests/google/tel/live/TelWifiDataTest.py b/acts/tests/google/tel/live/TelWifiDataTest.py
index 664d134..5da2eac 100644
--- a/acts/tests/google/tel/live/TelWifiDataTest.py
+++ b/acts/tests/google/tel/live/TelWifiDataTest.py
@@ -28,6 +28,7 @@
 from acts.test_utils.tel.tel_test_utils import wait_for_cell_data_connection
 from acts.test_utils.tel.tel_test_utils import wait_for_wifi_data_connection
 from acts.test_utils.tel.tel_test_utils import run_multithread_func
+from acts.test_utils.tel.tel_test_utils import active_data_transfer_test
 from acts.utils import adb_shell_ping
 
 # Attenuator name
@@ -42,8 +43,7 @@
 class TelWifiDataTest(TelephonyBaseTest):
     def __init__(self, controllers):
         TelephonyBaseTest.__init__(self, controllers)
-        self.tests = ("test_wifi_cell_switching_stress",
-                      "test_wifi_cell_irat_stress_ping_continuous",)
+
         self.stress_test_number = self.get_stress_test_number()
         self.live_network_ssid = self.user_params["wifi_network_ssid"]
         self.live_network_pwd = self.user_params.get("wifi_network_pass")
@@ -78,34 +78,74 @@
             return False
         return True
 
+    def _atten_setup_wifi_cell(self):
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+
+    def _atten_setup_cell_only(self):
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+
+    def _atten_setup_lte_only(self):
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+
+    def _atten_setup_wcdma_only(self):
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
+
+    def _atten_setup_wifi_only(self):
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
+
     @TelephonyBaseTest.tel_test_wrap
-    def _wifi_cell_irat_task(self, ad_dut, irat_wait_time=60):
+    def _wifi_cell_irat_task(self, ad, irat_wait_time=60):
         """
         Atten only WiFi to MIN and MAX
         WiFi --> Cellular
         """
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
-                 MAX_RSSI_RESERVED_VALUE)
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
-                 MAX_RSSI_RESERVED_VALUE)
-
+        self._atten_setup_wifi_cell()
         if (not wait_for_wifi_data_connection(
-                self.log, ad_dut, True, irat_wait_time) or
-                not verify_http_connection(self.log,
-                                           self.android_devices[0])):
+                self.log, ad, True, irat_wait_time) or
+                not verify_http_connection(self.log, ad)):
             self.log.error("Data not on WiFi")
             return False
 
         self.log.info("Triggering WiFi to Cellular IRAT")
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
-                 MIN_RSSI_RESERVED_VALUE)
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
-                 MIN_RSSI_RESERVED_VALUE)
-
+        self._atten_setup_cell_only()
         if (not wait_for_cell_data_connection(
-                self.log, ad_dut, True, irat_wait_time) or
-                not verify_http_connection(self.log,
-                                           ad_dut)):
+                self.log, ad, True, irat_wait_time) or
+                not verify_http_connection(self.log, ad)):
             self.log.error("Data not on Cell")
             return False
         return True
@@ -137,9 +177,9 @@
             return False
 
         total_iteration = self.stress_test_number
-        ad_dut = self.android_devices[0]
-        ping_task = (adb_shell_ping, (ad_dut, DEFAULT_PING_DURATION))
-        irat_task = (self._wifi_cell_irat_task, (ad_dut, DEFAULT_IRAT_DURATION))
+        ad = self.android_devices[0]
+        ping_task = (adb_shell_ping, (ad, DEFAULT_PING_DURATION))
+        irat_task = (self._wifi_cell_irat_task, (ad, DEFAULT_IRAT_DURATION))
         current_iteration = 1
         while (current_iteration <= total_iteration):
             self.log.info(">----Current iteration = %d/%d----<",
@@ -164,7 +204,72 @@
             return True
 
     @TelephonyBaseTest.tel_test_wrap
-    def test_wifi_cell_switching_stress(self):
+    def test_wifi_cell_irat_stress_http_dl(self):
+        """Test for data switch between WiFi and Cell. DUT go in and out WiFi
+        coverage for multiple times.
+
+        Steps:
+        1. Set WiFi and Cellular signal to good (attenuation value to MIN).
+        2. Make sure DUT get Cell data coverage (LTE) and WiFi connected.
+        3. Set WiFi RSSI to MAX (WiFi attenuator value to MIN).
+        4. Verify DUT report WiFi connected and able to download file
+        5. Set WiFi RSSI to MIN (WiFi attenuator value to MAX).
+        6. Verify DUT report Cellular Data connected and able to download file
+        7. Repeat Step 3~6 for stress number.
+
+        Expected Results:
+        4. DUT report WiFi connected and able to download file
+        6. DUT report Cellular Data connected and able to download file
+        7. Stress test should pass.
+
+        Returns:
+        True if Pass. False if fail.
+        """
+        ad = self.android_devices[0]
+        if not self._basic_connectivity_check():
+            self.log.error("Basic Connectivity Check Failed")
+            return False
+
+        total_iteration = self.stress_test_number
+        self.log.info("Stress test. Total iteration = %d.",
+                      total_iteration)
+        current_iteration = 1
+        while (current_iteration <= total_iteration):
+            self.log.info(">----Current iteration = %d/%d----<",
+                          current_iteration, total_iteration)
+
+            self._atten_setup_wifi_cell()
+            if (not wait_for_wifi_data_connection(
+                    self.log, ad, True)):
+                self.log.error("Data not on WiFi")
+                break
+            if not active_data_transfer_test(self.log, ad):
+                self.log.error("%s HTTP DL Failed on WiFi", ad)
+                break
+
+            self._atten_setup_cell_only()
+            if (not wait_for_cell_data_connection(
+                    self.log, ad, True)):
+                self.log.error("Data not on Cell")
+                break
+            if not active_data_transfer_test(self.log, ad):
+                self.log.error("%s HTTP DL Failed on Cell", ad)
+                break
+
+            self.log.info(">----Iteration : %d/%d succeed.----<",
+                          current_iteration, total_iteration)
+            current_iteration += 1
+
+        if current_iteration <= total_iteration:
+            self.log.info(">----Iteration : %d/%d failed.----<",
+                          current_iteration, total_iteration)
+            return False
+        else:
+            return True
+
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_wifi_cell_irat_stress_ping(self):
         """Test for data switch between WiFi and Cell. DUT go in and out WiFi
         coverage for multiple times.
 
@@ -185,6 +290,7 @@
         Returns:
         True if Pass. False if fail.
         """
+        ad = self.android_devices[0]
         if not self._basic_connectivity_check():
             self.log.error("Basic Connectivity Check Failed")
             return False
@@ -196,24 +302,18 @@
         while (current_iteration <= total_iteration):
             self.log.info(">----Current iteration = %d/%d----<",
                           current_iteration, total_iteration)
-            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
-                     MAX_RSSI_RESERVED_VALUE)
-            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
-                     MAX_RSSI_RESERVED_VALUE)
+
+            self._atten_setup_wifi_cell()
             if (not wait_for_wifi_data_connection(
-                    self.log, self.android_devices[0], True) or
-                    not verify_http_connection(self.log,
-                                               self.android_devices[0])):
+                    self.log, ad, True) or
+                    not verify_http_connection(self.log, ad)):
                 self.log.error("Data not on WiFi")
                 break
-            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
-                     MIN_RSSI_RESERVED_VALUE)
-            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
-                     MIN_RSSI_RESERVED_VALUE)
+
+            self._atten_setup_cell_only()
             if (not wait_for_cell_data_connection(
-                    self.log, self.android_devices[0], True) or
-                    not verify_http_connection(self.log,
-                                               self.android_devices[0])):
+                    self.log, ad, True) or
+                    not verify_http_connection(self.log, ad)):
                 self.log.error("Data not on Cell")
                 break
             self.log.info(">----Iteration : %d/%d succeed.----<",
@@ -226,6 +326,65 @@
         else:
             return True
 
+    @TelephonyBaseTest.tel_test_wrap
+    def test_wifi_only_http_dl(self):
+        """Test for 1GB file download on WiFi Only
+
+        Steps:
+        1. Set WiFi atten to MIN and Cellular to MAX
+        2. Start downloading 1GB file from net
+        3. Verify is the download is successfull
+
+        Expected Results:
+        1. File should download over WiFi
+
+        Returns:
+        True if Pass. False if fail.
+        """
+        ad = self.android_devices[0]
+        if not self._basic_connectivity_check():
+            self.log.error("Basic Connectivity Check Failed")
+            return False
+        self._atten_setup_wifi_only()
+        if (not wait_for_wifi_data_connection(
+                self.log, ad, True) or
+                not verify_http_connection(self.log, ad)):
+            self.log.error("Data not on WiFi")
+            return False
+        if not active_data_transfer_test(self.log, ad, "1GB"):
+            self.log.error("%s HTTP DL Failed on WiFi", ad)
+            return False
+        return True
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_lte_only_http_dl(self):
+        """Test for 1GB file download on WiFi Only
+
+        Steps:
+        1. Set WiFi atten to MIN and Cellular to MAX
+        2. Start downloading 1GB file from net
+        3. Verify is the download is successfull
+
+        Expected Results:
+        1. File should download over WiFi
+
+        Returns:
+        True if Pass. False if fail.
+        """
+        ad = self.android_devices[0]
+        if not self._basic_connectivity_check():
+            self.log.error("Basic Connectivity Check Failed")
+            return False
+        self._atten_setup_lte_only()
+        if (not wait_for_cell_data_connection(
+                self.log, ad, True) or
+                not verify_http_connection(self.log, ad)):
+            self.log.error("Data not on LTE")
+            return False
+        if not active_data_transfer_test(self.log, ad, "1GB"):
+            self.log.error("%s HTTP DL Failed on LTE", ad)
+            return False
+        return True
 
 if __name__ == "__main__":
     raise Exception("Cannot run this class directly")
diff --git a/acts/tests/google/tel/live/TelWifiVoiceTest.py b/acts/tests/google/tel/live/TelWifiVoiceTest.py
index cf283ef..d6317cb 100755
--- a/acts/tests/google/tel/live/TelWifiVoiceTest.py
+++ b/acts/tests/google/tel/live/TelWifiVoiceTest.py
@@ -87,8 +87,10 @@
 from acts.test_utils.tel.tel_voice_utils import phone_idle_volte
 
 # Attenuator name
-ATTEN_NAME_FOR_WIFI = 'wifi0'
-ATTEN_NAME_FOR_CELL = 'cell0'
+ATTEN_NAME_FOR_WIFI_2G = 'wifi0'
+ATTEN_NAME_FOR_WIFI_5G = 'wifi1'
+ATTEN_NAME_FOR_CELL_3G = 'cell0'
+ATTEN_NAME_FOR_CELL_4G = 'cell1'
 
 # WiFi RSSI settings for ROVE_IN test
 WIFI_RSSI_FOR_ROVE_IN_TEST_PHONE_ROVE_IN = -60
@@ -111,146 +113,6 @@
 class TelWifiVoiceTest(TelephonyBaseTest):
     def __init__(self, controllers):
         TelephonyBaseTest.__init__(self, controllers)
-        self.tests = (
-            # WFC Call Routing tests.
-            # epdg, WFC, APM, WiFi strong
-            "test_call_epdg_wfc_wifi_only_wifi_strong_apm",
-            "test_call_epdg_wfc_wifi_preferred_wifi_strong_apm",
-            "test_call_epdg_wfc_cellular_preferred_wifi_strong_apm",
-
-            # epdg, WFC, APM, WiFi Absent
-            "test_call_epdg_wfc_wifi_only_wifi_absent_apm",
-            "test_call_epdg_wfc_wifi_preferred_wifi_absent_apm",
-            "test_call_epdg_wfc_cellular_preferred_wifi_absent_apm",
-
-            # epdg, WFC, APM, WiFi Disabled
-            "test_call_epdg_wfc_wifi_only_wifi_disabled_apm",
-            "test_call_epdg_wfc_wifi_preferred_wifi_disabled_apm",
-            "test_call_epdg_wfc_cellular_preferred_wifi_disabled_apm",
-
-            # epdg, WFC, cellular strong, WiFi strong
-            "test_call_epdg_wfc_wifi_preferred_wifi_strong_cellular_strong",
-            "test_call_epdg_wfc_cellular_preferred_wifi_strong_cellular_strong",
-
-            # epdg, WFC, cellular strong, WiFi weak
-            "test_call_epdg_wfc_wifi_preferred_wifi_weak_cellular_strong",
-            "test_call_epdg_wfc_cellular_preferred_wifi_weak_cellular_strong",
-
-            # epdg, WFC, cellular strong, WiFi Absent
-            "test_call_epdg_wfc_wifi_preferred_wifi_absent_cellular_strong",
-            "test_call_epdg_wfc_cellular_preferred_wifi_absent_cellular_strong",
-
-            # epdg, WFC, cellular strong, WiFi Disabled
-            "test_call_epdg_wfc_wifi_preferred_wifi_disabled_cellular_strong",
-            "test_call_epdg_wfc_cellular_preferred_wifi_disabled_cellular_strong",
-
-            # epdg, WFC, cellular weak, WiFi strong
-            "test_call_epdg_wfc_wifi_preferred_wifi_strong_cellular_weak",
-
-            # epdg, WFC, cellular weak, WiFi Absent=
-            "test_call_epdg_wfc_wifi_preferred_wifi_absent_cellular_weak",
-            "test_call_epdg_wfc_cellular_preferred_wifi_absent_cellular_weak",
-
-            # epdg, WFC, cellular weak, WiFi Disabled
-            "test_call_epdg_wfc_wifi_preferred_wifi_disabled_cellular_weak",
-            "test_call_epdg_wfc_cellular_preferred_wifi_disabled_cellular_weak",
-
-            # epdg, WiFI strong, WFC disabled
-            "test_call_epdg_wfc_disabled_wifi_strong_apm",
-            "test_call_epdg_wfc_disabled_wifi_strong_cellular_strong",
-            "test_call_epdg_wfc_disabled_wifi_strong_cellular_weak",
-
-            # WFC Idle-Mode Mobility
-            # Rove-in, Rove-out test
-            "test_rove_in_lte_wifi_preferred",
-            "test_rove_in_lte_wifi_only",
-            "test_rove_in_wcdma_wifi_preferred",
-            "test_rove_in_wcdma_wifi_only",
-            "test_rove_out_lte_wifi_preferred",
-            "test_rove_out_lte_wifi_only",
-            "test_rove_out_wcdma_wifi_preferred",
-            "test_rove_out_wcdma_wifi_only",
-            "test_rove_out_in_stress",
-
-            # WFC Active-Mode Mobility
-            # Hand-in, Hand-out test
-            "test_hand_out_wifi_only",
-            "test_hand_out_wifi_preferred",
-            "test_hand_out_in_wifi_preferred",
-            "test_hand_in_wifi_preferred",
-            "test_hand_in_out_wifi_preferred",
-            "test_hand_out_in_stress",
-
-            # WFC test with E4G disabled
-            "test_call_epdg_wfc_wifi_preferred_e4g_disabled",
-            "test_call_epdg_wfc_wifi_preferred_e4g_disabled_wifi_not_connected",
-            "test_call_epdg_wfc_wifi_preferred_e4g_disabled_leave_wifi_coverage",
-
-            # ePDG Active-Mode Mobility: Hand-in, Hand-out test
-            "test_hand_out_cellular_preferred",
-            "test_hand_in_cellular_preferred",
-
-            # epdg, WFC, cellular weak, WiFi strong
-            "test_call_epdg_wfc_wifi_only_wifi_strong_cellular_weak",
-            "test_call_epdg_wfc_cellular_preferred_wifi_strong_cellular_weak",
-
-            # epdg, WFC, cellular weak, WiFi weak
-            "test_call_epdg_wfc_wifi_only_wifi_weak_cellular_weak",
-            "test_call_epdg_wfc_wifi_preferred_wifi_weak_cellular_weak",
-            "test_call_epdg_wfc_cellular_preferred_wifi_weak_cellular_weak",
-
-            # epdg, WFC, cellular weak, WiFi Absent
-            "test_call_epdg_wfc_wifi_only_wifi_absent_cellular_weak",
-
-            # epdg, WFC, cellular weak, WiFi Disabled
-            "test_call_epdg_wfc_wifi_only_wifi_disabled_cellular_weak",
-
-            # epdg, WFC, cellular absent, WiFi strong
-            "test_call_epdg_wfc_wifi_only_wifi_strong_cellular_absent",
-            "test_call_epdg_wfc_wifi_preferred_wifi_strong_cellular_absent",
-            "test_call_epdg_wfc_cellular_preferred_wifi_strong_cellular_absent",
-
-            # epdg, WFC, cellular absent, WiFi weak
-            "test_call_epdg_wfc_wifi_only_wifi_weak_cellular_absent",
-            "test_call_epdg_wfc_wifi_preferred_wifi_weak_cellular_absent",
-            "test_call_epdg_wfc_cellular_preferred_wifi_weak_cellular_absent",
-
-            # epdg, WFC, cellular absent, WiFi Absent
-            "test_call_epdg_wfc_wifi_only_wifi_absent_cellular_absent",
-            "test_call_epdg_wfc_wifi_preferred_wifi_absent_cellular_absent",
-            "test_call_epdg_wfc_cellular_preferred_wifi_absent_cellular_absent",
-
-            # epdg, WFC, cellular absent, WiFi Disabled
-            "test_call_epdg_wfc_wifi_only_wifi_disabled_cellular_absent",
-            "test_call_epdg_wfc_wifi_preferred_wifi_disabled_cellular_absent",
-            "test_call_epdg_wfc_cellular_preferred_wifi_disabled_cellular_absent",
-
-            # epdg, WiFI strong, WFC disabled
-            "test_call_epdg_wfc_disabled_wifi_strong_cellular_absent",
-
-            # Below test fail now, because:
-            # 1. wifi weak not working now. (phone don't rove-in)
-            # 2. wifi-only mode not working now.
-            # epdg, WFC, APM, WiFi weak
-            "test_call_epdg_wfc_wifi_only_wifi_weak_apm",
-            "test_call_epdg_wfc_wifi_preferred_wifi_weak_apm",
-            "test_call_epdg_wfc_cellular_preferred_wifi_weak_apm",
-
-            # epdg, WFC, cellular strong, WiFi strong
-            "test_call_epdg_wfc_wifi_only_wifi_strong_cellular_strong",
-
-            # epdg, WFC, cellular strong, WiFi weak
-            "test_call_epdg_wfc_wifi_only_wifi_weak_cellular_strong",
-
-            # epdg, WFC, cellular strong, WiFi Absent
-            "test_call_epdg_wfc_wifi_only_wifi_absent_cellular_strong",
-
-            # epdg, WFC, cellular strong, WiFi Disabled
-            "test_call_epdg_wfc_wifi_only_wifi_disabled_cellular_strong",
-
-            # RSSI monitoring
-            "test_rssi_monitoring", )
-
         self.stress_test_number = self.get_stress_test_number()
         self.live_network_ssid = self.user_params["wifi_network_ssid"]
 
@@ -274,10 +136,15 @@
             0].droid.telephonyStartTrackingSignalStrengthChange()
 
         # Do WiFi RSSI calibration.
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI], 0,
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
                  MAX_RSSI_RESERVED_VALUE)
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL], 0,
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
                  MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+
         if not ensure_network_generation(
                 self.log,
                 self.android_devices[0],
@@ -335,10 +202,13 @@
     def teardown_test(self):
 
         super().teardown_test()
-
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI], 0,
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
                  MAX_RSSI_RESERVED_VALUE)
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL], 0,
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G], 0,
                  MAX_RSSI_RESERVED_VALUE)
         return True
 
@@ -855,74 +725,110 @@
 
     def _wfc_set_wifi_strong_cell_strong(self):
         self.log.info("--->Setting WiFi strong cell strong<---")
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
-                 self.wifi_rssi_with_no_atten, MAX_RSSI_RESERVED_VALUE)
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL],
-                 self.cell_rssi_with_no_atten, MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
         return True
 
     def _wfc_set_wifi_strong_cell_weak(self):
         self.log.info("--->Setting WiFi strong cell weak<---")
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
-                 self.wifi_rssi_with_no_atten, MAX_RSSI_RESERVED_VALUE)
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL],
-                 self.cell_rssi_with_no_atten, CELL_WEAK_RSSI_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G], 0,
+                 CELL_WEAK_RSSI_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G], 0,
+                 CELL_WEAK_RSSI_VALUE)
         return True
 
     def _wfc_set_wifi_strong_cell_absent(self):
         self.log.info("--->Setting WiFi strong cell absent<---")
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
-                 self.wifi_rssi_with_no_atten, MAX_RSSI_RESERVED_VALUE)
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL],
-                 self.cell_rssi_with_no_atten, MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
         return True
 
     def _wfc_set_wifi_weak_cell_strong(self):
         self.log.info("--->Setting WiFi weak cell strong<---")
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
-                 self.wifi_rssi_with_no_atten, WIFI_WEAK_RSSI_VALUE)
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL],
-                 self.cell_rssi_with_no_atten, MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
+                 WIFI_WEAK_RSSI_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
+                 WIFI_WEAK_RSSI_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
         return True
 
     def _wfc_set_wifi_weak_cell_weak(self):
         self.log.info("--->Setting WiFi weak cell weak<---")
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL],
-                 self.cell_rssi_with_no_atten, CELL_WEAK_RSSI_VALUE)
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
-                 self.wifi_rssi_with_no_atten, WIFI_WEAK_RSSI_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
+                 WIFI_WEAK_RSSI_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
+                 WIFI_WEAK_RSSI_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G], 0,
+                 CELL_WEAK_RSSI_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G], 0,
+                 CELL_WEAK_RSSI_VALUE)
         return True
 
     def _wfc_set_wifi_weak_cell_absent(self):
         self.log.info("--->Setting WiFi weak cell absent<---")
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
-                 self.wifi_rssi_with_no_atten, WIFI_WEAK_RSSI_VALUE)
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL],
-                 self.cell_rssi_with_no_atten, MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
+                 WIFI_WEAK_RSSI_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
+                 WIFI_WEAK_RSSI_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
         return True
 
     def _wfc_set_wifi_absent_cell_strong(self):
         self.log.info("--->Setting WiFi absent cell strong<---")
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
-                 self.wifi_rssi_with_no_atten, MIN_RSSI_RESERVED_VALUE)
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL],
-                 self.cell_rssi_with_no_atten, MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G], 0,
+                 MAX_RSSI_RESERVED_VALUE)
         return True
 
     def _wfc_set_wifi_absent_cell_weak(self):
         self.log.info("--->Setting WiFi absent cell weak<---")
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
-                 self.wifi_rssi_with_no_atten, MIN_RSSI_RESERVED_VALUE)
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL],
-                 self.cell_rssi_with_no_atten, CELL_WEAK_RSSI_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G], 0,
+                 CELL_WEAK_RSSI_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G], 0,
+                 CELL_WEAK_RSSI_VALUE)
         return True
 
     def _wfc_set_wifi_absent_cell_absent(self):
         self.log.info("--->Setting WiFi absent cell absent<---")
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
-                 self.wifi_rssi_with_no_atten, MIN_RSSI_RESERVED_VALUE)
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL],
-                 self.cell_rssi_with_no_atten, MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G], 0,
+                 MIN_RSSI_RESERVED_VALUE)
         return True
 
     """ Tests Begin """
@@ -2560,7 +2466,10 @@
             return False
 
         # set up wifi to WIFI_RSSI_FOR_ROVE_IN_TEST_PHONE_NOT_ROVE_IN in 10 seconds
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                 self.wifi_rssi_with_no_atten,
+                 WIFI_RSSI_FOR_ROVE_IN_TEST_PHONE_NOT_ROVE_IN, 5, 1)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                  self.wifi_rssi_with_no_atten,
                  WIFI_RSSI_FOR_ROVE_IN_TEST_PHONE_NOT_ROVE_IN, 5, 1)
         if (not wait_for_wifi_data_connection(self.log,
@@ -2575,7 +2484,10 @@
             return False
 
         # set up wifi to WIFI_RSSI_FOR_ROVE_IN_TEST_PHONE_ROVE_IN in 10 seconds
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                 self.wifi_rssi_with_no_atten,
+                 WIFI_RSSI_FOR_ROVE_IN_TEST_PHONE_ROVE_IN, 1, 1)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                  self.wifi_rssi_with_no_atten,
                  WIFI_RSSI_FOR_ROVE_IN_TEST_PHONE_ROVE_IN, 1, 1)
         if not self._phone_idle_iwlan():
@@ -2601,10 +2513,15 @@
         Make a call.
         """
         # set up cell strong
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL],
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G],
+                 self.cell_rssi_with_no_atten, MAX_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G],
                  self.cell_rssi_with_no_atten, MAX_RSSI_RESERVED_VALUE)
         # set up wifi WIFI_RSSI_FOR_ROVE_OUT_TEST_PHONE_INITIAL_STATE
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                 self.wifi_rssi_with_no_atten,
+                 WIFI_RSSI_FOR_ROVE_OUT_TEST_PHONE_INITIAL_STATE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                  self.wifi_rssi_with_no_atten,
                  WIFI_RSSI_FOR_ROVE_OUT_TEST_PHONE_INITIAL_STATE)
         # ensure cellular rat, wfc mode, wifi associated
@@ -2639,7 +2556,10 @@
             return False
 
         # set up wifi to WIFI_RSSI_FOR_ROVE_OUT_TEST_PHONE_NOT_ROVE_OUT in 10 seconds
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                 self.wifi_rssi_with_no_atten,
+                 WIFI_RSSI_FOR_ROVE_OUT_TEST_PHONE_NOT_ROVE_OUT, 1, 1)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                  self.wifi_rssi_with_no_atten,
                  WIFI_RSSI_FOR_ROVE_OUT_TEST_PHONE_NOT_ROVE_OUT, 1, 1)
         if (not wait_for_wifi_data_connection(self.log,
@@ -2653,7 +2573,10 @@
             return False
 
         # set up wifi to WIFI_RSSI_FOR_ROVE_OUT_TEST_PHONE_ROVE_OUT in 10 seconds
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                 self.wifi_rssi_with_no_atten,
+                 WIFI_RSSI_FOR_ROVE_OUT_TEST_PHONE_ROVE_OUT, 2, 1)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                  self.wifi_rssi_with_no_atten,
                  WIFI_RSSI_FOR_ROVE_OUT_TEST_PHONE_ROVE_OUT, 2, 1)
         if (not wait_for_wifi_data_connection(self.log,
@@ -2729,7 +2652,10 @@
                 current_iteration, total_iteration))
 
             # set up wifi to WIFI_RSSI_FOR_ROVE_OUT_TEST_PHONE_ROVE_OUT in 10 seconds
-            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                     self.wifi_rssi_with_no_atten,
+                     WIFI_RSSI_FOR_ROVE_OUT_TEST_PHONE_ROVE_OUT, 2, 1)
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                      self.wifi_rssi_with_no_atten,
                      WIFI_RSSI_FOR_ROVE_OUT_TEST_PHONE_ROVE_OUT, 2, 1)
             if (not wait_for_wifi_data_connection(
@@ -2744,7 +2670,10 @@
                 break
             self.log.info("Rove-out succeed.")
             # set up wifi to WIFI_RSSI_FOR_ROVE_IN_TEST_PHONE_ROVE_IN in 10 seconds
-            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                     self.wifi_rssi_with_no_atten,
+                     WIFI_RSSI_FOR_ROVE_IN_TEST_PHONE_ROVE_IN, 2, 1)
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                      self.wifi_rssi_with_no_atten,
                      WIFI_RSSI_FOR_ROVE_IN_TEST_PHONE_ROVE_IN, 2, 1)
             if (not wait_for_wifi_data_connection(
@@ -2802,7 +2731,10 @@
                 current_iteration, total_iteration))
 
             # set up wifi to WIFI_RSSI_FOR_ROVE_IN_TEST_PHONE_ROVE_IN in 10 seconds
-            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                     self.wifi_rssi_with_no_atten,
+                     WIFI_RSSI_FOR_ROVE_IN_TEST_PHONE_ROVE_IN, 2, 1)
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                      self.wifi_rssi_with_no_atten,
                      WIFI_RSSI_FOR_ROVE_IN_TEST_PHONE_ROVE_IN, 2, 1)
             if (not wait_for_wifi_data_connection(
@@ -2818,7 +2750,10 @@
             self.log.info("Rove-in succeed.")
 
             # set up wifi to WIFI_RSSI_FOR_ROVE_OUT_TEST_PHONE_ROVE_OUT in 10 seconds
-            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                     self.wifi_rssi_with_no_atten,
+                     WIFI_RSSI_FOR_ROVE_OUT_TEST_PHONE_ROVE_OUT, 2, 1)
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                      self.wifi_rssi_with_no_atten,
                      WIFI_RSSI_FOR_ROVE_OUT_TEST_PHONE_ROVE_OUT, 2, 1)
             if (not wait_for_wifi_data_connection(
@@ -3002,7 +2937,10 @@
         PhoneA call should remain active.
         """
         # Increase WiFI RSSI to WIFI_RSSI_FOR_HAND_IN_TEST_PHONE_NOT_HAND_IN in 10s
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                 self.wifi_rssi_with_no_atten,
+                 WIFI_RSSI_FOR_HAND_IN_TEST_PHONE_NOT_HAND_IN, 5, 1)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                  self.wifi_rssi_with_no_atten,
                  WIFI_RSSI_FOR_HAND_IN_TEST_PHONE_NOT_HAND_IN, 5, 1)
         # Make sure WiFI connected and data OK.
@@ -3016,7 +2954,10 @@
             self.log.error("Phone hand-in to wfc.")
             return False
         # Increase WiFI RSSI to WIFI_RSSI_FOR_HAND_IN_TEST_PHONE_HAND_IN in 10s
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                 self.wifi_rssi_with_no_atten,
+                 WIFI_RSSI_FOR_HAND_IN_TEST_PHONE_HAND_IN, 2, 1)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                  self.wifi_rssi_with_no_atten,
                  WIFI_RSSI_FOR_HAND_IN_TEST_PHONE_HAND_IN, 2, 1)
         # Make sure phone hand in to iwlan.
@@ -3093,7 +3034,9 @@
         PhoneA should either drop or hands over to 3g/2g.
         """
         # Decrease LTE RSSI to CELL_WEAK_RSSI_VALUE in 30 seconds
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL],
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G],
+                 self.cell_rssi_with_no_atten, CELL_WEAK_RSSI_VALUE, 1, 1)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G],
                  self.cell_rssi_with_no_atten, CELL_WEAK_RSSI_VALUE, 1, 1)
         # Make sure phone not hand in to iwlan.
         if self._phone_wait_for_wfc():
@@ -3138,7 +3081,10 @@
         """
         # Decrease WiFi RSSI to WIFI_RSSI_FOR_HAND_OUT_TEST_PHONE_NOT_HAND_OUT
         # in 10 seconds
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                 self.wifi_rssi_with_no_atten,
+                 WIFI_RSSI_FOR_HAND_OUT_TEST_PHONE_NOT_HAND_OUT, 2, 1)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                  self.wifi_rssi_with_no_atten,
                  WIFI_RSSI_FOR_HAND_OUT_TEST_PHONE_NOT_HAND_OUT, 2, 1)
         # Make sure WiFi still connected and have data.
@@ -3157,7 +3103,10 @@
 
         # Decrease WiFi RSSI to WIFI_RSSI_FOR_HAND_OUT_TEST_PHONE_HAND_OUT
         # in 10 seconds
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                 self.wifi_rssi_with_no_atten,
+                 WIFI_RSSI_FOR_HAND_OUT_TEST_PHONE_HAND_OUT, 2, 1)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                  self.wifi_rssi_with_no_atten,
                  WIFI_RSSI_FOR_HAND_OUT_TEST_PHONE_HAND_OUT, 2, 1)
         # Make sure WiFi still connected and have data.
@@ -3249,7 +3198,10 @@
             # Decrease WiFi RSSI to WIFI_RSSI_FOR_HAND_OUT_TEST_PHONE_HAND_OUT
             # in 10 seconds
             self.log.info("Decrease WiFi RSSI to hand out.")
-            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                     self.wifi_rssi_with_no_atten,
+                     WIFI_RSSI_FOR_HAND_OUT_TEST_PHONE_HAND_OUT, 2, 1)
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                      self.wifi_rssi_with_no_atten,
                      WIFI_RSSI_FOR_HAND_OUT_TEST_PHONE_HAND_OUT, 2, 1)
             # Make sure WiFi still connected and have data.
@@ -3269,7 +3221,10 @@
                 break
             # Increase WiFI RSSI to WIFI_RSSI_FOR_HAND_IN_TEST_PHONE_HAND_IN in 10s
             self.log.info("Increase WiFi RSSI to hand in.")
-            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                     self.wifi_rssi_with_no_atten,
+                     WIFI_RSSI_FOR_HAND_IN_TEST_PHONE_HAND_IN, 2, 1)
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                      self.wifi_rssi_with_no_atten,
                      WIFI_RSSI_FOR_HAND_IN_TEST_PHONE_HAND_IN, 2, 1)
             # Make sure WiFi still connected and have data.
@@ -3338,7 +3293,10 @@
             # Increase WiFi RSSI to WIFI_RSSI_FOR_HAND_IN_TEST_PHONE_HAND_IN
             # in 10 seconds
             self.log.info("Increase WiFi RSSI to hand in.")
-            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                     self.wifi_rssi_with_no_atten,
+                     WIFI_RSSI_FOR_HAND_IN_TEST_PHONE_HAND_IN, 2, 1)
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                      self.wifi_rssi_with_no_atten,
                      WIFI_RSSI_FOR_HAND_IN_TEST_PHONE_HAND_IN, 2, 1)
             # Make sure WiFi still connected and have data.
@@ -3358,7 +3316,10 @@
 
             # Decrease WiFI RSSI to WIFI_RSSI_FOR_HAND_OUT_TEST_PHONE_HAND_OUT in 10s
             self.log.info("Decrease WiFi RSSI to hand out.")
-            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                     self.wifi_rssi_with_no_atten,
+                     WIFI_RSSI_FOR_HAND_OUT_TEST_PHONE_HAND_OUT, 2, 1)
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                      self.wifi_rssi_with_no_atten,
                      WIFI_RSSI_FOR_HAND_OUT_TEST_PHONE_HAND_OUT, 2, 1)
             # Make sure WiFi still connected and have data.
@@ -3421,7 +3382,9 @@
         PhoneA should have data on WiFi.
         """
         # Increase Cellular RSSI to CELL_STRONG_RSSI_VALUE in 30 seconds
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL],
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_3G],
+                 self.cell_rssi_with_no_atten, CELL_STRONG_RSSI_VALUE, 1, 1)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL_4G],
                  self.cell_rssi_with_no_atten, CELL_STRONG_RSSI_VALUE, 1, 1)
         # Make sure phone hand-out, not drop call
         if not self._phone_wait_for_not_wfc():
@@ -3464,7 +3427,9 @@
         PhoneA data should be on LTE.
         """
         # Decrease WiFi RSSI to <-100dBm in 30 seconds
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                 self.wifi_rssi_with_no_atten, MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                  self.wifi_rssi_with_no_atten, MIN_RSSI_RESERVED_VALUE)
         # Make sure PhoneA data is on LTE.
         if (not wait_for_cell_data_connection(self.log,
@@ -3539,7 +3504,9 @@
         Decrease WiFi RSSI to make sure WiFI not connected. Call should Drop.
         """
         # Decrease WiFi RSSI to <-100dBm in 30 seconds
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                 self.wifi_rssi_with_no_atten, MIN_RSSI_RESERVED_VALUE)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                  self.wifi_rssi_with_no_atten, MIN_RSSI_RESERVED_VALUE)
         # Make sure PhoneA data is on cellular.
         if (not wait_for_cell_data_connection(self.log,
@@ -3602,7 +3569,9 @@
 
         ad = self.android_devices[0]
 
-        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                 self.wifi_rssi_with_no_atten, INITIAL_RSSI)
+        set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                  self.wifi_rssi_with_no_atten, INITIAL_RSSI)
         if not ensure_wifi_connected(self.log, ad, self.live_network_ssid,
                                      self.live_network_pwd):
@@ -3631,7 +3600,12 @@
 
             self.log.info("Set RSSI to HIGHER_RSSI_THRESHOLD+5,"
                           "rssi_monitoring_id_higher should be available.")
-            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                     self.wifi_rssi_with_no_atten,
+                     HIGHER_RSSI_THRESHOLD + RSSI_THRESHOLD_MARGIN,
+                     WIFI_RSSI_CHANGE_STEP_SIZE,
+                     WIFI_RSSI_CHANGE_DELAY_PER_STEP)
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                      self.wifi_rssi_with_no_atten,
                      HIGHER_RSSI_THRESHOLD + RSSI_THRESHOLD_MARGIN,
                      WIFI_RSSI_CHANGE_STEP_SIZE,
@@ -3650,7 +3624,12 @@
 
             self.log.info("Set RSSI to HIGHER_RSSI_THRESHOLD-5,"
                           "rssi_monitoring_id_higher should be lost.")
-            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                     self.wifi_rssi_with_no_atten,
+                     HIGHER_RSSI_THRESHOLD - RSSI_THRESHOLD_MARGIN,
+                     WIFI_RSSI_CHANGE_STEP_SIZE,
+                     WIFI_RSSI_CHANGE_DELAY_PER_STEP)
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                      self.wifi_rssi_with_no_atten,
                      HIGHER_RSSI_THRESHOLD - RSSI_THRESHOLD_MARGIN,
                      WIFI_RSSI_CHANGE_STEP_SIZE,
@@ -3669,7 +3648,12 @@
 
             self.log.info("Set RSSI to LOWER_RSSI_THRESHOLD-5,"
                           "rssi_monitoring_id_lower should be lost.")
-            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                     self.wifi_rssi_with_no_atten,
+                     LOWER_RSSI_THRESHOLD - RSSI_THRESHOLD_MARGIN,
+                     WIFI_RSSI_CHANGE_STEP_SIZE,
+                     WIFI_RSSI_CHANGE_DELAY_PER_STEP)
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                      self.wifi_rssi_with_no_atten,
                      LOWER_RSSI_THRESHOLD - RSSI_THRESHOLD_MARGIN,
                      WIFI_RSSI_CHANGE_STEP_SIZE,
@@ -3688,7 +3672,12 @@
 
             self.log.info("Set RSSI to LOWER_RSSI_THRESHOLD+5,"
                           "rssi_monitoring_id_lower should be available.")
-            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI],
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_2G],
+                     self.wifi_rssi_with_no_atten,
+                     LOWER_RSSI_THRESHOLD + RSSI_THRESHOLD_MARGIN,
+                     WIFI_RSSI_CHANGE_STEP_SIZE,
+                     WIFI_RSSI_CHANGE_DELAY_PER_STEP)
+            set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI_5G],
                      self.wifi_rssi_with_no_atten,
                      LOWER_RSSI_THRESHOLD + RSSI_THRESHOLD_MARGIN,
                      WIFI_RSSI_CHANGE_STEP_SIZE,
diff --git a/acts/tests/google/wifi/WifiAwareManagerTest.py b/acts/tests/google/wifi/WifiAwareManagerTest.py
index 0ead0ee..7ce7750 100644
--- a/acts/tests/google/wifi/WifiAwareManagerTest.py
+++ b/acts/tests/google/wifi/WifiAwareManagerTest.py
@@ -1027,7 +1027,7 @@
             event_pub_rx['data']['peerId'], publisher_passphrase)
         self.log.info("Publisher network specifier - '%s'", pub_ns)
         self.network_req['NetworkSpecifier'] = pub_ns
-        pub_req_key = self.publisher.droid.connectivityRequestNetwork(
+        pub_req_key = self.publisher.droid.connectivityRequestWifiAwareNetwork(
             self.network_req)
 
         # P sends message to S
@@ -1051,7 +1051,7 @@
             event_sub_rx['data']['peerId'], subscriber_passphrase)
         self.log.info("Subscriber network specifier - '%s'", sub_ns)
         self.network_req['NetworkSpecifier'] = sub_ns
-        sub_req_key = self.subscriber.droid.connectivityRequestNetwork(
+        sub_req_key = self.subscriber.droid.connectivityRequestWifiAwareNetwork(
             self.network_req)
 
         # Wait until both S and P get confirmation that network formed
diff --git a/acts/tests/google/wifi/WifiManagerTest.py b/acts/tests/google/wifi/WifiManagerTest.py
index bd1f061..78e4c5e 100755
--- a/acts/tests/google/wifi/WifiManagerTest.py
+++ b/acts/tests/google/wifi/WifiManagerTest.py
@@ -25,6 +25,7 @@
 import acts.utils
 
 from acts import asserts
+from acts.test_decorators import test_tracker_info
 
 WifiEnums = wutils.WifiEnums
 # Default timeout used for reboot, toggle WiFi and Airplane mode,
@@ -313,6 +314,7 @@
         self.log.debug("Going from off to on.")
         wutils.wifi_toggle_state(self.dut, True)
 
+    @test_tracker_info(uuid="e9d11563-2bbe-4c96-87eb-ec919b51435b")
     def test_toggle_with_screen(self):
         """Test toggling wifi with screen on/off"""
         wait_time = 5
@@ -331,7 +333,7 @@
             time.sleep(wait_time)
             self.dut.droid.goToSleepNow()
 
-    @test_tracker_info(uuid="b8c58e90-8ef8-4705-ac2f-d89be52e6b89")
+    @test_tracker_info(uuid="71556e06-7fb1-4e2b-9338-b01f1f8e286e")
     def test_scan(self):
         """Test wifi connection scan can start and find expected networks."""
         wutils.wifi_toggle_state(self.dut, True)
@@ -366,6 +368,7 @@
                 nw[WifiEnums.BSSID_KEY] != ssid,
                 "Found forgotten network %s in configured networks." % ssid)
 
+    @test_tracker_info(uuid="b306d65c-6df3-4eb5-a178-6278bdc76c3e")
     def test_reconnect_to_connected_network(self):
         """Connect to a network and immediately issue reconnect.
 
@@ -391,6 +394,7 @@
             raise signals.TestFailure("Device did not connect to the correct"
                                       " 5GHz network.")
 
+    @test_tracker_info(uuid="3cff17f6-b684-4a95-a438-8272c2ad441d")
     def test_reconnect_to_previously_connected(self):
         """Connect to multiple networks and reconnect to the previous network.
 
@@ -416,6 +420,7 @@
             raise signals.TestFailure("Device did not connect to the correct"
                                       " 5GHz network.")
 
+    @test_tracker_info(uuid="334175c3-d26a-4c87-a8ab-8eb220b2d80f")
     def test_reconnect_toggle_wifi(self):
         """Connect to multiple networks, turn off/on wifi, then reconnect to
            a previously connected network.
@@ -439,6 +444,7 @@
             raise signals.TestFailure("Device did not connect to the correct"
                                       " network after toggling WiFi.")
 
+    @test_tracker_info(uuid="8e6e6c21-fefb-4fe8-9fb1-f09b1182b76d")
     def test_reconnect_toggle_airplane(self):
         """Connect to multiple networks, turn on/off Airplane moce, then
            reconnect a previously connected network.
@@ -462,6 +468,7 @@
             raise signals.TestFailure("Device did not connect to the correct"
                                       " network after toggling Airplane mode.")
 
+    @test_tracker_info(uuid="3d041c12-05e2-46a7-ab9b-e3f60cc735db")
     def test_reboot_configstore_reconnect(self):
         """Connect to multiple networks, reboot then reconnect to previously
            connected network.
@@ -490,6 +497,7 @@
                 "Device failed to reconnect to the correct"
                 " network after reboot.")
 
+    @test_tracker_info(uuid="26d94dfa-1349-4c8b-aea0-475eb73bb521")
     def test_toggle_wifi_reboot_configstore_reconnect(self):
         """Connect to multiple networks, disable WiFi, reboot, then
            reconnect to previously connected network.
@@ -524,6 +532,7 @@
                    " toggling WiFi and rebooting.")
             raise signals.TestFailure(msg)
 
+    @test_tracker_info(uuid="4fce017b-b443-40dc-a598-51d59d3bb38f")
     def test_toggle_airplane_reboot_configstore_reconnect(self):
         """Connect to multiple networks, enable Airplane mode, reboot, then
            reconnect to previously connected network.
@@ -591,6 +600,7 @@
             name_func=name_gen)
         asserts.assert_false(failed, "Failed ones: {}".format(failed))
 
+    @test_tracker_info(uuid="b9fbc13a-47b4-4f64-bd2c-e5a3cb24ab2f")
     def test_tdls_supported(self):
         model = acts.utils.trim_model_name(self.dut.model)
         self.log.debug("Model is %s" % model)
@@ -603,6 +613,7 @@
                 "TDLS should not be supported on %s, but device "
                 "is reporting supported.") % model)
 
+    @test_tracker_info(uuid="50637d40-ea59-4f4b-9fc1-e6641d64074c")
     def test_energy_info(self):
         """Verify the WiFi energy info reporting feature.
 
@@ -645,6 +656,7 @@
             idle_time = new_idle_time
             wutils.start_wifi_connection_scan(self.dut)
 
+    @test_tracker_info(uuid="1f1cf549-53eb-4f36-9f33-ce06c9158efc")
     def test_energy_info_connected(self):
         """Verify the WiFi energy info reporting feature when connected.
 
diff --git a/acts/tests/google/wifi/WifiNewSetupAutoJoinTest.py b/acts/tests/google/wifi/WifiNewSetupAutoJoinTest.py
index a797ed9..7b735cb 100644
--- a/acts/tests/google/wifi/WifiNewSetupAutoJoinTest.py
+++ b/acts/tests/google/wifi/WifiNewSetupAutoJoinTest.py
@@ -18,6 +18,7 @@
 
 from acts import asserts
 from acts import base_test
+from acts.test_decorators import test_tracker_info
 from acts.test_utils.wifi import wifi_constants
 from acts.test_utils.wifi import wifi_test_utils as wutils
 
@@ -170,7 +171,7 @@
 
     """ Tests Begin """
 
-    @test_tracker_info(uuid="ec509d40-e339-47c2-995e-cc77f5a28687")
+    @test_tracker_info(uuid="9ea2c78d-d305-497f-87a5-f621f0a4b34e")
     def test_autojoin_Ap1_2g(self):
         """Test wifi auto join functionality move in range of AP1.
 
@@ -195,7 +196,7 @@
             failed,
             "Number of test_autojoin_Ap1_2g failed {}".format(len(failed)))
 
-    @test_tracker_info(uuid="01faeba0-bd66-4d30-a3d9-b81e959025b2")
+    @test_tracker_info(uuid="b5eba5ec-96e5-4bd8-b483-f5b2a9504558")
     def test_autojoin_Ap1_2gto5g(self):
         """Test wifi auto join functionality move to high range.
 
@@ -219,7 +220,7 @@
             failed,
             "Number of test_autojoin_Ap1_2gto5g failed {}".format(len(failed)))
 
-    @test_tracker_info(uuid="9ea2c78d-d305-497f-87a5-f621f0a4b34e")
+    @test_tracker_info(uuid="37822578-d35c-462c-87c0-7a2d9252938c")
     def test_autojoin_in_AP1_5gto2g(self):
         """Test wifi auto join functionality move to low range toward AP2.
 
@@ -244,7 +245,7 @@
             failed, "Number of test_autojoin_in_AP1_5gto2g failed {}".format(
                 len(failed)))
 
-    @test_tracker_info(uuid="b5eba5ec-96e5-4bd8-b483-f5b2a9504558")
+    @test_tracker_info(uuid="8ffdcab1-2bfb-4acd-b1e8-089ba8a4ec41")
     def test_autojoin_swtich_AP1toAp2(self):
         """Test wifi auto join functionality move from low range of AP1 to better
            range of AP2.
@@ -270,7 +271,7 @@
             failed, "Number of test_autojoin_swtich_AP1toAp2 failed {}".format(
                 len(failed)))
 
-    @test_tracker_info(uuid="15c27654-bae0-4d2d-bdc8-54fb04b901d1")
+    @test_tracker_info(uuid="7a8b9242-f93c-449a-90a6-4562274a213a")
     def test_autojoin_Ap2_2gto5g(self):
         """Test wifi auto join functionality move to high range of AP2.
 
@@ -294,7 +295,7 @@
             failed,
             "Number of test_autojoin_Ap2_2gto5g failed {}".format(len(failed)))
 
-    @test_tracker_info(uuid="8ffdcab1-2bfb-4acd-b1e8-089ba8a4ec41")
+    @test_tracker_info(uuid="009457df-f430-402c-96ab-c456b043b6f5")
     def test_autojoin_Ap2_5gto2g(self):
         """Test wifi auto join functionality move to low range of AP2.
 
@@ -317,7 +318,7 @@
             failed,
             "Number of test_autojoin_Ap2_5gto2g failed {}".format(len(failed)))
 
-    @test_tracker_info(uuid="7a8b9242-f93c-449a-90a6-4562274a213a")
+    @test_tracker_info(uuid="c6d070af-b601-42f1-adec-5ac564154b29")
     def test_autojoin_out_of_range(self):
         """Test wifi auto join functionality move to low range.
 
@@ -347,7 +348,7 @@
             self.dut.droid.wifiLockRelease()
             self.dut.droid.goToSleepNow()
 
-    @test_tracker_info(uuid="009457df-f430-402c-96ab-c456b043b6f5")
+    @test_tracker_info(uuid="15c27654-bae0-4d2d-bdc8-54fb04b901d1")
     def test_autojoin_Ap2_2g(self):
         """Test wifi auto join functionality move in low range of AP2.
 
@@ -372,7 +373,7 @@
             failed,
             "Number of test_autojoin_Ap2_2g failed {}".format(len(failed)))
 
-    @test_tracker_info(uuid="e294889d-ad87-4475-852a-7d1f3c476d10")
+    @test_tracker_info(uuid="80e74c78-59e2-46db-809d-cb03bd1b6824")
     def test_autojoin_in_Ap2_5gto2g(self):
         """Test wifi auto join functionality move to medium range of Ap2 and
            low range of AP1.
@@ -397,7 +398,7 @@
             failed, "Number of test_autojoin_in_Ap2_5gto2g failed {}".format(
                 len(failed)))
 
-    @test_tracker_info(uuid="80e74c78-59e2-46db-809d-cb03bd1b6824")
+    @test_tracker_info(uuid="01faeba0-bd66-4d30-a3d9-b81e959025b2")
     def test_autojoin_swtich_AP2toAp1(self):
         """Test wifi auto join functionality move from low range of AP2 to better
            range of AP1.
@@ -423,7 +424,7 @@
             failed, "Number of test_autojoin_swtich_AP2toAp1 failed {}".format(
                 len(failed)))
 
-    @test_tracker_info(uuid="59be1afa-cde1-4cfa-bb16-26c0a96ceeca")
+    @test_tracker_info(uuid="ec509d40-e339-47c2-995e-cc77f5a28687")
     def test_autojoin_Ap1_5gto2g(self):
         """Test wifi auto join functionality move to medium range of AP1.
 
diff --git a/acts/tests/google/wifi/WifiPowerTest.py b/acts/tests/google/wifi/WifiPowerTest.py
index 2d91e8f..84fd4f9 100755
--- a/acts/tests/google/wifi/WifiPowerTest.py
+++ b/acts/tests/google/wifi/WifiPowerTest.py
@@ -24,6 +24,7 @@
 from acts.controllers import adb
 from acts.controllers import iperf_server as ip_server
 from acts.controllers import monsoon
+from acts.test_decorators import test_tracker_info
 from acts.test_utils.wifi import wifi_test_utils as wutils
 from acts.utils import force_airplane_mode
 from acts.utils import set_adaptive_brightness
diff --git a/acts/tests/google/wifi/WifiScannerBssidTest.py b/acts/tests/google/wifi/WifiScannerBssidTest.py
index 52432ad..e91c449 100644
--- a/acts/tests/google/wifi/WifiScannerBssidTest.py
+++ b/acts/tests/google/wifi/WifiScannerBssidTest.py
@@ -20,6 +20,7 @@
 from acts import asserts
 from acts import base_test
 from acts import utils
+from acts.test_decorators import test_tracker_info
 from acts.test_utils.wifi import wifi_test_utils as wutils
 
 BSSID_EVENT_WAIT = 30
diff --git a/acts/tests/google/wifi/WifiScannerMultiScanTest.py b/acts/tests/google/wifi/WifiScannerMultiScanTest.py
index fe030f2..481ffb0 100755
--- a/acts/tests/google/wifi/WifiScannerMultiScanTest.py
+++ b/acts/tests/google/wifi/WifiScannerMultiScanTest.py
@@ -19,6 +19,8 @@
 
 from acts import asserts
 from acts import base_test
+from acts import signals
+from acts.test_decorators import test_tracker_info
 from acts.test_utils.wifi import wifi_test_utils as wutils
 
 WifiChannelUS = wutils.WifiChannelUS
@@ -128,6 +130,47 @@
         5. The time gap between two consecutive scan results should be
            approximately equal to the scan interval specified by the scan
            setting.
+        A scan result looks like this:
+        {
+          'data':
+           {
+             'Type': 'onResults',
+             'ResultElapsedRealtime': 4280931,
+             'Index': 10,
+             'Results': [
+                         {
+                          'Flags': 0,
+                          'Id': 4,
+                          'ScanResults':[
+                                          {
+                                           'is80211McRTTResponder': False,
+                                           'channelWidth': 0,
+                                           'numUsage': 0,
+                                           'SSID': '"wh_ap1_2g"',
+                                           'timestamp': 4280078660,
+                                           'numConnection': 0,
+                                           'BSSID': '30:b5:c2:33:f9:05',
+                                           'frequency': 2412,
+                                           'numIpConfigFailures': 0,
+                                           'distanceSdCm': 0,
+                                           'distanceCm': 0,
+                                           'centerFreq1': 0,
+                                           'centerFreq0': 0,
+                                           'blackListTimestamp': 0,
+                                           'venueName': '',
+                                           'seen': 0,
+                                           'operatorFriendlyName': '',
+                                           'level': -31,
+                                           'passpointNetwork': False,
+                                           'untrusted': False
+                                          }
+                                        ]
+                         }
+                        ]
+            },
+          'time': 1491744576383,
+          'name': 'WifiScannerScan10onResults'
+        }
         """
         num_of_events = len(self.results_events)
         asserts.assert_true(
@@ -137,6 +180,9 @@
         for event_idx in range(num_of_events):
             batches = self.results_events[event_idx]["data"]["Results"]
             actual_num_of_batches = len(batches)
+            if not actual_num_of_batches:
+                raise signals.TestFailure("Scan returned empty Results list %s "
+                                          "% batches")
             # For batch scan results.
             report_type = self.scan_setting['reportEvents']
             if not (report_type & WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN):
@@ -148,8 +194,13 @@
                     "Expected to get at most %d batches in event No.%d, got %d."
                     % (expected_num_of_batches, event_idx,
                        actual_num_of_batches))
-                # Check the results within each event of batch scan
-                for batch_idx in range(1, actual_num_of_batches):
+            # Check the results within each event of batch scan
+            for batch_idx in range(actual_num_of_batches):
+                if not len(batches[batch_idx]["ScanResults"]):
+                    raise signals.TestFailure("Scan event %d returned empty"
+                    " scan results in batch %d" % (event_idx, batch_idx))
+                # Start checking interval from the second batch.
+                if batch_idx >=1:
                     self.check_interval(
                         batches[batch_idx - 1]["ScanResults"][0],
                         batches[batch_idx]["ScanResults"][0])
diff --git a/acts/tests/google/wifi/WifiScannerScanTest.py b/acts/tests/google/wifi/WifiScannerScanTest.py
index f76657a..140ddd9 100755
--- a/acts/tests/google/wifi/WifiScannerScanTest.py
+++ b/acts/tests/google/wifi/WifiScannerScanTest.py
@@ -22,6 +22,7 @@
 from acts import asserts
 from acts import base_test
 from acts import utils
+from acts.test_decorators import test_tracker_info
 from acts.test_utils.wifi import wifi_constants
 from acts.test_utils.wifi import wifi_test_utils as wutils
 
@@ -619,7 +620,7 @@
             "Number of test_single_scan_report_each_scan_for_band failed %s" %
             len(failed))
 
-    @test_tracker_info(uuid="6fe45cd7-4fac-4ddd-a950-b9431e68f735")
+    @test_tracker_info(uuid="44989f93-e63b-4c2e-a90a-a483477303bb")
     def test_batch_scan_report_buffer_full_for_channels_with_enumerated_params(
             self):
         """Test WiFi scanner batch scan using channels with enumerated settings
@@ -645,7 +646,7 @@
             "Number of test_batch_scan_report_buffer_full_for_channels"
             " failed {}").format(len(failed)))
 
-    @test_tracker_info(uuid="740e1c18-911a-43d2-9317-3827ecf71d3b")
+    @test_tracker_info(uuid="63538df6-388a-4c16-964f-e9c19b750e07")
     def test_batch_scan_report_buffer_full_for_band_with_enumerated_params(
             self):
         """Test WiFi scanner batch scan using band with enumerated settings
@@ -671,7 +672,7 @@
             failed, ("Number of test_batch_scan_report_buffer_full_for_band"
                      " failed {}").format(len(failed)))
 
-    @test_tracker_info(uuid="e9a7cfb5-21c4-4c40-8169-8d88b65a1dee")
+    @test_tracker_info(uuid="bd4e8c53-16c8-4ed6-b680-55c1ba688ad8")
     def test_batch_scan_report_each_scan_for_channels_with_enumerated_params(
             self):
         """Test WiFi scanner batch scan using channels with enumerated settings
@@ -697,7 +698,7 @@
             failed, ("Number of test_batch_scan_report_each_scan_for_channels"
                      " failed {}").format(len(failed)))
 
-    @test_tracker_info(uuid="0ddccf2e-b518-45a7-ae75-96924070b841")
+    @test_tracker_info(uuid="d11e8c09-97d0-49c1-bf09-b9ec672c2fa6")
     def test_batch_scan_report_each_scan_for_band_with_enumerated_params(self):
         """Test WiFi scanner batch scan using band with enumerated settings
            to report each scan results.
@@ -722,7 +723,7 @@
             not failed, ("Number of test_batch_scan_report_each_scan_for_band"
                          " failed {}").format(len(failed)))
 
-    @test_tracker_info(uuid="e9f3aaad-4af3-4c54-9829-65dc1d6d4987")
+    @test_tracker_info(uuid="7f967b0e-82fe-403e-9d74-0dee7f09a21d")
     def test_single_scan_report_full_scan_for_channels_with_enumerated_params(
             self):
         """Test WiFi scanner single scan using channels with enumerated settings
@@ -748,7 +749,7 @@
             failed, ("Number of test_single_scan_report_full_scan_for_channels"
                      " failed {}").format(len(failed)))
 
-    @test_tracker_info(uuid="49ba245a-52e2-4c9b-90ad-a2fbc97e3d9f")
+    @test_tracker_info(uuid="34d09f60-31bf-4952-8fb3-03fc93ec98fa")
     def test_single_scan_report_full_scan_for_band_with_enumerated_params(
             self):
         """Test WiFi scanner single scan using band with enumerated settings
@@ -774,7 +775,7 @@
             not failed, ("Number of test_single_scan_report_full_scan_for_band"
                          " failed {}").format(len(failed)))
 
-    @test_tracker_info(uuid="fc18d947-0b5a-42b4-98f3-dd1f2b52a7af")
+    @test_tracker_info(uuid="0ddccf2e-b518-45a7-ae75-96924070b841")
     def test_batch_scan_report_full_scan_for_channels_with_enumerated_params(
             self):
         """Test WiFi scanner batch scan using channels with enumerated settings
@@ -801,7 +802,7 @@
             failed, ("Number of test_batch_scan_report_full_scan_for_channels"
                      " failed {}").format(len(failed)))
 
-    @test_tracker_info(uuid="0ddccf2e-b518-45a7-ae75-96924070b841")
+    @test_tracker_info(uuid="0685b667-8470-43a0-923d-dee71428f8ce")
     def test_batch_scan_report_full_scan_for_band_with_enumerated_params(self):
         """Test WiFi scanner batch scan using channels with enumerated settings
            to report full scan results.
@@ -827,7 +828,7 @@
             not failed, ("Number of test_batch_scan_report_full_scan_for_band"
                          " failed {}").format(len(failed)))
 
-    @test_tracker_info(uuid="44989f93-e63b-4c2e-a90a-a483477303bb")
+    @test_tracker_info(uuid="740e1c18-911a-43d2-9317-3827ecf71d3b")
     def test_wifi_connection_while_single_scan(self):
         """Test configuring a connection parallel to wifi scanner single scan.
 
@@ -871,7 +872,7 @@
             raise AssertionError(
                 "Event did not triggered for single scan {}".format(error))
 
-    @test_tracker_info(uuid="63538df6-388a-4c16-964f-e9c19b750e07")
+    @test_tracker_info(uuid="e9a7cfb5-21c4-4c40-8169-8d88b65a1dee")
     def test_single_scan_while_pno(self):
         """Test wifi scanner single scan parallel to PNO connection.
 
@@ -905,7 +906,7 @@
             "Error, No internet connection for current network")
         wutils.wifi_forget_network(self.dut, self.connect_network["SSID"])
 
-    @test_tracker_info(uuid="bd4e8c53-16c8-4ed6-b680-55c1ba688ad8")
+    @test_tracker_info(uuid="fc18d947-0b5a-42b4-98f3-dd1f2b52a7af")
     def test_wifi_connection_and_pno_while_batch_scan(self):
         """Test configuring a connection and PNO connection parallel to wifi
            scanner batch scan.
@@ -1010,7 +1011,7 @@
             self.dut.droid.wifiScannerStopBackgroundScan(idx)
             self.dut.ed.clear_all_events()
 
-    @test_tracker_info(uuid="46f817b9-97a3-455e-af2c-56f9aea64f7e")
+    @test_tracker_info(uuid="7c25ce32-0fae-4a68-a7cb-fdf6d4d03caf")
     def test_wifi_scanner_single_scan_channel_sanity(self):
         """Test WiFi scanner single scan for mix channel with default setting
            parameters.
@@ -1025,7 +1026,7 @@
                         wutils.WifiEnums.REPORT_EVENT_AFTER_EACH_SCAN}
         self.wifi_scanner_single_scan(scan_setting)
 
-    @test_tracker_info(uuid="7f967b0e-82fe-403e-9d74-0dee7f09a21d")
+    @test_tracker_info(uuid="e9f3aaad-4af3-4c54-9829-65dc1d6d4987")
     def test_wifi_scanner_batch_scan_channel_sanity(self):
         """Test WiFi scanner batch scan for mix channel with default setting
            parameters to report the result on buffer full.
@@ -1040,6 +1041,7 @@
                         wutils.WifiEnums.REPORT_EVENT_AFTER_BUFFER_FULL}
         self.wifi_scanner_batch_scan(scan_setting)
 
+    @test_tracker_info(uuid="49ba245a-52e2-4c9b-90ad-a2fbc97e3d9f")
     def test_wifi_scanner_batch_scan_period_too_short(self):
         """Test WiFi scanner batch scan for band with too short period time.
 
@@ -1051,6 +1053,7 @@
                         wutils.WifiEnums.REPORT_EVENT_AFTER_BUFFER_FULL}
         self.start_wifi_scanner_background_scan_expect_failure(scan_setting)
 
+    @test_tracker_info(uuid="6fe45cd7-4fac-4ddd-a950-b9431e68f735")
     def test_wifi_scanner_single_scan_in_isolated(self):
         """Test WiFi scanner in isolated environment with default scan settings.
 
@@ -1092,6 +1095,7 @@
             self.attenuators[0].set_atten(0)
             self.attenuators[1].set_atten(0)
 
+    @test_tracker_info(uuid="46f817b9-97a3-455e-af2c-56f9aea64f7e")
     def test_wifi_scanner_with_wifi_off(self):
         """Test WiFi scanner single scan when wifi is off.
 
@@ -1106,7 +1110,7 @@
         self.log.debug("Turning wifi back on.")
         wutils.wifi_toggle_state(self.dut, True)
 
-    @test_tracker_info(uuid="e764989e-78e7-4358-99ba-10a119357ae6")
+    @test_tracker_info(uuid="257ad734-c21f-49f4-b448-3986b70eba3d")
     def test_wifi_scanner_with_invalid_numBssidsPerScan(self):
         """Test WiFi scanner single scan with invalid number of bssids reported
            per scan.
diff --git a/acts/tests/google/wifi/WifiSoftApTest.py b/acts/tests/google/wifi/WifiSoftApTest.py
index e27e66f..e38a58a 100644
--- a/acts/tests/google/wifi/WifiSoftApTest.py
+++ b/acts/tests/google/wifi/WifiSoftApTest.py
@@ -21,6 +21,7 @@
 from acts import asserts
 from acts import utils
 from acts import base_test
+from acts.test_decorators import test_tracker_info
 from acts.test_utils.tel import tel_defines
 from acts.test_utils.tel import tel_test_utils as tel_utils
 from acts.test_utils.wifi import wifi_test_utils as wutils
diff --git a/acts/tests/google/wifi/WifiTeleCoexTest.py b/acts/tests/google/wifi/WifiTeleCoexTest.py
new file mode 100644
index 0000000..6ec1ef8
--- /dev/null
+++ b/acts/tests/google/wifi/WifiTeleCoexTest.py
@@ -0,0 +1,289 @@
+#!/usr/bin/env python3.4
+
+import queue
+import time
+
+import acts.base_test
+import acts.test_utils.wifi.wifi_test_utils as wifi_utils
+import acts.test_utils.tel.tel_test_utils as tele_utils
+import acts.utils
+
+from acts import asserts
+from acts import signals
+from acts.test_utils.tel.TelephonyBaseTest import TelephonyBaseTest
+from acts.test_utils.tel.tel_voice_utils import phone_setup_voice_general
+from acts.test_utils.tel.tel_voice_utils import two_phone_call_short_seq
+
+WifiEnums = wifi_utils.WifiEnums
+
+ATTENUATORS = "attenuators"
+WIFI_SSID = "wifi_network_ssid"
+WIFI_PWD = "wifi_network_pass"
+STRESS_COUNT = "stress_iteration"
+
+class WifiTeleCoexTest(TelephonyBaseTest):
+    """Tests for WiFi, Celular Co-existance."""
+
+
+    def __init__(self, controllers):
+        TelephonyBaseTest.__init__(self, controllers)
+
+
+    def setup_class(self):
+        TelephonyBaseTest.setup_class(self)
+        self.dut = self.android_devices[0]
+        wifi_utils.wifi_test_device_init(self.dut)
+        # Set attenuation to 0 on all channels.
+        if getattr(self, ATTENUATORS, []):
+            for a in self.attenuators:
+                a.set_atten(0)
+        self.ads = self.android_devices
+        self.dut = self.android_devices[0]
+        self.wifi_network_ssid = self.user_params.get(WIFI_SSID)
+        self.wifi_network_pass = self.user_params.get(WIFI_PWD)
+        self.network = { WifiEnums.SSID_KEY : self.wifi_network_ssid,
+                         WifiEnums.PWD_KEY : self.wifi_network_pass
+                       }
+        self.stress_count = self.user_params.get(STRESS_COUNT)
+
+
+    def setup_test(self):
+        wifi_utils.wifi_toggle_state(self.dut, True)
+
+
+    def teardown_test(self):
+        wifi_utils.reset_wifi(self.dut)
+
+
+    """Helper Functions"""
+
+
+    def connect_to_wifi(self, ad, network):
+        """Connection logic for open and psk wifi networks.
+
+        Args:
+            ad: Android device object.
+            network: A JSON dict of the WiFi network configuration.
+
+        """
+        ad.ed.clear_all_events()
+        wifi_utils.start_wifi_connection_scan(ad)
+        scan_results = ad.droid.wifiGetScanResults()
+        wifi_utils.assert_network_in_list({WifiEnums.SSID_KEY:
+                self.wifi_network_ssid}, scan_results)
+        wifi_utils.wifi_connect(ad, network)
+        self.log.debug("Connected to %s network on %s device" % (
+                network[WifiEnums.SSID_KEY], ad.serial))
+
+
+    def stress_toggle_wifi(self, stress_count):
+        """Toggle WiFi in a loop.
+
+        Args:
+            stress_count: Number of times to toggle WiFi OFF and ON.
+
+        """
+        for count in range(stress_count):
+            self.log.debug("stress_toggle_wifi: Iteration %d" % count)
+            wifi_utils.toggle_wifi_off_and_on(self.dut)
+
+        if not self.dut.droid.wifiGetisWifiEnabled():
+            raise signals.TestFailure("WiFi did not turn on after toggling it"
+                                      " %d times" % self.stress_count)
+
+
+    def stress_toggle_airplane(self, stress_count):
+        """Toggle Airplane mode in a loop.
+
+        Args:
+            stress_count: Number of times to toggle Airplane mode OFF and ON.
+
+        """
+        for count in range(stress_count):
+            self.log.debug("stress_toggle_airplane: Iteration %d" % count)
+            wifi_utils.toggle_airplane_mode_on_and_off(self.dut)
+
+        if not self.dut.droid.wifiGetisWifiEnabled():
+            raise signals.TestFailure("WiFi did not turn on after toggling it"
+                                      " %d times" % self.stress_count)
+
+
+    def stress_toggle_airplane_and_wifi(self, stress_count):
+        """Toggle Airplane and WiFi modes in a loop.
+
+        Args:
+            stress_count: Number of times to perform Airplane mode ON, WiFi ON,
+                          Airplane mode OFF, in a sequence.
+
+        """
+        self.log.debug("Toggling Airplane mode ON")
+        asserts.assert_true(
+            acts.utils.force_airplane_mode(self.dut, True),
+            "Can not turn on airplane mode on: %s" % self.dut.serial)
+        self.log.debug("Toggling wifi ON")
+        wifi_utils.wifi_toggle_state(self.dut, True)
+        asserts.assert_true(
+            acts.utils.force_airplane_mode(self.dut, False),
+            "Can not turn on airplane mode on: %s" % self.dut.serial)
+
+        if not self.dut.droid.wifiGetisWifiEnabled():
+            raise signals.TestFailure("WiFi did not turn on after toggling it"
+                                      " %d times" % self.stress_count)
+
+
+    def setup_cellular_voice_calling(self):
+        """Setup phone for voice general calling and make sure phone is
+           attached to voice."""
+        # Make sure Phone A and B are attached to voice network.
+        for ad in self.ads:
+            if not phone_setup_voice_general(self.log, ad):
+                raise signals.TestFailure("Phone failed to setup for voice"
+                                          " calling serial:%s" % ad.serial)
+        self.log.debug("Finished setting up phones for voice calling")
+
+
+    def validate_cellular_and_wifi(self):
+        """Validate WiFi, make some cellular calls.
+
+        Steps:
+            1. Check if device is still connected to the WiFi network.
+            2. If WiFi looks good, check if deivce is attached to voice.
+            3. Make a short sequence voice call between Phone A and B.
+
+        """
+        wifi_info = self.dut.droid.wifiGetConnectionInfo()
+        if wifi_info[WifiEnums.SSID_KEY] != self.wifi_network_ssid:
+            raise signals.TestFailure("Phone failed to connect to %s network on"
+                                      " %s" % (self.wifi_network_ssid,
+                                      self.dut.serial))
+
+        # Make short call sequence between Phone A and Phone B.
+        two_phone_call_short_seq(self.log, self.ads[0], None, None, self.ads[1],
+                                 None, None)
+
+    """Tests"""
+
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_toggle_wifi_call(self):
+        """Test to toggle WiFi and then perform WiFi connection and
+           cellular calls.
+
+        Steps:
+            1. Attach device to voice subscription network.
+            2. Connect to a WiFi network.
+            3. Toggle WiFi OFF and ON.
+            4. Verify device auto-connects to the WiFi network.
+            5. Verify device is attached to voice network.
+            6. Make short sequence voice calls.
+
+        """
+        self.setup_cellular_voice_calling()
+        self.connect_to_wifi(self.dut, self.network)
+        wifi_utils.toggle_wifi_off_and_on(self.dut)
+        self.validate_cellular_and_wifi()
+
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_toggle_airplane_call(self):
+        """Test to toggle Airplane mode and perform WiFi connection and
+           cellular calls.
+
+        Steps:
+            1. Attach device to voice subscription network.
+            2. Connect to a WiFi network.
+            3. Toggle Airplane mode OFF and ON.
+            4. Verify device auto-connects to the WiFi network.
+            5. Verify device is attached to voice network.
+            6. Make short sequence voice calls.
+
+        """
+        self.setup_cellular_voice_calling()
+        self.connect_to_wifi(self.dut, self.network)
+        wifi_utils.toggle_airplane_mode_on_and_off(self.dut)
+        self.validate_cellular_and_wifi()
+
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_toggle_airplane_and_wifi_call(self):
+        """Test to toggle WiFi in a loop and perform WiFi connection and
+           cellular calls.
+
+        Steps:
+            1. Attach device to voice subscription network.
+            2. Connect to a WiFi network.
+            3. Toggle Airplane mode ON.
+            4. Turn WiFi ON.
+            5. Toggle Airplane mode OFF.
+            3. Verify device auto-connects to the WiFi network.
+            4. Verify device is attached to voice network.
+            5. Make short sequence voice calls.
+
+        """
+        self.setup_cellular_voice_calling()
+        self.connect_to_wifi(self.dut, self.network)
+        self.stress_toggle_airplane_and_wifi(1)
+        self.validate_cellular_and_wifi()
+
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_stress_toggle_wifi_call(self):
+        """Stress test to toggle WiFi in a loop, then perform WiFi connection
+           and cellular calls.
+
+        Steps:
+            1. Attach device to voice subscription network.
+            2. Connect to a WiFi network.
+            3. Toggle WiFi OFF and ON in a loop.
+            4. Verify device auto-connects to the WiFi network.
+            5. Verify device is attached to voice network.
+            6. Make short sequence voice calls.
+
+        """
+        self.setup_cellular_voice_calling()
+        self.connect_to_wifi(self.dut, self.network)
+        self.stress_toggle_wifi(self.stress_count)
+        self.validate_cellular_and_wifi()
+
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_stress_toggle_airplane_call(self):
+        """Stress test to toggle Airplane mode in a loop, then perform WiFi and
+           cellular calls.
+
+        Steps:
+            1. Attach device to voice subscription network.
+            2. Connect to a WiFi network.
+            3. Toggle Airplane mode OFF and ON in a loop.
+            4. Verify device auto-connects to the WiFi network.
+            5. Verify device is attached to voice network.
+            6. Make short sequence voice calls.
+
+        """
+        self.setup_cellular_voice_calling()
+        self.connect_to_wifi(self.dut, self.network)
+        self.stress_toggle_airplane(self.stress_count)
+        self.validate_cellular_and_wifi()
+
+
+    @TelephonyBaseTest.tel_test_wrap
+    def test_stress_toggle_airplane_and_wifi_call(self):
+        """Stress test to toggle Airplane and WiFi mode in a loop, then perform
+           WiFi connection and cellular calls.
+
+        Steps:
+            1. Attach device to voice subscription network.
+            2. Connect to a WiFi network.
+            3. Toggle Airplane mode ON.
+            4. Turn WiFi ON.
+            5. Toggle Airplane mode OFF.
+            6. Repeat 3, 4 & 5, in a loop.
+            7. Verify device auto-connects to the WiFi network.
+            8. Verify device is attached to voice network.
+            9. Make short sequence voice calls.
+
+        """
+        self.setup_cellular_voice_calling()
+        self.connect_to_wifi(self.dut, self.network)
+        stress_toggle_airplane_and_wifi(self.stress_count)
+        self.validate_cellular_and_wifi()