diff --git a/PREUPLOAD.cfg b/PREUPLOAD.cfg
index 053c580..b76b797 100644
--- a/PREUPLOAD.cfg
+++ b/PREUPLOAD.cfg
@@ -1,32 +1,7 @@
 [Hook Scripts]
-acts_adb_test = ./acts/framework/tests/acts_adb_test.py
-acts_android_device_test = ./acts/framework/tests/acts_android_device_test.py
-acts_asserts_test = ./acts/framework/tests/acts_asserts_test.py
-acts_base_class_test = ./acts/framework/tests/acts_base_class_test.py
-acts_config_test = ./acts/framework/tests/config/unittest_bundle.py
-acts_context_test = ./acts/framework/tests/acts_context_test.py
-acts_error_test = ./acts/framework/tests/acts_error_test.py
-acts_host_utils_test = ./acts/framework/tests/acts_host_utils_test.py
-acts_import_test_utils_test = ./acts/framework/tests/acts_import_test_utils_test.py
-acts_import_unit_test = ./acts/framework/tests/acts_import_unit_test.py
-acts_job_test = ./acts/framework/tests/acts_job_test.py
-acts_libs_ota_tests = ./acts/framework/tests/libs/ota/unittest_bundle.py
-acts_logger_test = ./acts/framework/tests/acts_logger_test.py
-acts_metrics_test = ./acts/framework/tests/libs/metrics/unittest_bundle.py
-acts_records_test = ./acts/framework/tests/acts_records_test.py
-acts_relay_controller_test = ./acts/framework/tests/acts_relay_controller_test.py
-acts_test_runner_test = ./acts/framework/tests/acts_test_runner_test.py
-acts_unittest_suite = ./acts/framework/tests/acts_unittest_suite.py
-acts_utils_test = ./acts/framework/tests/acts_utils_test.py
-android_lib_unittest_bundle = ./acts/framework/tests/controllers/android_lib/android_lib_unittest_bundle.py
-event_unittest_bundle = ./acts/framework/tests/event/event_unittest_bundle.py
-instrumentation_unit_test_suite = ./acts/framework/tests/test_utils/instrumentation/unit_test_suite.py
-logging_unittest_bundle = ./acts/framework/tests/libs/logging/logging_unittest_bundle.py
-metrics_tests = ./acts/framework/tests/metrics/unittest_bundle.py
-proc_unittest_bundle = ./acts/framework/tests/libs/proc/proc_unittest_bundle.py
-sl4a_lib_suite = ./acts/framework/tests/controllers/sl4a_lib/test_suite.py
-test_runner_test = ./acts/framework/tests/test_runner_test.py
-version_selector_tests = ./acts/framework/tests/libs/version_selector_test.py
+create_virtualenv = ./tools/create_virtualenv.sh
+acts_unittests = /tmp/acts_preupload_virtualenv/bin/python3 ./acts/tests/meta/ActsUnitTest.py
+destroy_virtualenv = rm -rf /tmp/acts_preupload_virtualenv/
 
 lab_test = ./tools/lab/lab_upload_hooks.py
 proto_check = ./tools/proto_check.py
diff --git a/acts/framework/acts/base_test.py b/acts/framework/acts/base_test.py
index 0e250f4..4e3c4de 100755
--- a/acts/framework/acts/base_test.py
+++ b/acts/framework/acts/base_test.py
@@ -198,16 +198,6 @@
             class_name=self.__class__.__name__,
             controller_configs=self.testbed_configs)
 
-        # Import and register the built-in controller modules specified
-        # in testbed config.
-        for module in self._import_builtin_controllers():
-            self.register_controller(module, builtin=True)
-        if hasattr(self, 'android_devices'):
-            for ad in self.android_devices:
-                if ad.droid:
-                    utils.set_location_service(ad, False)
-                    utils.sync_device_time(ad)
-
     def _import_builtin_controllers(self):
         """Import built-in controller modules.
 
@@ -386,6 +376,10 @@
         is called.
         """
         event_bus.post(TestClassBeginEvent(self))
+        # Import and register the built-in controller modules specified
+        # in testbed config.
+        for module in self._import_builtin_controllers():
+            self.register_controller(module, builtin=True)
         return self.setup_class()
 
     def _teardown_class(self):
@@ -899,6 +893,7 @@
                 self._block_all_test_cases(tests)
                 setup_fail = True
         except signals.TestAbortClass:
+            self.log.exception('Test class %s aborted' % self.TAG)
             setup_fail = True
         except Exception as e:
             self.log.exception("Failed to setup %s.", self.TAG)
@@ -917,6 +912,7 @@
                     self.exec_one_testcase(test_name, test_func, self.cli_args)
             return self.results
         except signals.TestAbortClass:
+            self.log.exception('Test class %s aborted' % self.TAG)
             return self.results
         except signals.TestAbortAll as e:
             # Piggy-back test results on this exception object so we don't lose
diff --git a/acts/framework/acts/controllers/android_device.py b/acts/framework/acts/controllers/android_device.py
index 52404fa..9f03c93 100755
--- a/acts/framework/acts/controllers/android_device.py
+++ b/acts/framework/acts/controllers/android_device.py
@@ -100,6 +100,10 @@
                  " but is not attached.") % ad.serial,
                 serial=ad.serial)
     _start_services_on_ads(ads)
+    for ad in ads:
+        if ad.droid:
+            utils.set_location_service(ad, False)
+            utils.sync_device_time(ad)
     return ads
 
 
diff --git a/acts/framework/acts/controllers/anritsu_lib/md8475_cellular_simulator.py b/acts/framework/acts/controllers/anritsu_lib/md8475_cellular_simulator.py
index 892a786..23fee41 100644
--- a/acts/framework/acts/controllers/anritsu_lib/md8475_cellular_simulator.py
+++ b/acts/framework/acts/controllers/anritsu_lib/md8475_cellular_simulator.py
@@ -14,7 +14,10 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
+import ntpath
+import time
 import acts.controllers.cellular_simulator as cc
+from acts.test_utils.power.tel_simulations import LteSimulation
 from acts.controllers.anritsu_lib import md8475a
 from acts.controllers.anritsu_lib import _anritsu_utils as anritsu
 
@@ -23,20 +26,501 @@
 
     MD8475_VERSION = 'A'
 
+    # Indicates if it is able to use 256 QAM as the downlink modulation for LTE
+    LTE_SUPPORTS_DL_256QAM = False
+
+    # Indicates if it is able to use 64 QAM as the uplink modulation for LTE
+    LTE_SUPPORTS_UL_64QAM = False
+
+    # Indicates if 4x4 MIMO is supported for LTE
+    LTE_SUPPORTS_4X4_MIMO = False
+
+    # The maximum number of carriers that this simulator can support for LTE
+    LTE_MAX_CARRIERS = 2
+
+    # The maximum power that the equipment is able to transmit
+    MAX_DL_POWER = -10
+
+    # Simulation config files in the callbox computer.
+    # These should be replaced in the future by setting up
+    # the same configuration manually.
+    LTE_BASIC_SIM_FILE = 'SIM_default_LTE.wnssp'
+    LTE_BASIC_CELL_FILE = 'CELL_LTE_config.wnscp'
+    LTE_CA_BASIC_SIM_FILE = 'SIM_LTE_CA.wnssp'
+    LTE_CA_BASIC_CELL_FILE = 'CELL_LTE_CA_config.wnscp'
+
+    # Filepath to the config files stored in the Anritsu callbox. Needs to be
+    # formatted to replace {} with either A or B depending on the model.
+    CALLBOX_CONFIG_PATH = 'C:\\Users\\MD8475A\\Documents\\DAN_configs\\'
+
     def __init__(self, ip_address):
+        """ Initializes the cellular simulator.
+
+        Args:
+            ip_address: the ip address of the MD8475 instrument
+        """
+        super().__init__()
+
         try:
             self.anritsu = md8475a.MD8475A(ip_address,
                                            md8475_version=self.MD8475_VERSION)
         except anritsu.AnristuError:
             raise cc.CellularSimulatorError('Could not connect to MD8475.')
 
+        self.bts = None
+
     def destroy(self):
         """ Sends finalization commands to the cellular equipment and closes
         the connection. """
         self.anritsu.stop_simulation()
         self.anritsu.disconnect()
 
+    def setup_lte_scenario(self):
+        """ Configures the equipment for an LTE simulation. """
+        cell_file_name = self.LTE_BASIC_CELL_FILE
+        sim_file_name = self.LTE_BASIC_SIM_FILE
+
+        cell_file_path = ntpath.join(self.CALLBOX_CONFIG_PATH, cell_file_name)
+        sim_file_path = ntpath.join(self.CALLBOX_CONFIG_PATH, sim_file_name)
+
+        self.anritsu.load_simulation_paramfile(sim_file_path)
+        self.anritsu.load_cell_paramfile(cell_file_path)
+        self.anritsu.start_simulation()
+
+        self.bts = [self.anritsu.get_BTS(md8475a.BtsNumber.BTS1)]
+
+    def setup_lte_ca_scenario(self):
+        """ Configures the equipment for an LTE with CA simulation. """
+        cell_file_name = self.LTE_CA_BASIC_CELL_FILE
+        sim_file_name = self.LTE_CA_BASIC_SIM_FILE
+
+        cell_file_path = ntpath.join(self.CALLBOX_CONFIG_PATH, cell_file_name)
+        sim_file_path = ntpath.join(self.CALLBOX_CONFIG_PATH, sim_file_name)
+
+        self.anritsu.load_simulation_paramfile(sim_file_path)
+        self.anritsu.load_cell_paramfile(cell_file_path)
+        self.anritsu.start_simulation()
+
+        self.bts = [
+            self.anritsu.get_BTS(md8475a.BtsNumber.BTS1),
+            self.anritsu.get_BTS(md8475a.BtsNumber.BTS2)
+        ]
+
+    def set_input_power(self, bts_index, input_power):
+        """ Sets the input power for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            input_power: the new input power
+        """
+        self.bts[bts_index].input_level = input_power
+
+    def set_output_power(self, bts_index, output_power):
+        """ Sets the output power for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            output_power: the new output power
+        """
+        self.bts[bts_index].output_level = output_power
+
+    def set_downlink_channel_number(self, bts_index, channel_number):
+        """ Sets the downlink channel number for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            channel_number: the new channel number
+        """
+        # Temporarily adding this line to workaround a bug in the
+        # Anritsu callbox in which the channel number needs to be set
+        # to a different value before setting it to the final one.
+        self.bts[bts_index].dl_channel = str(channel_number + 1)
+        time.sleep(8)
+        self.bts[bts_index].dl_channel = str(channel_number)
+
+    def set_enabled_for_ca(self, bts_index, enabled):
+        """ Enables or disables the base station during carrier aggregation.
+
+        Args:
+            bts_index: the base station number
+            enabled: whether the base station should be enabled for ca.
+        """
+        self.bts[bts_index].dl_cc_enabled = enabled
+
+    def set_dl_modulation(self, bts_index, modulation):
+        """ Sets the DL modulation for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            modulation: the new DL modulation
+        """
+        self.bts[bts_index].lte_dl_modulation_order = modulation
+
+    def set_ul_modulation(self, bts_index, modulation):
+        """ Sets the UL modulation for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            modulation: the new UL modulation
+        """
+        self.bts[bts_index].lte_ul_modulation_order = modulation
+
+    def set_tbs_pattern_on(self, bts_index, tbs_pattern_on):
+        """ Enables or disables TBS pattern in the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            tbs_pattern_on: the new TBS pattern setting
+        """
+        if tbs_pattern_on:
+            self.bts[bts_index].tbs_pattern = 'FULLALLOCATION'
+        else:
+            self.bts[bts_index].tbs_pattern = 'OFF'
+
+    def set_band(self, bts_index, band):
+        """ Sets the right duplex mode before switching to a new band.
+
+        Args:
+            bts_index: the base station number
+            band: desired band
+        """
+        bts = self.bts[bts_index]
+
+        # The callbox won't restore the band-dependent default values if the
+        # request is to switch to the same band as the one the base station is
+        # currently using. To ensure that default values are restored, go to a
+        # different band before switching.
+        if int(bts.band) == band:
+            # Using bands 1 and 2 but it could be any others
+            bts.band = '1' if band != 1 else '2'
+            # Switching to config.band will be handled by the parent class
+            # implementation of this method.
+
+        bts.duplex_mode = self.get_duplex_mode(band).value
+        bts.band = band
+        time.sleep(5)  # It takes some time to propagate the new band
+
+    def get_duplex_mode(self, band):
+        """ Determines if the band uses FDD or TDD duplex mode
+
+        Args:
+            band: a band number
+        Returns:
+            an variable of class DuplexMode indicating if band is FDD or TDD
+        """
+
+        if 33 <= int(band) <= 46:
+            return LteSimulation.DuplexMode.TDD
+        else:
+            return LteSimulation.DuplexMode.FDD
+
+    def set_tdd_config(self, bts_index, config):
+        """ Sets the frame structure for TDD bands.
+
+        Args:
+            bts_index: the base station number
+            config: the desired frame structure. An int between 0 and 6.
+        """
+
+        if not 0 <= config <= 6:
+            raise ValueError("The frame structure configuration has to be a "
+                             "number between 0 and 6")
+
+        self.bts[bts_index].uldl_configuration = config
+
+        # Wait for the setting to propagate
+        time.sleep(5)
+
+    def set_bandwidth(self, bts_index, bandwidth):
+        """ Sets the LTE channel bandwidth (MHz)
+
+        Args:
+            bts_index: the base station number
+            bandwidth: desired bandwidth (MHz)
+        """
+        bts = self.bts[bts_index]
+
+        if bandwidth == 20:
+            bts.bandwidth = md8475a.BtsBandwidth.LTE_BANDWIDTH_20MHz
+        elif bandwidth == 15:
+            bts.bandwidth = md8475a.BtsBandwidth.LTE_BANDWIDTH_15MHz
+        elif bandwidth == 10:
+            bts.bandwidth = md8475a.BtsBandwidth.LTE_BANDWIDTH_10MHz
+        elif bandwidth == 5:
+            bts.bandwidth = md8475a.BtsBandwidth.LTE_BANDWIDTH_5MHz
+        elif bandwidth == 3:
+            bts.bandwidth = md8475a.BtsBandwidth.LTE_BANDWIDTH_3MHz
+        elif bandwidth == 1.4:
+            bts.bandwidth = md8475a.BtsBandwidth.LTE_BANDWIDTH_1dot4MHz
+        else:
+            msg = "Bandwidth = {} MHz is not valid for LTE".format(bandwidth)
+            self.log.error(msg)
+            raise ValueError(msg)
+        time.sleep(5)  # It takes some time to propagate the new settings
+
+    def set_mimo_mode(self, bts_index, mimo):
+        """ Sets the number of DL antennas for the desired MIMO mode.
+
+        Args:
+            bts_index: the base station number
+            mimo: object of class MimoMode
+        """
+
+        bts = self.bts[bts_index]
+
+        # If the requested mimo mode is not compatible with the current TM,
+        # warn the user before changing the value.
+
+        if mimo == LteSimulation.MimoMode.MIMO_1x1:
+            if bts.transmode not in [
+                    LteSimulation.TransmissionMode.TM1,
+                    LteSimulation.TransmissionMode.TM7
+            ]:
+                self.log.warning(
+                    "Using only 1 DL antennas is not allowed with "
+                    "the current transmission mode. Changing the "
+                    "number of DL antennas will override this "
+                    "setting.")
+            bts.dl_antenna = 1
+        elif mimo == LteSimulation.MimoMode.MIMO_2x2:
+            if bts.transmode not in [
+                    LteSimulation.TransmissionMode.TM2,
+                    LteSimulation.TransmissionMode.TM3,
+                    LteSimulation.TransmissionMode.TM4,
+                    LteSimulation.TransmissionMode.TM8,
+                    LteSimulation.TransmissionMode.TM9
+            ]:
+                self.log.warning("Using two DL antennas is not allowed with "
+                                 "the current transmission mode. Changing the "
+                                 "number of DL antennas will override this "
+                                 "setting.")
+            bts.dl_antenna = 2
+        elif mimo == LteSimulation.MimoMode.MIMO_4x4:
+            if bts.transmode not in [
+                    LteSimulation.TransmissionMode.TM2,
+                    LteSimulation.TransmissionMode.TM3,
+                    LteSimulation.TransmissionMode.TM4,
+                    LteSimulation.TransmissionMode.TM9
+            ]:
+                self.log.warning("Using four DL antennas is not allowed with "
+                                 "the current transmission mode. Changing the "
+                                 "number of DL antennas will override this "
+                                 "setting.")
+
+            bts.dl_antenna = 4
+        else:
+            RuntimeError("The requested MIMO mode is not supported.")
+
+    def set_scheduling_mode(self, bts_index, scheduling, mcs_dl, mcs_ul,
+                            nrb_dl, nrb_ul):
+        """ Sets the scheduling mode for LTE
+
+        Args:
+            bts_index: the base station number
+            scheduling: DYNAMIC or STATIC scheduling (Enum list)
+            mcs_dl: Downlink MCS (only for STATIC scheduling)
+            mcs_ul: Uplink MCS (only for STATIC scheduling)
+            nrb_dl: Number of RBs for downlink (only for STATIC scheduling)
+            nrb_ul: Number of RBs for uplink (only for STATIC scheduling)
+        """
+
+        bts = self.bts[bts_index]
+        bts.lte_scheduling_mode = scheduling.value
+
+        if scheduling == LteSimulation.SchedulingMode.STATIC:
+
+            if not all([nrb_dl, nrb_ul, mcs_dl, mcs_ul]):
+                raise ValueError('When the scheduling mode is set to manual, '
+                                 'the RB and MCS parameters are required.')
+
+            bts.packet_rate = md8475a.BtsPacketRate.LTE_MANUAL
+            bts.lte_mcs_dl = mcs_dl
+            bts.lte_mcs_ul = mcs_ul
+            bts.nrb_dl = nrb_dl
+            bts.nrb_ul = nrb_ul
+
+        time.sleep(5)  # It takes some time to propagate the new settings
+
+    def lte_attach_secondary_carriers(self):
+        """ Activates the secondary carriers for CA. Requires the DUT to be
+        attached to the primary carrier first. """
+
+        testcase = self.anritsu.get_AnritsuTestCases()
+        # Setting the procedure to selection is needed because of a bug in the
+        # instrument's software (b/139547391).
+        testcase.procedure = md8475a.TestProcedure.PROCEDURE_SELECTION
+        testcase.procedure = md8475a.TestProcedure.PROCEDURE_MULTICELL
+        testcase.power_control = md8475a.TestPowerControl.POWER_CONTROL_DISABLE
+        testcase.measurement_LTE = md8475a.TestMeasurement.MEASUREMENT_DISABLE
+
+        self.anritsu.start_testcase()
+
+        retry_counter = 0
+        self.log.info("Waiting for the test case to start...")
+        time.sleep(5)
+
+        while self.anritsu.get_testcase_status() == "0":
+            retry_counter += 1
+            if retry_counter == 3:
+                raise RuntimeError(
+                    "The test case failed to start after {} "
+                    "retries. The connection between the phone "
+                    "and the base station might be unstable.".format(
+                        retry_counter))
+            time.sleep(10)
+
+    def set_transmission_mode(self, bts_index, tmode):
+        """ Sets the transmission mode for the LTE basetation
+
+        Args:
+            bts_index: the base station number
+            tmode: Enum list from class 'TransmissionModeLTE'
+        """
+
+        bts = self.bts[bts_index]
+
+        # If the selected transmission mode does not support the number of DL
+        # antennas, throw an exception.
+        if (tmode in [
+                LteSimulation.TransmissionMode.TM1,
+                LteSimulation.TransmissionMode.TM7
+        ] and bts.dl_antenna != '1'):
+            # TM1 and TM7 only support 1 DL antenna
+            raise ValueError("{} allows only one DL antenna. Change the "
+                             "number of DL antennas before setting the "
+                             "transmission mode.".format(tmode.value))
+        elif (tmode == LteSimulation.TransmissionMode.TM8
+              and bts.dl_antenna != '2'):
+            # TM8 requires 2 DL antennas
+            raise ValueError("TM2 requires two DL antennas. Change the "
+                             "number of DL antennas before setting the "
+                             "transmission mode.")
+        elif (tmode in [
+                LteSimulation.TransmissionMode.TM2,
+                LteSimulation.TransmissionMode.TM3,
+                LteSimulation.TransmissionMode.TM4,
+                LteSimulation.TransmissionMode.TM9
+        ] and bts.dl_antenna == '1'):
+            # TM2, TM3, TM4 and TM9 require 2 or 4 DL antennas
+            raise ValueError("{} requires at least two DL atennas. Change the "
+                             "number of DL antennas before setting the "
+                             "transmission mode.".format(tmode.value))
+
+        # The TM mode is allowed for the current number of DL antennas, so it
+        # is safe to change this setting now
+        bts.transmode = tmode.value
+
+        time.sleep(5)  # It takes some time to propagate the new settings
+
+    def wait_until_attached(self, timeout=120):
+        """ Waits until the DUT is attached to the primary carrier.
+
+        Args:
+            timeout: after this amount of time the method will raise a
+                CellularSimulatorError exception. Default is 120 seconds.
+        """
+        try:
+            self.anritsu.wait_for_registration_state(time_to_wait=timeout)
+        except anritsu.AnritsuError:
+            raise cc.CellularSimulatorError('The phone did not attach before '
+                                            'the timeout period ended.')
+
+    def wait_until_communication_state(self, timeout=120):
+        """ Waits until the DUT is in Communication state.
+
+        Args:
+            timeout: after this amount of time the method will raise a
+                CellularSimulatorError exception. Default is 120 seconds.
+        """
+        try:
+            self.anritsu.wait_for_communication_state(time_to_wait=timeout)
+        except anritsu.AnritsuError:
+            raise cc.CellularSimulatorError('The phone was not in '
+                                            'Communication state before '
+                                            'the timeout period ended.')
+
+    def wait_until_idle_state(self, timeout=120):
+        """ Waits until the DUT is in Idle state.
+
+        Args:
+            timeout: after this amount of time the method will raise a
+                CellularSimulatorError exception. Default is 120 seconds.
+        """
+        try:
+            self.anritsu.wait_for_idle_state(time_to_wait=timeout)
+        except anritsu.AnritsuError:
+            raise cc.CellularSimulatorError('The phone was not in Idle state '
+                                            'before the time the timeout '
+                                            'period ended.')
+
+    def detach(self):
+        """ Turns off all the base stations so the DUT loose connection."""
+        self.anritsu.set_simulation_state_to_poweroff()
+
+    def stop(self):
+        """ Stops current simulation. After calling this method, the simulator
+        will need to be set up again. """
+        self.simulator.stop()
+
+    def start_data_traffic(self):
+        """ Starts transmitting data from the instrument to the DUT. """
+        try:
+            self.anritsu.start_ip_traffic()
+        except md8475a.AnritsuError as inst:
+            # This typically happens when traffic is already running.
+            # TODO (b/141962691): continue only if traffic is running
+            self.log.warning(str(inst))
+        time.sleep(4)
+
+    def stop_data_traffic(self):
+        """ Stops transmitting data from the instrument to the DUT. """
+        try:
+            self.anritsu.stop_ip_traffic()
+        except md8475a.AnritsuError as inst:
+            # This typically happens when traffic has already been stopped
+            # TODO (b/141962691): continue only if traffic is stopped
+            self.log.warning(str(inst))
+        time.sleep(2)
+
 
 class MD8475BCellularSimulator(MD8475CellularSimulator):
 
     MD8475_VERSION = 'B'
+
+    # Indicates if it is able to use 256 QAM as the downlink modulation for LTE
+    LTE_SUPPORTS_DL_256QAM = True
+
+    # Indicates if it is able to use 64 QAM as the uplink modulation for LTE
+    LTE_SUPPORTS_UL_64QAM = True
+
+    # Indicates if 4x4 MIMO is supported for LTE
+    LTE_SUPPORTS_4X4_MIMO = True
+
+    # The maximum number of carriers that this simulator can support for LTE
+    LTE_MAX_CARRIERS = 4
+
+    # The maximum power that the equipment is able to transmit
+    MAX_DL_POWER = -30
+
+    # Simulation config files in the callbox computer.
+    # These should be replaced in the future by setting up
+    # the same configuration manually.
+    LTE_BASIC_SIM_FILE = 'SIM_default_LTE.wnssp2'
+    LTE_BASIC_CELL_FILE = 'CELL_LTE_config.wnscp2'
+    LTE_CA_BASIC_SIM_FILE = 'SIM_LTE_CA.wnssp2'
+    LTE_CA_BASIC_CELL_FILE = 'CELL_LTE_CA_config.wnscp2'
+
+    # Filepath to the config files stored in the Anritsu callbox. Needs to be
+    # formatted to replace {} with either A or B depending on the model.
+    CALLBOX_CONFIG_PATH = 'C:\\Users\\MD8475B\\Documents\\DAN_configs\\'
+
+    def setup_lte_ca_scenario(self):
+        """ The B model can support up to five carriers. """
+
+        super().setup_lte_ca_scenario()
+
+        self.bts.extend([
+            self.anritsu.get_BTS(md8475a.BtsNumber.BTS3),
+            self.anritsu.get_BTS(md8475a.BtsNumber.BTS4),
+            self.anritsu.get_BTS(md8475a.BtsNumber.BTS5)
+        ])
diff --git a/acts/framework/acts/controllers/cellular_simulator.py b/acts/framework/acts/controllers/cellular_simulator.py
index 8c82792..a140c0f 100644
--- a/acts/framework/acts/controllers/cellular_simulator.py
+++ b/acts/framework/acts/controllers/cellular_simulator.py
@@ -13,6 +13,8 @@
 #   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 import logger
+from acts.test_utils.power import tel_simulations as sims
 
 
 class AbstractCellularSimulator:
@@ -22,11 +24,286 @@
 
     This class defines the interface that every cellular simulator controller
     needs to implement and shouldn't be instantiated by itself. """
+
+    # Indicates if it is able to use 256 QAM as the downlink modulation for LTE
+    LTE_SUPPORTS_DL_256QAM = None
+
+    # Indicates if it is able to use 64 QAM as the uplink modulation for LTE
+    LTE_SUPPORTS_UL_64QAM = None
+
+    # Indicates if 4x4 MIMO is supported for LTE
+    LTE_SUPPORTS_4X4_MIMO = None
+
+    # The maximum number of carriers that this simulator can support for LTE
+    LTE_MAX_CARRIERS = None
+
+    # The maximum power that the equipment is able to transmit
+    MAX_DL_POWER = None
+
+    def __init__(self):
+        """ Initializes the cellular simulator. """
+        self.log = logger.create_tagged_trace_logger('CellularSimulator')
+
     def destroy(self):
         """ Sends finalization commands to the cellular equipment and closes
         the connection. """
         raise NotImplementedError()
 
+    def setup_lte_scenario(self):
+        """ Configures the equipment for an LTE simulation. """
+        raise NotImplementedError()
+
+    def setup_lte_ca_scenario(self):
+        """ Configures the equipment for an LTE with CA simulation. """
+        raise NotImplementedError()
+
+    def configure_bts(self, config, bts_index=0):
+        """ Commands the equipment to setup a base station with the required
+        configuration. This method applies configurations that are common to all
+        RATs.
+
+        Args:
+            config: a BaseSimulation.BtsConfig object.
+            bts_index: the base station number.
+        """
+
+        if config.output_power:
+            self.set_output_power(bts_index, config.output_power)
+
+        if config.input_power:
+            self.set_input_power(bts_index, config.input_power)
+
+        if isinstance(config, sims.LteSimulation.LteSimulation.BtsConfig):
+            self.configure_lte_bts(config, bts_index)
+
+    def configure_lte_bts(self, config, bts_index=0):
+        """ Commands the equipment to setup an LTE base station with the
+        required configuration.
+
+        Args:
+            config: an LteSimulation.BtsConfig object.
+            bts_index: the base station number.
+        """
+        if config.band:
+            self.set_band(bts_index, config.band)
+
+        if config.dlul_config:
+            self.set_tdd_config(bts_index, config.dlul_config)
+
+        if config.bandwidth:
+            self.set_bandwidth(bts_index, config.bandwidth)
+
+        if config.dl_channel:
+            self.set_downlink_channel_number(bts_index, config.dl_channel)
+
+        if config.mimo_mode:
+            self.set_mimo_mode(bts_index, config.mimo_mode)
+
+        if config.transmission_mode:
+            self.set_transmission_mode(bts_index, config.transmission_mode)
+
+        if config.scheduling_mode:
+
+            if (config.scheduling_mode ==
+                    sims.LteSimulation.SchedulingMode.STATIC
+                    and not (config.dl_rbs and config.ul_rbs and config.dl_mcs
+                             and config.ul_mcs)):
+                raise ValueError('When the scheduling mode is set to manual, '
+                                 'the RB and MCS parameters are required.')
+
+            # If scheduling mode is set to Dynamic, the RB and MCS parameters
+            # will be ignored by set_scheduling_mode.
+            self.set_scheduling_mode(bts_index, config.scheduling_mode,
+                                     config.dl_mcs, config.ul_mcs,
+                                     config.dl_rbs, config.ul_rbs)
+
+        # This variable stores a boolean value so the following is needed to
+        # differentiate False from None
+        if config.dl_cc_enabled is not None:
+            self.set_enabled_for_ca(bts_index, config.dl_cc_enabled)
+
+        if config.dl_modulation_order:
+            self.set_dl_modulation(bts_index, config.dl_modulation_order)
+
+        if config.ul_modulation_order:
+            self.set_ul_modulation(bts_index, config.ul_modulation_order)
+
+        # This variable stores a boolean value so the following is needed to
+        # differentiate False from None
+        if config.tbs_pattern_on is not None:
+            self.set_tbs_pattern_on(bts_index, config.tbs_pattern_on)
+
+    def set_band(self, bts_index, band):
+        """ Sets the band for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            band: the new band
+        """
+        raise NotImplementedError()
+
+    def set_input_power(self, bts_index, input_power):
+        """ Sets the input power for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            input_power: the new input power
+        """
+        raise NotImplementedError()
+
+    def set_output_power(self, bts_index, output_power):
+        """ Sets the output power for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            output_power: the new output power
+        """
+        raise NotImplementedError()
+
+    def set_tdd_config(self, bts_index, tdd_config):
+        """ Sets the tdd configuration number for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            tdd_config: the new tdd configuration number
+        """
+        raise NotImplementedError()
+
+    def set_bandwidth(self, bts_index, bandwidth):
+        """ Sets the bandwidth for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            bandwidth: the new bandwidth
+        """
+        raise NotImplementedError()
+
+    def set_downlink_channel_number(self, bts_index, channel_number):
+        """ Sets the downlink channel number for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            channel_number: the new channel number
+        """
+        raise NotImplementedError()
+
+    def set_mimo_mode(self, bts_index, mimo_mode):
+        """ Sets the mimo mode for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            mimo_mode: the new mimo mode
+        """
+        raise NotImplementedError()
+
+    def set_transmission_mode(self, bts_index, transmission_mode):
+        """ Sets the transmission mode for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            transmission_mode: the new transmission mode
+        """
+        raise NotImplementedError()
+
+    def set_scheduling_mode(self, bts_index, scheduling_mode, mcs_dl, mcs_ul,
+                            nrb_dl, nrb_ul):
+        """ Sets the scheduling mode for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            scheduling_mode: the new scheduling mode
+            mcs_dl: Downlink MCS (only for STATIC scheduling)
+            mcs_ul: Uplink MCS (only for STATIC scheduling)
+            nrb_dl: Number of RBs for downlink (only for STATIC scheduling)
+            nrb_ul: Number of RBs for uplink (only for STATIC scheduling)
+        """
+        raise NotImplementedError()
+
+    def set_enabled_for_ca(self, bts_index, enabled):
+        """ Enables or disables the base station during carrier aggregation.
+
+        Args:
+            bts_index: the base station number
+            enabled: whether the base station should be enabled for ca.
+        """
+        raise NotImplementedError()
+
+    def set_dl_modulation(self, bts_index, modulation):
+        """ Sets the DL modulation for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            modulation: the new DL modulation
+        """
+        raise NotImplementedError()
+
+    def set_ul_modulation(self, bts_index, modulation):
+        """ Sets the UL modulation for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            modulation: the new UL modulation
+        """
+        raise NotImplementedError()
+
+    def set_tbs_pattern_on(self, bts_index, tbs_pattern_on):
+        """ Enables or disables TBS pattern in the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            tbs_pattern_on: the new TBS pattern setting
+        """
+        raise NotImplementedError()
+
+    def lte_attach_secondary_carriers(self):
+        """ Activates the secondary carriers for CA. Requires the DUT to be
+        attached to the primary carrier first. """
+        raise NotImplementedError()
+
+    def wait_until_attached(self, timeout=120):
+        """ Waits until the DUT is attached to the primary carrier.
+
+        Args:
+            timeout: after this amount of time the method will raise a
+                CellularSimulatorError exception. Default is 120 seconds.
+        """
+        raise NotImplementedError()
+
+    def wait_until_communication_state(self, timeout=120):
+        """ Waits until the DUT is in Communication state.
+
+        Args:
+            timeout: after this amount of time the method will raise a
+                CellularSimulatorError exception. Default is 120 seconds.
+        """
+        raise NotImplementedError()
+
+    def wait_until_idle_state(self, timeout=120):
+        """ Waits until the DUT is in Idle state.
+
+        Args:
+            timeout: after this amount of time the method will raise a
+                CellularSimulatorError exception. Default is 120 seconds.
+        """
+        raise NotImplementedError()
+
+    def detach(self):
+        """ Turns off all the base stations so the DUT loose connection."""
+        raise NotImplementedError()
+
+    def stop(self):
+        """ Stops current simulation. After calling this method, the simulator
+        will need to be set up again. """
+        raise NotImplementedError()
+
+    def start_data_traffic(self):
+        """ Starts transmitting data from the instrument to the DUT. """
+        raise NotImplementedError()
+
+    def stop_data_traffic(self):
+        """ Stops transmitting data from the instrument to the DUT. """
+        raise NotImplementedError()
+
 
 class CellularSimulatorError(Exception):
     """ Exceptions thrown when the cellular equipment is unreachable or it
diff --git a/acts/framework/acts/controllers/monsoon_lib/sampling/hvpm/packet.py b/acts/framework/acts/controllers/monsoon_lib/sampling/hvpm/packet.py
index f62975d..2233370 100644
--- a/acts/framework/acts/controllers/monsoon_lib/sampling/hvpm/packet.py
+++ b/acts/framework/acts/controllers/monsoon_lib/sampling/hvpm/packet.py
@@ -53,8 +53,8 @@
      1  │    2   │ uint16 │  Main   │ Fine    │ Calibration/Measurement value
      2  │    4   │ uint16 │  USB    │ Coarse  │ Calibration/Measurement value
      3  │    6   │ uint16 │  USB    │ Fine    │ Calibration/Measurement value
-     4  │    8   │  int16 │  Aux    │ Coarse  │ Calibration/Measurement value
-     5  │   10   │  int16 │  Aux    │ Fine    │ Calibration/Measurement value
+     4  │    8   │ uint16 │  Aux    │ Coarse  │ Calibration/Measurement value
+     5  │   10   │ uint16 │  Aux    │ Fine    │ Calibration/Measurement value
      6  │   12   │ uint16 │  Main   │ Voltage │ Main V measurement, or Aux V
         │        │        │         │         │    if setVoltageChannel == 1
      7  │   14   │ uint16 │  USB    │ Voltage │ USB Voltage
@@ -76,7 +76,7 @@
     SIZE = 18
 
     def __init__(self, raw_data, sample_time):
-        self.values = struct.unpack('>4H2h2H2B', raw_data)
+        self.values = struct.unpack('>8H2B', raw_data)
         self._sample_time = sample_time
 
     def __getitem__(self, channel_and_reading_granularity):
diff --git a/acts/framework/acts/controllers/monsoon_lib/sampling/hvpm/transformers.py b/acts/framework/acts/controllers/monsoon_lib/sampling/hvpm/transformers.py
index e91a89b..5ddc23c 100644
--- a/acts/framework/acts/controllers/monsoon_lib/sampling/hvpm/transformers.py
+++ b/acts/framework/acts/controllers/monsoon_lib/sampling/hvpm/transformers.py
@@ -438,10 +438,10 @@
                 zero_offset += cal_zero
                 if cal_ref - zero_offset != 0:
                     slope = scale / (cal_ref - zero_offset)
-                    if granularity == Granularity.FINE:
-                        slope /= 1000
                 else:
                     slope = 0
+                if granularity == Granularity.FINE:
+                    slope /= 1000
 
                 index = HvpmMeasurement.get_index(channel, granularity)
                 calibrated_value[:, granularity] = slope * (
@@ -452,7 +452,7 @@
             readings[:, channel] = np.where(
                 measurements[:, fine_data_position] < self.fine_threshold,
                 calibrated_value[:, Granularity.FINE],
-                calibrated_value[:, Granularity.COARSE])
+                calibrated_value[:, Granularity.COARSE]) / 1000.0  # to mA
 
         main_voltage_index = HvpmMeasurement.get_index(Channel.MAIN,
                                                        Reading.VOLTAGE)
diff --git a/acts/framework/acts/controllers/monsoon_lib/sampling/lvpm_stock/packet.py b/acts/framework/acts/controllers/monsoon_lib/sampling/lvpm_stock/packet.py
index 80c8274..b0f8839 100644
--- a/acts/framework/acts/controllers/monsoon_lib/sampling/lvpm_stock/packet.py
+++ b/acts/framework/acts/controllers/monsoon_lib/sampling/lvpm_stock/packet.py
@@ -54,9 +54,9 @@
     Val │  Byte  │  Type  │ Monsoon │ Reading │
     Pos │ Offset │ Format │ Channel │  Type   │ Description
     ────┼────────┼────────┼─────────┼─────────┼──────────────────────────────
-     0  │   0    │ uint16 │  Main   │ Current │ Calibration value.
-     1  │   2    │ uint16 │  USB    │ Current │ Calibration value.
-     2  │   4    │ uint16 │  Aux    │ Current │ Calibration value.
+     0  │   0    │  int16 │  Main   │ Current │ Calibration value.
+     1  │   2    │  int16 │  USB    │ Current │ Calibration value.
+     2  │   4    │  int16 │  Aux    │ Current │ Calibration value.
      3  │   6    │ uint16 │  Main   │ Voltage │ Calibration value.
 
     If the measurement is a power reading:
@@ -64,11 +64,11 @@
     Val │  Byte  │  Type  │ Monsoon │ Reading │
     Pos │ Offset │ Format │ Channel │  Type   │ Description
     ────┼────────┼────────┼─────────┼─────────┼──────────────────────────────
-     0  │   0    │ uint16 │  Main   │ Current │ b0: if 1, Coarse, else Fine
+     0  │   0    │  int16 │  Main   │ Current │ b0: if 1, Coarse, else Fine
         │        │        │         │         │ b1-7: Measurement value.
-     1  │   2    │ uint16 │  USB    │ Current │ b0: if 1, Coarse, else Fine
+     1  │   2    │  int16 │  USB    │ Current │ b0: if 1, Coarse, else Fine
         │        │        │         │         │ b1-7: Measurement value.
-     2  │   4    │ uint16 │  Aux    │ Current │ b0: if 1, Coarse, else Fine
+     2  │   4    │  int16 │  Aux    │ Current │ b0: if 1, Coarse, else Fine
         │        │        │         │         │ b1-7: Measurement value.
      3  │   6    │ uint16 │  Main   │ Voltage │ Measurement value.
 
@@ -86,7 +86,7 @@
             sample_type: The type of sample that was recorded.
             entry_index: The index of the measurement within the packet.
         """
-        self.values = struct.unpack('>4H', raw_data)
+        self.values = struct.unpack('>3hH', raw_data)
         self._sample_time = sample_time
         self._sample_type = sample_type
 
diff --git a/acts/framework/acts/controllers/monsoon_lib/sampling/lvpm_stock/stock_transformers.py b/acts/framework/acts/controllers/monsoon_lib/sampling/lvpm_stock/stock_transformers.py
index eaf60b0..becc4ee 100644
--- a/acts/framework/acts/controllers/monsoon_lib/sampling/lvpm_stock/stock_transformers.py
+++ b/acts/framework/acts/controllers/monsoon_lib/sampling/lvpm_stock/stock_transformers.py
@@ -340,32 +340,6 @@
             return False
         return True
 
-    @staticmethod
-    def _get_currents(sample, calibration_data):
-        """Returns the list of current values for each channel.
-
-        Args:
-            sample: The Sample object to determine the current values of.
-            calibration_data: The CalibrationCollection used to calibrate the
-                sample.
-
-        Returns:
-
-        """
-        currents = [0] * 3
-        for channel in Channel.values:
-            current = sample[channel]
-            granularity = Granularity.FINE
-            if current & 1:
-                current &= ~1
-                granularity = Granularity.COARSE
-
-            zero = calibration_data.get(channel, Origin.ZERO, granularity)
-            scale = calibration_data.get(channel, Origin.SCALE, granularity)
-            currents[channel] = (current - zero) * scale
-
-        return currents
-
     def _transform_buffer(self, buffer):
         calibration_data = buffer.calibration_data
 
@@ -393,7 +367,7 @@
             # Monsoon.py algorithm.
             readings[:, channel] = np.where(
                 measurements[:, channel] & 1,
-                (measurements[:, channel] - 1 - coarse_zero) * coarse_scale,
+                ((measurements[:, channel] & ~1) - coarse_zero) * coarse_scale,
                 (measurements[:, channel] - fine_zero) * fine_scale)
 
         for i in range(len(buffer.samples)):
diff --git a/acts/framework/acts/controllers/rohdeschwarz_lib/cmw500_cellular_simulator.py b/acts/framework/acts/controllers/rohdeschwarz_lib/cmw500_cellular_simulator.py
new file mode 100644
index 0000000..6c76e62
--- /dev/null
+++ b/acts/framework/acts/controllers/rohdeschwarz_lib/cmw500_cellular_simulator.py
@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+#
+#   Copyright 2019 - 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.rohdeschwarz_lib import cmw500
+from acts.controllers import cellular_simulator as cc
+
+
+class CMW500CellularSimulator:
+    """ A cellular simulator for telephony simulations based on the CMW 500
+    controller. """
+
+    # Indicates if it is able to use 256 QAM as the downlink modulation for LTE
+    LTE_SUPPORTS_DL_256QAM = None
+
+    # Indicates if it is able to use 64 QAM as the uplink modulation for LTE
+    LTE_SUPPORTS_UL_64QAM = None
+
+    # Indicates if 4x4 MIMO is supported for LTE
+    LTE_SUPPORTS_4X4_MIMO = None
+
+    # The maximum number of carriers that this simulator can support for LTE
+    LTE_MAX_CARRIERS = None
+
+    def __init__(self, ip_address, port):
+        """ Initializes the cellular simulator.
+
+        Args:
+            ip_address: the ip address of the CMW500
+            port: the port number for the CMW500 controller
+        """
+        try:
+            self.cmw = cmw500.Cmw500(ip_address, port)
+        except cmw500.CmwError:
+            raise cc.CellularSimulatorError('Could not connect to CMW500.')
+
+    def destroy(self):
+        """ Sends finalization commands to the cellular equipment and closes
+        the connection. """
+        raise NotImplementedError()
+
+    def setup_lte_scenario(self):
+        """ Configures the equipment for an LTE simulation. """
+        raise NotImplementedError()
+
+    def setup_lte_ca_scenario(self):
+        """ Configures the equipment for an LTE with CA simulation. """
+        raise NotImplementedError()
+
+    def set_band(self, bts_index, band):
+        """ Sets the band for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            band: the new band
+        """
+        raise NotImplementedError()
+
+    def set_input_power(self, bts_index, input_power):
+        """ Sets the input power for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            input_power: the new input power
+        """
+        raise NotImplementedError()
+
+    def set_output_power(self, bts_index, output_power):
+        """ Sets the output power for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            output_power: the new output power
+        """
+        raise NotImplementedError()
+
+    def set_tdd_config(self, bts_index, tdd_config):
+        """ Sets the tdd configuration number for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            tdd_config: the new tdd configuration number
+        """
+        raise NotImplementedError()
+
+    def set_bandwidth(self, bts_index, bandwidth):
+        """ Sets the bandwidth for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            bandwidth: the new bandwidth
+        """
+        raise NotImplementedError()
+
+    def set_downlink_channel_number(self, bts_index, channel_number):
+        """ Sets the downlink channel number for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            channel_number: the new channel number
+        """
+        raise NotImplementedError()
+
+    def set_mimo_mode(self, bts_index, mimo_mode):
+        """ Sets the mimo mode for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            mimo_mode: the new mimo mode
+        """
+        raise NotImplementedError()
+
+    def set_transmission_mode(self, bts_index, transmission_mode):
+        """ Sets the transmission mode for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            transmission_mode: the new transmission mode
+        """
+        raise NotImplementedError()
+
+    def set_scheduling_mode(self, bts_index, scheduling_mode, mcs_dl, mcs_ul,
+                            nrb_dl, nrb_ul):
+        """ Sets the scheduling mode for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            scheduling_mode: the new scheduling mode
+            mcs_dl: Downlink MCS (only for STATIC scheduling)
+            mcs_ul: Uplink MCS (only for STATIC scheduling)
+            nrb_dl: Number of RBs for downlink (only for STATIC scheduling)
+            nrb_ul: Number of RBs for uplink (only for STATIC scheduling)
+        """
+        raise NotImplementedError()
+
+    def set_enabled_for_ca(self, bts_index, enabled):
+        """ Enables or disables the base station during carrier aggregation.
+
+        Args:
+            bts_index: the base station number
+            enabled: whether the base station should be enabled for ca.
+        """
+        raise NotImplementedError()
+
+    def set_dl_modulation(self, bts_index, modulation):
+        """ Sets the DL modulation for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            modulation: the new DL modulation
+        """
+        raise NotImplementedError()
+
+    def set_ul_modulation(self, bts_index, modulation):
+        """ Sets the UL modulation for the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            modulation: the new UL modulation
+        """
+        raise NotImplementedError()
+
+    def set_tbs_pattern_on(self, bts_index, tbs_pattern_on):
+        """ Enables or disables TBS pattern in the indicated base station.
+
+        Args:
+            bts_index: the base station number
+            tbs_pattern_on: the new TBS pattern setting
+        """
+        raise NotImplementedError()
+
+    def lte_attach_secondary_carriers(self):
+        """ Activates the secondary carriers for CA. Requires the DUT to be
+        attached to the primary carrier first. """
+        raise NotImplementedError()
+
+    def wait_until_attached(self, timeout=120):
+        """ Waits until the DUT is attached to the primary carrier.
+
+        Args:
+            timeout: after this amount of time the method will raise a
+                CellularSimulatorError exception. Default is 120 seconds.
+        """
+        raise NotImplementedError()
+
+    def wait_until_communication_state(self, timeout=120):
+        """ Waits until the DUT is in Communication state.
+
+        Args:
+            timeout: after this amount of time the method will raise a
+                CellularSimulatorError exception. Default is 120 seconds.
+        """
+        raise NotImplementedError()
+
+    def wait_until_idle_state(self, timeout=120):
+        """ Waits until the DUT is in Idle state.
+
+        Args:
+            timeout: after this amount of time the method will raise a
+                CellularSimulatorError exception. Default is 120 seconds.
+        """
+        raise NotImplementedError()
+
+    def detach(self):
+        """ Turns off all the base stations so the DUT loose connection."""
+        raise NotImplementedError()
+
+    def stop(self):
+        """ Stops current simulation. After calling this method, the simulator
+        will need to be set up again. """
+        raise NotImplementedError()
+
+    def start_data_traffic(self):
+        """ Starts transmitting data from the instrument to the DUT. """
+        raise NotImplementedError()
+
+    def stop_data_traffic(self):
+        """ Stops transmitting data from the instrument to the DUT. """
+        raise NotImplementedError()
diff --git a/acts/framework/acts/controllers/rohdeschwarz_lib/contest.py b/acts/framework/acts/controllers/rohdeschwarz_lib/contest.py
index 7d6c790..f34a62b 100644
--- a/acts/framework/acts/controllers/rohdeschwarz_lib/contest.py
+++ b/acts/framework/acts/controllers/rohdeschwarz_lib/contest.py
@@ -47,7 +47,7 @@
     MAXIMUM_OUTPUT_READ_RETRIES = 25
 
     # Root directory for the FTP server in the remote computer
-    FTP_ROOT = 'D:\\Contest\\Reports\\reports\\'
+    FTP_ROOT = 'D:\\Logs\\'
 
     def __init__(self, logger, remote_ip, remote_port, automation_listen_ip,
                  automation_port, dut_on_func, dut_off_func, ftp_usr, ftp_pwd):
@@ -212,6 +212,9 @@
              a JSON object containing the test results
         """
 
+        if not testplan_directory:
+            raise ValueError('Invalid testplan directory.')
+
         # Download test reports from the remote host
         job.run('wget -r --user={} --password={} -P {} ftp://{}/{}'.format(
             self.ftp_user, self.ftp_pass, logging.log_path,
@@ -387,14 +390,17 @@
                               "DUT to off state.")
                 self.dut_off_func()
                 self.send_ok()
+            elif command.startswith(self.NOTIFICATION_TESTPLAN_START):
+                self.log.info('Test plan is starting.')
+                self.send_ok()
             elif command.startswith(self.NOTIFICATION_TESTCASE_START):
                 self.log.info('Test case is starting.')
                 self.send_ok()
-            elif command in [
-                self.NOTIFICATION_TESTPLAN_START,
-                self.NOTIFICATION_TESCASE_END,
-                self.NOTIFICATION_TESTPLAN_END
-            ]:
+            elif command.startswith(self.NOTIFICATION_TESCASE_END):
+                self.log.info('Test case finished.')
+                self.send_ok()
+            elif command.startswith(self.NOTIFICATION_TESTPLAN_END):
+                self.log.info('Test plan finished.')
                 self.send_ok()
             else:
                 self.log.error('Unhandled automation command: ' + command)
diff --git a/acts/framework/acts/metrics/loggers/blackbox.py b/acts/framework/acts/metrics/loggers/blackbox.py
index 0e33164..8d7aeca 100644
--- a/acts/framework/acts/metrics/loggers/blackbox.py
+++ b/acts/framework/acts/metrics/loggers/blackbox.py
@@ -14,12 +14,15 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
+import shutil
+
 from acts.metrics.core import ProtoMetric
 from acts.metrics.logger import MetricLogger
 
 
-class BlackboxMetricLogger(MetricLogger):
-    """A MetricLogger for logging and publishing Blackbox metrics.
+class BlackboxMappedMetricLogger(MetricLogger):
+    """A MetricLogger for logging and publishing Blackbox metrics from a dict.
+    The dict maps the metric name to the metric value.
 
     The logger will publish an ActsBlackboxMetricResult message, containing
     data intended to be uploaded to Blackbox. The message itself contains only
@@ -32,47 +35,68 @@
 
     Attributes:
         proto_module: The proto module for ActsBlackboxMetricResult.
-        metric_name: The name of the metric, used to determine output filename.
         metric_key: The metric key to use. If unset, the logger will use the
                     context's identifier.
-        metric_value: The metric value.
+        _metric_map: the map of metric_name -> metric_value to publish
+                to blackbox. If the metric value is set to None, the
+                metric will not be reported.
     """
 
     PROTO_FILE = 'protos/acts_blackbox.proto'
 
-    def __init__(self, metric_name, metric_key=None, event=None):
+    def __init__(self, metric_key=None, event=None, compiler_out=None):
         """Initializes a logger for Blackbox metrics.
 
         Args:
-            metric_name: The name of the metric.
             metric_key: The metric key to use. If unset, the logger will use
                         the context's identifier.
             event: The event triggering the creation of this logger.
+            compiler_out: The directory to store the compiled proto module.
         """
         super().__init__(event=event)
-        self.proto_module = self._compile_proto(self.PROTO_FILE)
-        if not metric_name:
-            raise ValueError("metric_name must be supplied.")
-        self.metric_name = metric_name
+        self.proto_module = self._compile_proto(self.PROTO_FILE,
+                                                compiler_out=compiler_out)
         self.metric_key = metric_key
-        self.metric_value = None
+        self._metric_map = {}
 
-    def _get_metric_key(self):
+    def _get_metric_key(self, metric_name):
         """Gets the metric key to use.
 
         If the metric_key is explicitly set, returns that value. Otherwise,
         extracts an identifier from the context.
+
+        Args:
+            metric_name: The name of the metric to report.
         """
         if self.metric_key:
             key = self.metric_key
         else:
             key = self._get_blackbox_identifier()
-        key = '%s.%s' % (key, self.metric_name)
+        key = '%s.%s' % (key, metric_name)
         return key
 
-    def _get_file_name(self):
-        """Gets the base file name to publish to."""
-        return 'blackbox_%s' % self.metric_name
+    def set_metric_data(self, metric_map):
+        """Sets the map of metrics to be uploaded to Blackbox. Note that
+        this will overwrite all existing added by this function or add_metric.
+
+        Args:
+            metric_map: the map of metric_name -> metric_value to publish
+                to blackbox. If the metric value is set to None, the
+                metric will not be reported.
+        """
+        self._metric_map = metric_map
+
+    def add_metric(self, metric_name, metric_value):
+        """Adds a metric value to be published later.
+
+        Note that if the metric name has already been added, the metric value
+        will be overwritten.
+
+        Args:
+            metric_name: the name of the metric.
+            metric_value: the value of the metric.
+        """
+        self._metric_map[metric_name] = metric_value
 
     def _get_blackbox_identifier(self):
         """Returns the testcase identifier, as expected by Blackbox."""
@@ -82,20 +106,63 @@
         parts = identifier.rsplit('.', 1)
         return '#'.join(parts)
 
-    def end(self, event):
+    def end(self, _):
         """Creates and publishes a ProtoMetric with blackbox data.
 
-        Builds an ActsBlackboxMetricResult message based on the result
-        generated, and passes it off to the publisher.
+        Builds a list of ActsBlackboxMetricResult messages from the set
+        metric data, and sends them to the publisher.
+        """
+        metrics = []
+        for metric_name, metric_value in self._metric_map.items():
+            if metric_value is None:
+                continue
+            result = self.proto_module.ActsBlackboxMetricResult()
+            result.test_identifier = self._get_blackbox_identifier()
+            result.metric_key = self._get_metric_key(metric_name)
+            result.metric_value = metric_value
+
+            metrics.append(
+                ProtoMetric(name='blackbox_%s' % metric_name, data=result))
+
+        return self.publisher.publish(metrics)
+
+
+class BlackboxMetricLogger(BlackboxMappedMetricLogger):
+    """A MetricLogger for logging and publishing individual Blackbox metrics.
+
+    For additional information on reporting to Blackbox, see
+    BlackboxMappedMetricLogger.
+
+    Attributes:
+        proto_module: The proto module for ActsBlackboxMetricResult.
+        metric_name: The name of the metric, used to determine output filename.
+        metric_key: The metric key to use. If unset, the logger will use the
+                    context's identifier.
+        metric_value: The metric value.
+    """
+
+    def __init__(self, metric_name, metric_key=None, event=None,
+                 compiler_out=None):
+        """Initializes a logger for Blackbox metrics.
 
         Args:
-            event: The triggering event.
+            metric_name: The name of the metric.
+            metric_key: The metric key to use. If unset, the logger will use
+                        the context's identifier.
+            event: The event triggering the creation of this logger.
+            compiler_out: The directory to store the compiled proto module
         """
-        result = self.proto_module.ActsBlackboxMetricResult()
-        result.test_identifier = self._get_blackbox_identifier()
-        result.metric_key = self._get_metric_key()
-        if self.metric_value is not None:
-            result.metric_value = self.metric_value
+        super().__init__(metric_key=metric_key, event=event,
+                         compiler_out=compiler_out)
+        if not metric_name:
+            raise ValueError("metric_name must be supplied.")
+        self.metric_name = metric_name
+        self.metric_value = None
 
-        metric = ProtoMetric(name=self._get_file_name(), data=result)
-        return self.publisher.publish(metric)
+    @property
+    def metric_value(self):
+        return self._metric_map[self.metric_name]
+
+    @metric_value.setter
+    def metric_value(self, value):
+        self.add_metric(self.metric_name, value)
diff --git a/acts/framework/acts/test_utils/bt/BluetoothBaseTest.py b/acts/framework/acts/test_utils/bt/BluetoothBaseTest.py
index ec34b04..d6bcd05 100644
--- a/acts/framework/acts/test_utils/bt/BluetoothBaseTest.py
+++ b/acts/framework/acts/test_utils/bt/BluetoothBaseTest.py
@@ -49,18 +49,6 @@
     start_time = 0
     timer_list = []
 
-    def __init__(self, controllers):
-        BaseTestClass.__init__(self, controllers)
-        for ad in self.android_devices:
-            self._setup_bt_libs(ad)
-        if 'preferred_device_order' in self.user_params:
-            prefered_device_order = self.user_params['preferred_device_order']
-            for i, ad in enumerate(self.android_devices):
-                if ad.serial in prefered_device_order:
-                    index = prefered_device_order.index(ad.serial)
-                    self.android_devices[i], self.android_devices[index] = \
-                        self.android_devices[index], self.android_devices[i]
-
     def collect_bluetooth_manager_metrics_logs(self, ads, test_name):
         """
         Collect Bluetooth metrics logs, save an ascii log to disk and return
@@ -131,6 +119,17 @@
         return _safe_wrap_test_case
 
     def setup_class(self):
+        super().setup_class()
+        for ad in self.android_devices:
+            self._setup_bt_libs(ad)
+        if 'preferred_device_order' in self.user_params:
+            prefered_device_order = self.user_params['preferred_device_order']
+            for i, ad in enumerate(self.android_devices):
+                if ad.serial in prefered_device_order:
+                    index = prefered_device_order.index(ad.serial)
+                    self.android_devices[i], self.android_devices[index] = \
+                        self.android_devices[index], self.android_devices[i]
+
         if "reboot_between_test_class" in self.user_params:
             threads = []
             for a in self.android_devices:
diff --git a/acts/framework/acts/test_utils/bt/pts/pts_base_class.py b/acts/framework/acts/test_utils/bt/pts/pts_base_class.py
index 32f8b1b..33fa81b 100644
--- a/acts/framework/acts/test_utils/bt/pts/pts_base_class.py
+++ b/acts/framework/acts/test_utils/bt/pts/pts_base_class.py
@@ -46,8 +46,8 @@
     scan_timeout_seconds = 10
     peer_identifier = None
 
-    def __init__(self, controllers):
-        BaseTestClass.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         if 'dut' in self.user_params:
             if self.user_params['dut'] == 'fuchsia_devices':
                 self.dut = create_bluetooth_device(self.fuchsia_devices[0])
@@ -122,7 +122,6 @@
             }
         }
 
-    def setup_class(self):
         self.pts.setup_pts()
         self.pts.bind_to(self.process_next_action)
 
diff --git a/acts/framework/acts/test_utils/coex/audio_capture.py b/acts/framework/acts/test_utils/coex/audio_capture.py
index 7e011f1..bb29dcc 100644
--- a/acts/framework/acts/test_utils/coex/audio_capture.py
+++ b/acts/framework/acts/test_utils/coex/audio_capture.py
@@ -27,6 +27,9 @@
 class DeviceNotFound(Exception):
     """Raises exception if audio capture device is not found."""
 
+# TODO: (@sairamganesh) This class will be deprecated for
+# ../acts/test_utils/coex/audio_capture_device.py
+
 
 class AudioCapture:
 
diff --git a/acts/framework/acts/test_utils/coex/audio_capture_device.py b/acts/framework/acts/test_utils/coex/audio_capture_device.py
new file mode 100644
index 0000000..7f32030
--- /dev/null
+++ b/acts/framework/acts/test_utils/coex/audio_capture_device.py
@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+#
+#   Copyright 2019 - 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 logging
+import os
+import pyaudio
+import wave
+
+from acts import context
+from acts import utils
+
+
+WAVE_FILE_TEMPLATE = 'recorded_audio_%s.wav'
+ADB_PATH = 'sdcard/Music/'
+ADB_FILE = 'rec.pcm'
+
+
+class AudioCaptureBase(object):
+    """Base class for Audio capture."""
+
+    def __init__(self):
+
+        self.wave_file = os.path.join(self.log_path, WAVE_FILE_TEMPLATE)
+        self.file_dir = self.log_path
+
+    @property
+    def log_path(self):
+        """Returns current log path."""
+        current_context = context.get_current_context()
+        full_out_dir = os.path.join(current_context.get_full_output_path(),
+                                    'AudioCapture')
+
+        utils.create_dir(full_out_dir)
+        return full_out_dir
+
+    @property
+    def next_fileno(self):
+        counter = 0
+        while os.path.exists(self.wave_file % counter):
+            counter += 1
+        return counter
+
+    @property
+    def last_fileno(self):
+        return self.next_fileno - 1
+
+    def write_record_file(self, audio_params, frames):
+        """Writes the recorded audio into the file.
+
+        Args:
+            audio_params: A dict with audio configuration.
+            frames: Recorded audio frames.
+
+        Returns:
+            file_name: wave file name.
+        """
+        file_name = self.wave_file % self.next_fileno
+        logging.debug('writing to %s' % file_name)
+        wf = wave.open(file_name, 'wb')
+        wf.setnchannels(audio_params['channel'])
+        wf.setsampwidth(audio_params['sample_width'])
+        wf.setframerate(audio_params['sample_rate'])
+        wf.writeframes(frames)
+        wf.close()
+        return file_name
+
+
+class CaptureAudioOverAdb(AudioCaptureBase):
+    """Class to capture audio over android device which acts as the
+    a2dp sink or hfp client. This captures the digital audio and converts
+    to analog audio for post processing.
+    """
+
+    def __init__(self, ad, audio_params):
+        """Initializes CaptureAudioOverAdb.
+
+        Args:
+            ad: An android device object.
+            audio_params: Dict containing audio record settings.
+        """
+        super().__init__()
+        self._ad = ad
+        self.audio_params = audio_params
+        self.adb_path = None
+
+    def start(self):
+        """Start the audio capture over adb."""
+        self.adb_path = os.path.join(ADB_PATH, ADB_FILE)
+        cmd = 'ap2f --usage 1 --start --duration {} --target {}'.format(
+            self.audio_params['duration'], self.adb_path,
+        )
+        self._ad.adb.shell(cmd)
+
+    def stop(self):
+        """Stops the audio capture and stores it in wave file.
+
+        Returns:
+            File name of the recorded file.
+        """
+        cmd = '{} {}'.format(self.adb_path, self.file_dir)
+        self._ad.adb.pull(cmd)
+        self._ad.adb.shell('rm {}'.format(self.adb_path))
+        return self._convert_pcm_to_wav()
+
+    def _convert_pcm_to_wav(self):
+        """Converts raw pcm data into wave file.
+
+        Returns:
+            file_path: Returns the file path of the converted file
+            (digital to analog).
+        """
+        file_to_read = os.path.join(self.file_dir, ADB_FILE)
+        with open(file_to_read, 'rb') as pcm_file:
+            frames = pcm_file.read()
+        file_path = self.write_record_file(self.audio_params, frames)
+        return file_path
+
+
+class CaptureAudioOverLocal(AudioCaptureBase):
+    """Class to capture audio on local server using the audio input devices
+    such as iMic/AudioBox. This class mandates input deivce to be connected to
+    the machine.
+    """
+    def __init__(self, audio_params):
+        """Initializes CaptureAudioOverLocal.
+
+        Args:
+            audio_params: Dict containing audio record settings.
+        """
+        super().__init__()
+        self.audio_params = audio_params
+        self.channels = self.audio_params['channel']
+        self.chunk = self.audio_params['chunk']
+        self.sample_rate = self.audio_params['sample_rate']
+        self.__input_device = None
+        self.audio = None
+        self.frames = []
+
+    @property
+    def name(self):
+        return self.__input_device["name"]
+
+    def __get_input_device(self):
+        """Checks for the audio capture device."""
+        if self.__input_device is None:
+            for i in range(self.audio.get_device_count()):
+                device_info = self.audio.get_device_info_by_index(i)
+                logging.debug('Device Information: {}'.format(device_info))
+                if self.audio_params['input_device'] in device_info['name']:
+                    self.__input_device = device_info
+                    break
+            else:
+                raise DeviceNotFound(
+                    'Audio Capture device {} not found.'.format(
+                        self.audio_params['input_device']))
+        return self.__input_device
+
+    def start(self, trim_beginning=0, trim_end=0):
+        """Starts audio recording on host machine.
+
+        Args:
+            trim_beginning: how many seconds to trim from the beginning
+            trim_end: how many seconds to trim from the end
+        """
+        self.audio = pyaudio.PyAudio()
+        self.__input_device = self.__get_input_device()
+        stream = self.audio.open(
+            format=pyaudio.paInt16,
+            channels=self.channels,
+            rate=self.sample_rate,
+            input=True,
+            frames_per_buffer=self.chunk,
+            input_device_index=self.__input_device['index'])
+        b_chunks = trim_beginning * (self.sample_rate // self.chunk)
+        e_chunks = trim_end * (self.sample_rate // self.chunk)
+        total_chunks = self.sample_rate // self.chunk * self.audio_params[
+            'duration']
+        for i in range(total_chunks):
+            try:
+                data = stream.read(self.chunk, exception_on_overflow=False)
+            except IOError as ex:
+                logging.error('Cannot record audio: {}'.format(ex))
+                return False
+            if b_chunks <= i < total_chunks - e_chunks:
+                self.frames.append(data)
+
+        stream.stop_stream()
+        stream.close()
+
+    def stop(self):
+        """Terminates the pulse audio instance.
+
+        Returns:
+            File name of the recorded audio file.
+        """
+        self.audio.terminate()
+        frames = b''.join(self.frames)
+        return self.write_record_file(self.audio_params, frames)
+
+
+class DeviceNotFound(Exception):
+    """Raises exception if audio capture device is not found."""
diff --git a/acts/framework/acts/test_utils/coex/audio_test_utils.py b/acts/framework/acts/test_utils/coex/audio_test_utils.py
index efee428..0fca41a 100644
--- a/acts/framework/acts/test_utils/coex/audio_test_utils.py
+++ b/acts/framework/acts/test_utils/coex/audio_test_utils.py
@@ -18,6 +18,8 @@
 import os
 import wave
 
+from acts.test_utils.coex.audio_capture_device import CaptureAudioOverAdb
+from acts.test_utils.coex.audio_capture_device import CaptureAudioOverLocal
 from acts.controllers.utils_lib.ssh import connection
 from acts.controllers.utils_lib.ssh import settings
 from acts.test_utils.audio_analysis_lib import audio_analysis
@@ -32,9 +34,47 @@
 bits_per_sample = 32
 
 
+def get_audio_capture_device(test_class_instance):
+    """Gets the device object of the audio capture device connected to server.
+
+    The audio capture device returned is specified by the audio_params
+    within user_params. audio_params must specify a "type" field, that
+    is either "AndroidDevice" or "Local"
+
+    Args:
+        test_class_instance: object self of test class.
+
+    Returns:
+        Object of the audio capture device.
+
+    Raises:
+        ValueError if audio_params['type'] is not "AndroidDevice" or
+            "Local".
+        ValueError if "AndroidDevice" is specified, but there is only one
+            AndroidDevice within the testbed.
+    """
+    audio_params = test_class_instance.user_params.get('audio_params')
+
+    if audio_params['type'] == 'AndroidDevice':
+        if len(test_class_instance.android_devices) > 1:
+            return CaptureAudioOverAdb(
+                test_class_instance.android_devices[-1], audio_params)
+        else:
+            raise ValueError('At least 2 or more AndroidDevice should be '
+                             'specified to use as audio capture endpoint.')
+    elif audio_params['type'] == 'Local':
+        return CaptureAudioOverLocal(audio_params)
+    else:
+        raise ValueError('Unrecognized audio capture device '
+                         '%s' % audio_params['type'])
+
+
 class FileNotFound(Exception):
     """Raises Exception if file is not present"""
 
+# TODO @sairamganesh Rename this class to AudioCaptureResult and
+# remove duplicates which are in ../test_utils/coex/audio_capture_device.py.
+
 
 class SshAudioCapture(AudioCapture):
 
diff --git a/acts/framework/acts/test_utils/gnss/gnss_test_utils.py b/acts/framework/acts/test_utils/gnss/gnss_test_utils.py
index 16285c2..2b4e6f3 100644
--- a/acts/framework/acts/test_utils/gnss/gnss_test_utils.py
+++ b/acts/framework/acts/test_utils/gnss/gnss_test_utils.py
@@ -42,6 +42,15 @@
     "TTFF_REPORT", "ttff_loop ttff_sec ttff_pe ttff_cn")
 TRACK_REPORT = collections.namedtuple(
     "TRACK_REPORT", "track_l5flag track_pe track_top4cn track_cn")
+LOCAL_PROP_FILE_CONTENTS =  """\
+log.tag.LocationManagerService=VERBOSE
+log.tag.GnssLocationProvider=VERBOSE
+log.tag.GnssMeasurementsProvider=VERBOSE
+log.tag.GpsNetInitiatedHandler=VERBOSE
+log.tag.GnssNetworkConnectivityHandler=VERBOSE
+log.tag.ConnectivityService=VERBOSE
+log.tag.ConnectivityManager=VERBOSE
+log.tag.GnssVisibilityControl=VERBOSE"""
 
 
 class GnssTestUtilsError(Exception):
@@ -88,11 +97,7 @@
     remount_device(ad)
     ad.log.info("Enable GNSS VERBOSE Logging and persistent logcat.")
     ad.adb.shell("echo DEBUG_LEVEL = 5 >> /vendor/etc/gps.conf")
-    ad.adb.shell("echo log.tag.LocationManagerService=VERBOSE >> /data/local.prop")
-    ad.adb.shell("echo log.tag.GnssLocationProvider=VERBOSE >> /data/local.prop")
-    ad.adb.shell("echo log.tag.GnssMeasurementsProvider=VERBOSE >> /data/local.prop")
-    ad.adb.shell("echo log.tag.GpsNetInitiatedHandler=VERBOSE >> /data/local.prop")
-    ad.adb.shell("echo log.tag.GnssNetworkConnectivityHandler=VERBOSE >> /data/local.prop")
+    ad.adb.shell("echo %r >> /data/local.prop" % LOCAL_PROP_FILE_CONTENTS)
     ad.adb.shell("chmod 644 /data/local.prop")
     ad.adb.shell("setprop persist.logd.size 16777216")
     ad.adb.shell("setprop persist.vendor.radio.adb_log_on 1")
@@ -284,7 +289,8 @@
     shutil.make_archive(gnss_log_path, "zip", gnss_log_path)
     shutil.rmtree(gnss_log_path)
     output_path = os.path.join(DEFAULT_QXDM_LOG_PATH, "logs/.")
-    file_count = ad.adb.shell("find %s -type f -iname *.qmdl | wc -l" % output_path)
+    file_count = ad.adb.shell(
+        "find %s -type f -iname *.qmdl | wc -l" % output_path)
     if not int(file_count) == 0:
         qxdm_log_name = "QXDM_%s_%s" % (ad.model, ad.serial)
         qxdm_log_path = os.path.join(log_path, qxdm_log_name)
@@ -328,7 +334,8 @@
         ad.log.error("Mobile data is at unknown state and set to %d" % out)
 
 def gnss_trigger_modem_ssr(ad, dwelltime=60):
-    """Trigger modem SSR crash and verify if modem crash and recover successfully.
+    """Trigger modem SSR crash and verify if modem crash and recover
+    successfully.
 
     Args:
         ad: An AndroidDevice object.
@@ -415,7 +422,6 @@
     remount_device(ad)
     pull_gtw_gpstool(ad)
     ad.adb.shell("settings put global verifier_verify_adb_installs 0")
-    ad.adb.shell("settings put global package_verifier_enable 0")
     reinstall_gtw_gpstool(ad)
 
 def fastboot_factory_reset(ad):
@@ -466,7 +472,6 @@
                 break
             ad.log.info("Re-install sl4a")
             ad.adb.shell("settings put global verifier_verify_adb_installs 0")
-            ad.adb.shell("settings put global package_verifier_enable 0")
             ad.adb.install("-r -g -t /tmp/base.apk")
             reinstall_gtw_gpstool(ad)
             time.sleep(10)
@@ -532,7 +537,8 @@
     for i in range(retries):
         begin_time = get_current_epoch_time()
         clear_aiding_data_by_gtw_gpstool(ad)
-        ad.log.info("Start %s on GTW_GPSTool - attempt %d" % (type.upper(), i+1))
+        ad.log.info("Start %s on GTW_GPSTool - attempt %d" % (type.upper(),
+                                                              i+1))
         start_gnss_by_gtw_gpstool(ad, True, type)
         for _ in range(10 + criteria):
             logcat_results = ad.search_logcat("First fixed", begin_time)
@@ -544,16 +550,16 @@
                 if (first_fixed/1000) <= criteria:
                     return True
                 start_gnss_by_gtw_gpstool(ad, False, type)
-                raise signals.TestFailure("Fail to get %s location fixed within "
-                                          "%d seconds criteria." %
-                                          (type.upper(), criteria))
+                raise signals.TestFailure("Fail to get %s location fixed "
+                                          "within %d seconds criteria."
+                                          % (type.upper(), criteria))
             time.sleep(1)
         if not ad.is_adb_logcat_on:
             ad.start_adb_logcat()
         check_currrent_focus_app(ad)
         start_gnss_by_gtw_gpstool(ad, False, type)
-    raise signals.TestFailure("Fail to get %s location fixed within %d attempts."
-                              % (type.upper(), retries))
+    raise signals.TestFailure("Fail to get %s location fixed within %d "
+                              "attempts." % (type.upper(), retries))
 
 def start_ttff_by_gtw_gpstool(ad, ttff_mode, iteration):
     """Identify which TTFF mode for different test items.
@@ -578,9 +584,9 @@
                             begin_time):
             ad.log.info("Send TTFF start_test_action successfully.")
             break
-        if i == 3:
-            check_currrent_focus_app(ad)
-            raise signals.TestFailure("Fail to send TTFF start_test_action.")
+    else:
+        check_currrent_focus_app(ad)
+        raise signals.TestFailure("Fail to send TTFF start_test_action.")
 
 def gnss_tracking_via_gtw_gpstool(ad, criteria, type="gnss", testtime=60):
     """Start GNSS/FLP tracking tests for input testtime on GTW_GPSTool.
@@ -621,6 +627,7 @@
     track_data = {}
     history_top4_cn = 0
     history_cn = 0
+    l5flag = "false"
     file_count = int(ad.adb.shell("find %s -type f -iname *.txt | wc -l"
                                   % GNSSSTATUS_LOG_PATH))
     if file_count != 1:
@@ -777,7 +784,8 @@
     elif any(float(ttff_data[key].ttff_sec) == 0.0 for key in ttff_data.keys()):
         ad.log.error("One or more TTFF %s Timeout" % ttff_mode)
         return False
-    elif any(float(ttff_data[key].ttff_sec) >= criteria for key in ttff_data.keys()):
+    elif any(float(ttff_data[key].ttff_sec) >= criteria for key in
+             ttff_data.keys()):
         ad.log.error("One or more TTFF %s are over test criteria %d seconds"
                      % (ttff_mode, criteria))
         return False
@@ -862,7 +870,8 @@
         ad: An AndroidDevice object.
     """
     time.sleep(1)
-    current = ad.adb.shell("dumpsys window | grep -E 'mCurrentFocus|mFocusedApp'")
+    current = ad.adb.shell(
+        "dumpsys window | grep -E 'mCurrentFocus|mFocusedApp'")
     ad.log.debug("\n"+current)
 
 def check_location_api(ad, retries):
@@ -884,7 +893,8 @@
             logcat_results = ad.search_logcat("REPORT_LOCATION", begin_time)
             if logcat_results:
                 ad.log.info("%s" % logcat_results[-1]["log_message"])
-                ad.log.info("GnssLocationProvider reports location successfully.")
+                ad.log.info("GnssLocationProvider reports location "
+                            "successfully.")
                 return True
         if not ad.is_adb_logcat_on:
             ad.start_adb_logcat()
@@ -907,10 +917,12 @@
         time.sleep(1)
         begin_time = get_current_epoch_time()
         ad.log.info("Try to get NLP status - attempt %d" % (i+1))
-        ad.adb.shell("am start -S -n com.android.gpstool/.GPSTool --es mode nlp")
+        ad.adb.shell(
+            "am start -S -n com.android.gpstool/.GPSTool --es mode nlp")
         while get_current_epoch_time() - begin_time <= 30000:
-            logcat_results = ad.search_logcat(
-                "LocationManagerService: incoming location: Location", begin_time)
+            logcat_results = ad.search_logcat("LocationManagerService: "
+                                              "incoming location: Location",
+                                              begin_time)
             if logcat_results:
                 for logcat_result in logcat_results:
                     if location_type in logcat_result["log_message"]:
@@ -932,7 +944,8 @@
         atten_value: attenuation value
     """
     try:
-        ad.log.info("Set attenuation value to \"%d\" for GNSS signal." % atten_value)
+        ad.log.info(
+            "Set attenuation value to \"%d\" for GNSS signal." % atten_value)
         attenuator[0].set_atten(atten_value)
     except Exception as e:
         ad.log.error(e)
@@ -987,7 +1000,8 @@
         ad.log.info("Open an youtube video - attempt %d" % (i+1))
         ad.adb.shell("am start -a android.intent.action.VIEW -d \"%s\"" % url)
         time.sleep(2)
-        out = ad.adb.shell("dumpsys activity | grep NewVersionAvailableActivity")
+        out = ad.adb.shell(
+            "dumpsys activity | grep NewVersionAvailableActivity")
         if out:
             ad.log.info("Skip Youtube New Version Update.")
             ad.send_keycode("BACK")
@@ -1008,12 +1022,72 @@
     """
     try:
         baseband_version = ad.adb.getprop("gsm.version.baseband")
-        gms_version = ad.adb.shell("dumpsys package com.google.android.gms | "
-                                   "grep versionName").split("\n")[0].split("=")[1]
+        gms_version = ad.adb.shell(
+            "dumpsys package com.google.android.gms | grep versionName"
+        ).split("\n")[0].split("=")[1]
+        mpss_version = ad.adb.shell("cat /sys/devices/soc0/images | grep MPSS "
+                                    "| cut -d ':' -f 3")
         if not extra_msg:
             ad.log.info("TestResult Baseband_Version %s" % baseband_version)
-            ad.log.info("TestResult GMS_Version %s" % gms_version.replace(" ", ""))
+            ad.log.info(
+                "TestResult GMS_Version %s" % gms_version.replace(" ", ""))
+            ad.log.info("TestResult MPSS_Version %s" % mpss_version)
         else:
-            ad.log.info("%s, Baseband_Version = %s" % (extra_msg, baseband_version))
+            ad.log.info(
+                "%s, Baseband_Version = %s" % (extra_msg, baseband_version))
     except Exception as e:
-        ad.log.error(e)
\ No newline at end of file
+        ad.log.error(e)
+
+def start_toggle_gnss_by_gtw_gpstool(ad, iteration):
+    """Send toggle gnss off/on start_test_action
+
+    Args:
+        ad: An AndroidDevice object.
+        iteration: Iteration of toggle gnss off/on cycles.
+    """
+    msg_list = []
+    begin_time = get_current_epoch_time()
+    try:
+        for i in range(1, 4):
+            ad.adb.shell("am start -S -n com.android.gpstool/.GPSTool "
+                         "--es mode toggle --es cycle %d" % iteration)
+            time.sleep(1)
+            if ad.search_logcat("cmp=com.android.gpstool/.ToggleGPS",
+                                begin_time):
+                ad.log.info("Send ToggleGPS start_test_action successfully.")
+                break
+        else:
+            check_currrent_focus_app(ad)
+            raise signals.TestFailure("Fail to send ToggleGPS "
+                                      "start_test_action within 3 attempts.")
+        time.sleep(2)
+        test_start = ad.search_logcat("GPSTool_ToggleGPS: startService",
+                                      begin_time)
+        if test_start:
+            ad.log.info(test_start[-1]["log_message"].split(":")[-1].strip())
+        else:
+            raise signals.TestFailure("Fail to start toggle GPS off/on test.")
+        # Every iteration is expected to finish within 4 minutes.
+        while get_current_epoch_time() - begin_time <= iteration * 240000:
+            crash_end = ad.search_logcat("Force finishing activity "
+                                         "com.android.gpstool/.GPSTool",
+                                         begin_time)
+            if crash_end:
+                raise signals.TestFailure("GPSTool crashed. Abort test.")
+            toggle_results = ad.search_logcat("GPSTool : msg", begin_time)
+            if toggle_results:
+                for toggle_result in toggle_results:
+                    msg = toggle_result["log_message"]
+                    if not msg in msg_list:
+                        ad.log.info(msg.split(":")[-1].strip())
+                        msg_list.append(msg)
+                    if "timeout" in msg:
+                        raise signals.TestFailure("Fail to get location fixed "
+                                                  "within 60 seconds.")
+                    if "Test end" in msg:
+                        raise signals.TestPass("Completed quick toggle GNSS "
+                                               "off/on test.")
+        raise signals.TestFailure("Fail to finish toggle GPS off/on test "
+                                  "within %d minutes" % (iteration * 4))
+    finally:
+        ad.send_keycode("HOME")
diff --git a/acts/framework/acts/test_utils/instrumentation/adb_commands/common.py b/acts/framework/acts/test_utils/instrumentation/adb_commands/common.py
index 2991600..ffd43dd 100644
--- a/acts/framework/acts/test_utils/instrumentation/adb_commands/common.py
+++ b/acts/framework/acts/test_utils/instrumentation/adb_commands/common.py
@@ -62,6 +62,11 @@
 nfc = DeviceState('svc nfc', 'enable', 'disable')
 
 
+# Calling
+
+disable_dialing = DeviceSetprop('ro.telephony.disable-call', 'true', 'false')
+
+
 # Screen
 
 screen_adaptive_brightness = DeviceSetting(
@@ -115,3 +120,12 @@
 
 disable_doze = 'dumpsys deviceidle disable'
 
+
+# Miscellaneous
+
+test_harness = DeviceBinaryCommandSeries(
+    [
+        DeviceSetprop('ro.monkey'),
+        DeviceSetprop('ro.test_harness')
+    ]
+)
diff --git a/acts/framework/acts/test_utils/instrumentation/instrumentation_base_test.py b/acts/framework/acts/test_utils/instrumentation/instrumentation_base_test.py
index d0e7948..fe00d33 100644
--- a/acts/framework/acts/test_utils/instrumentation/instrumentation_base_test.py
+++ b/acts/framework/acts/test_utils/instrumentation/instrumentation_base_test.py
@@ -140,25 +140,51 @@
         """Clean up device after test completion."""
         pass
 
-    def _get_controller_config(self, controller_name):
-        """Get the controller config from the instrumentation config, at the
-        level of the current test class or test case.
+    def _get_merged_config(self, config_name):
+        """Takes the configs with config_name from the base, testclass, and
+        testcase levels and merges them together. When the same parameter is
+        defined in different contexts, the value from the most specific context
+        is taken.
+
+        Example:
+            self._instrumentation_config = {
+                'sample_config': {
+                    'val_a': 5,
+                    'val_b': 7
+                },
+                'ActsTestClass': {
+                    'sample_config': {
+                        'val_b': 3,
+                        'val_c': 6
+                    },
+                    'acts_test_case': {
+                        'sample_config': {
+                            'val_c': 10,
+                            'val_d': 2
+                        }
+                    }
+                }
+            }
+
+            self._get_merged_config('sample_config') returns
+            {
+                'val_a': 5,
+                'val_b': 3,
+                'val_c': 10,
+                'val_d': 2
+            }
 
         Args:
-            controller_name: Name of the controller config to fetch
-        Returns: The controller config, as a ConfigWrapper
+            config_name: Name of the config to fetch
+        Returns: The merged config, as a ConfigWrapper
         """
+        merged_config = self._instrumentation_config.get_config(
+            config_name)
+        merged_config.update(self._class_config.get_config(config_name))
         if self.current_test_name:
-            # Return the testcase level config, used for setting up test
             case_config = self._class_config.get_config(self.current_test_name)
-            return case_config.get_config(controller_name)
-        else:
-            # Merge the base and testclass level configs, used for setting up
-            # class.
-            merged_config = self._instrumentation_config.get_config(
-                controller_name)
-            merged_config.update(self._class_config.get_config(controller_name))
-            return merged_config
+            merged_config.update(case_config.get_config(config_name))
+        return merged_config
 
     def adb_run(self, cmds):
         """Run the specified command, or list of commands, with the ADB shell.
diff --git a/acts/framework/acts/test_utils/instrumentation/intent_builder.py b/acts/framework/acts/test_utils/instrumentation/intent_builder.py
index 1fe4035..a1cc529 100644
--- a/acts/framework/acts/test_utils/instrumentation/intent_builder.py
+++ b/acts/framework/acts/test_utils/instrumentation/intent_builder.py
@@ -14,17 +14,10 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
-from collections import defaultdict
+import collections
 
-TYPE_TO_FLAG = defaultdict(lambda: '--es')
-TYPE_TO_FLAG.update(
-    {
-        bool: '--ez',
-        int: '--ei',
-        float: '--ef',
-        str: '--es'
-    }
-)
+TYPE_TO_FLAG = collections.defaultdict(lambda: '--es')
+TYPE_TO_FLAG.update({bool: '--ez', int: '--ei', float: '--ef', str: '--es'})
 
 
 class IntentBuilder(object):
@@ -41,7 +34,7 @@
         self._component = None
         self._data_uri = None
         self._flags = []
-        self._key_value_params = {}
+        self._key_value_params = collections.OrderedDict()
 
     def set_action(self, action):
         """Set the intent action, as marked by the -a flag"""
@@ -85,6 +78,6 @@
                 str_value = str(value)
                 if isinstance(value, bool):
                     str_value = str_value.lower()
-                cmd.append(
-                    ' '.join((TYPE_TO_FLAG[type(value)], key, str_value)))
+                cmd.append(' '.join((TYPE_TO_FLAG[type(value)], key,
+                                     str_value)))
         return ' '.join(cmd).strip()
diff --git a/acts/framework/acts/test_utils/power/PowerBaseTest.py b/acts/framework/acts/test_utils/power/PowerBaseTest.py
index 08e7a9a..92fc603 100644
--- a/acts/framework/acts/test_utils/power/PowerBaseTest.py
+++ b/acts/framework/acts/test_utils/power/PowerBaseTest.py
@@ -50,7 +50,6 @@
     """Create a random obj with unknown attributes and value.
 
     """
-
     def __init__(self, **kwargs):
         self.__dict__.update(kwargs)
 
@@ -69,7 +68,6 @@
     """Base class for all wireless power related tests.
 
     """
-
     def __init__(self, controllers):
 
         base_test.BaseTestClass.__init__(self, controllers)
@@ -94,8 +92,7 @@
         self.mon.attach_device(self.dut)
 
         # Unpack the test/device specific parameters
-        TEST_PARAMS = self.TAG + '_params'
-        req_params = [TEST_PARAMS, 'custom_files']
+        req_params = ['custom_files']
         self.unpack_userparams(req_params)
         # Unpack the custom files based on the test configs
         for file in self.custom_files:
@@ -111,11 +108,14 @@
         asserts.abort_class_if(
             not self.threshold_file,
             'Required test pass/fail threshold file is missing')
-        asserts.abort_class_if(not self.rockbottom_script,
-                               'Required rockbottom setting script is missing')
+        asserts.abort_class_if(
+            not self.rockbottom_script,
+            'Required rockbottom setting script is missing')
 
         # Unpack test specific configs
-        self.unpack_testparams(getattr(self, TEST_PARAMS))
+        TEST_PARAMS = self.TAG + '_params'
+        self.test_params = self.user_params.get(TEST_PARAMS, {})
+        self.unpack_testparams(self.test_params)
         if hasattr(self, 'attenuators'):
             self.num_atten = self.attenuators[0].instrument.num_atten
             self.atten_level = self.unpack_custom_file(self.attenuation_file)
@@ -124,7 +124,7 @@
         self.mon_info = self.create_monsoon_info()
 
         # Sync device time, timezone and country code
-        utils.require_sl4a((self.dut,))
+        utils.require_sl4a((self.dut, ))
         utils.sync_device_time(self.dut)
         self.dut.droid.wifiSetCountryCode('US')
 
@@ -159,11 +159,18 @@
         self.mon.usb('on')
         self.power_logger.set_avg_power(self.power_result.metric_value)
         self.power_logger.set_testbed(self.testbed_name)
+
         # Take Bugreport
         if self.bug_report:
             begin_time = utils.get_current_epoch_time()
             self.dut.take_bug_report(self.test_name, begin_time)
 
+        # Allow the device to cooldown before executing the next test
+        last_test = self.current_test_name == self.results.requested[-1]
+        cooldown = self.test_params.get('cooldown', None)
+        if cooldown and not last_test:
+            time.sleep(cooldown)
+
     def teardown_class(self):
         """Clean up the test class after tests finish running
 
@@ -444,11 +451,10 @@
             iperf_result = ipf.IPerfResult(iperf_file)
 
             # Compute the throughput in Mbit/s
-            throughput = (
-                math.fsum(
-                    iperf_result.instantaneous_rates[self.start_meas_time:-1]) /
-                len(iperf_result.instantaneous_rates[self.start_meas_time:-1])
-            ) * 8 * (1.024**2)
+            throughput = (math.fsum(
+                iperf_result.instantaneous_rates[self.start_meas_time:-1]
+            ) / len(iperf_result.instantaneous_rates[self.start_meas_time:-1])
+                          ) * 8 * (1.024**2)
 
             self.log.info('The average throughput is {}'.format(throughput))
         except ValueError:
diff --git a/acts/framework/acts/test_utils/power/PowerCellularLabBaseTest.py b/acts/framework/acts/test_utils/power/PowerCellularLabBaseTest.py
index 9a3b100..d7bc63c 100644
--- a/acts/framework/acts/test_utils/power/PowerCellularLabBaseTest.py
+++ b/acts/framework/acts/test_utils/power/PowerCellularLabBaseTest.py
@@ -19,6 +19,7 @@
 import acts.test_utils.power.PowerBaseTest as PBT
 import acts.controllers.cellular_simulator as simulator
 from acts.controllers.anritsu_lib import md8475_cellular_simulator as anritsu
+from acts.controllers.rohdeschwarz_lib import cmw500_cellular_simulator as cmw
 from acts.test_utils.power.tel_simulations.GsmSimulation import GsmSimulation
 from acts.test_utils.power.tel_simulations.LteSimulation import LteSimulation
 from acts.test_utils.power.tel_simulations.UmtsSimulation import UmtsSimulation
@@ -75,10 +76,6 @@
 
         super().setup_class()
 
-        # Gets the name of the interface from which packets are sent
-        if hasattr(self, 'packet_senders'):
-            self.pkt_sender = self.packet_senders[0]
-
         # Load calibration tables
         filename_calibration_table = (
             self.FILENAME_CALIBRATION_TABLE_UNFORMATTED.format(
@@ -91,9 +88,8 @@
                 self.log.debug(self.calibration_table)
                 break
 
-        # Store the value of the key to access the test config in the
-        # user_params dictionary.
-        self.PARAMS_KEY = self.TAG + "_params"
+        # Ensure the calibration table only contains non-negative values
+        self.ensure_valid_calibration_table(self.calibration_table)
 
         # Turn on airplane mode for all devices, as some might
         # be unused during the test
@@ -135,6 +131,18 @@
                     self.md8475a_ip_address)
             else:
                 raise ValueError('Invalid MD8475 version.')
+
+        elif hasattr(self, 'cmw500_ip') or hasattr(self, 'cmw500_port'):
+
+            for key in ['cmw500_ip', 'cmw500_port']:
+                if not hasattr(self, key):
+                    raise RuntimeError('The CMW500 cellular simulator '
+                                       'requires %s to be set in the '
+                                       'config file.' % key)
+
+            return cmw.CMW500CellularSimulator(self.cmw500_ip,
+                                               self.cmw500_port)
+
         else:
             raise RuntimeError(
                 'The simulator could not be initialized because '
@@ -196,14 +204,9 @@
         # Wait for new params to settle
         time.sleep(5)
 
-        # Start the simulation. This method will raise a RuntimeException if
+        # Start the simulation. This method will raise an exception if
         # the phone is unable to attach.
-        try:
-            self.simulation.start()
-        except RuntimeError:
-            return False
-
-        self.simulation.start_test_case()
+        self.simulation.start()
 
         # Make the device go to sleep
         self.dut.droid.goToSleepNow()
@@ -352,5 +355,22 @@
         # Instantiate a new simulation
         self.simulation = simulation_class(self.cellular_simulator, self.log,
                                            self.dut,
-                                           self.user_params[self.PARAMS_KEY],
+                                           self.test_params,
                                            self.calibration_table[sim_type])
+
+    def ensure_valid_calibration_table(self, calibration_table):
+        """ Ensures the calibration table has the correct structure.
+
+        A valid calibration table is a nested dictionary with non-negative
+        number values
+
+        """
+        if not calibration_table or not isinstance(calibration_table, dict):
+            raise TypeError('The calibration table must be a dictionary')
+        for val in calibration_table.values():
+            if isinstance(val, dict):
+                self.ensure_valid_calibration_table(val)
+            elif not isinstance(val, float) and not isinstance(val, int):
+                raise TypeError('Calibration table value must be a number')
+            elif val < 0.0:
+                raise ValueError('Calibration table contains negative values')
diff --git a/acts/framework/acts/test_utils/power/tel_simulations/BaseSimulation.py b/acts/framework/acts/test_utils/power/tel_simulations/BaseSimulation.py
index 6ce7f85..091c18e 100644
--- a/acts/framework/acts/test_utils/power/tel_simulations/BaseSimulation.py
+++ b/acts/framework/acts/test_utils/power/tel_simulations/BaseSimulation.py
@@ -18,16 +18,14 @@
 from enum import Enum
 
 import numpy as np
-
-from acts.controllers.anritsu_lib._anritsu_utils import AnritsuError
-from acts.controllers.anritsu_lib.md8475a import BtsNumber
+from acts.controllers import cellular_simulator
 from acts.test_utils.tel.tel_test_utils import get_telephony_signal_strength
 from acts.test_utils.tel.tel_test_utils import toggle_airplane_mode
 from acts.test_utils.tel.tel_test_utils import toggle_cell_data_roaming
 
 
 class BaseSimulation():
-    """ Base class for an Anritsu Simulation abstraction.
+    """ Base class for cellular connectivity simulations.
 
     Classes that inherit from this base class implement different simulation
     setups. The base class contains methods that are common to all simulation
@@ -37,10 +35,8 @@
 
     NUM_UL_CAL_READS = 3
     NUM_DL_CAL_READS = 5
-    DL_CAL_TARGET_POWER = {'A': -15.0, 'B': -35.0}
     MAX_BTS_INPUT_POWER = 30
     MAX_PHONE_OUTPUT_POWER = 23
-    DL_MAX_POWER = {'A': -10.0, 'B': -30.0}
     UL_MIN_POWER = -60.0
 
     # Key to read the calibration setting from the test_config dictionary.
@@ -86,6 +82,7 @@
             parameters to None. """
             self.output_power = None
             self.input_power = None
+            self.band = None
 
         def incorporate(self, new_config):
             """ Incorporates a different configuration by replacing the current
@@ -111,7 +108,6 @@
         """
 
         self.simulator = simulator
-        self.anritsu = simulator.anritsu
         self.log = log
         self.dut = dut
         self.calibration_table = calibration_table
@@ -128,9 +124,6 @@
         self.calibration_required = test_config.get(self.KEY_CALIBRATION,
                                                     False)
 
-        # Gets BTS1 since this sim only has 1 BTS
-        self.bts1 = self.anritsu.get_BTS(BtsNumber.BTS1)
-
         # Configuration object for the primary base station
         self.primary_config = self.BtsConfig()
 
@@ -155,25 +148,17 @@
         # Enable roaming on the phone
         toggle_cell_data_roaming(self.dut, True)
 
-        # Load callbox config files
-        self.callbox_config_path = self.CALLBOX_PATH_FORMAT_STR.format(
-            self.anritsu._md8475_version)
-        self.load_config_files()
-
         # Make sure airplane mode is on so the phone won't attach right away
         toggle_airplane_mode(self.log, self.dut, True)
 
         # Wait for airplane mode setting to propagate
         time.sleep(2)
 
-        # Start simulation if it wasn't started
-        self.anritsu.start_simulation()
+        # Prepare the simulator for this simulation setup
+        self.setup_simulator()
 
-    def load_config_files(self):
-        """ Loads configuration files for the simulation.
-
-        This method needs to be implement by derived simulation classes. """
-
+    def setup_simulator(self):
+        """ Do initial configuration in the simulator. """
         raise NotImplementedError()
 
     def attach(self):
@@ -196,7 +181,7 @@
         new_config = self.BtsConfig()
         new_config.input_power = -10
         new_config.output_power = -30
-        self.configure_bts(self.bts1, new_config)
+        self.simulator.configure_bts(new_config)
         self.primary_config.incorporate(new_config)
 
         # Try to attach the phone.
@@ -208,15 +193,14 @@
                 toggle_airplane_mode(self.log, self.dut, False)
 
                 # Wait for the phone to attach.
-                self.anritsu.wait_for_registration_state(
-                    time_to_wait=self.ATTACH_WAITING_TIME)
+                self.simulator.wait_until_attached(
+                    timeout=self.ATTACH_WAITING_TIME)
 
-            except AnritsuError as e:
+            except cellular_simulator.CellularSimulatorError:
 
                 # The phone failed to attach
                 self.log.info(
                     "UE failed to attach on attempt number {}.".format(i + 1))
-                self.log.info("Error message: {}".format(str(e)))
 
                 # Turn airplane mode on to prepare the phone for a retry.
                 toggle_airplane_mode(self.log, self.dut, True)
@@ -253,21 +237,13 @@
         # Wait for APM to propagate
         time.sleep(2)
 
-        # Try to power off the basestation. An exception will be raised if the
-        # simulation is not running, which is ok because it means the phone is
-        # not attached.
-        try:
-            self.anritsu.set_simulation_state_to_poweroff()
-        except AnritsuError:
-            self.log.warning('Could not power off the basestation. The '
-                             'simulation might be stopped.')
+        # Power off basestation
+        self.simulator.detach()
 
     def stop(self):
         """  Detach phone from the basestation by stopping the simulation.
 
-        Send stop command to anritsu and turn on airplane mode.
-
-        """
+        Stop the simulation and turn airplane mode on. """
 
         # Set the DUT to airplane mode so it doesn't see the
         # cellular network going off
@@ -277,28 +253,39 @@
         time.sleep(2)
 
         # Stop the simulation
-        self.anritsu.stop_simulation()
+        self.simulator.stop()
 
     def start(self):
         """ Start the simulation by attaching the phone and setting the
         required DL and UL power.
 
         Note that this refers to starting the simulated testing environment
-        and not to starting the simulation in the Anritsu callbox, which was
-        done during the class initialization. """
+        and not to starting the signaling on the cellular instruments,
+        which might have been done earlier depending on the cellular
+        instrument controller implementation. """
 
         if not self.attach():
             raise RuntimeError('Could not attach to base station.')
 
+        # Starts IP traffic while changing this setting to force the UE to be
+        # in Communication state, as UL power cannot be set in Idle state
+        self.start_traffic_for_calibration()
+
+        # Wait until it goes to communication state
+        self.simulator.wait_until_communication_state()
+
         # Set signal levels obtained from the test parameters
         new_config = self.BtsConfig()
         new_config.output_power = self.calibrated_downlink_rx_power(
             self.primary_config, self.sim_dl_power)
         new_config.input_power = self.calibrated_uplink_tx_power(
             self.primary_config, self.sim_ul_power)
-        self.configure_bts(self.bts1, new_config)
+        self.simulator.configure_bts(new_config)
         self.primary_config.incorporate(new_config)
 
+        # Stop IP traffic after setting the UL power level
+        self.stop_traffic_for_calibration()
+
     def parse_parameters(self, parameters):
         """ Configures simulation using a list of parameters.
 
@@ -311,22 +298,6 @@
 
         raise NotImplementedError()
 
-    def configure_bts(self, bts_handle, config):
-        """ Configures the base station in the Anritsu callbox.
-
-        Parameters set to None in the configuration object are skipped.
-
-        Args:
-            bts_handle: a handle to the Anritsu base station controller.
-            config: a BtsConfig object containing the desired configuration.
-        """
-
-        if config.output_power:
-            bts_handle.output_level = config.output_power
-
-        if config.input_power:
-            bts_handle.input_level = config.input_power
-
     def consume_parameter(self, parameters, parameter_name, num_values=0):
         """ Parses a parameter from a list.
 
@@ -419,14 +390,12 @@
         # throw an TypeError exception
         try:
             calibrated_power = round(power + self.dl_path_loss)
-            if (calibrated_power >
-                    self.DL_MAX_POWER[self.anritsu._md8475_version]):
+            if calibrated_power > self.simulator.MAX_DL_POWER:
                 self.log.warning(
                     "Cannot achieve phone DL Rx power of {} dBm. Requested TX "
                     "power of {} dBm exceeds callbox limit!".format(
                         power, calibrated_power))
-                calibrated_power = self.DL_MAX_POWER[
-                    self.anritsu._md8475_version]
+                calibrated_power = self.simulator.MAX_DL_POWER
                 self.log.warning(
                     "Setting callbox Tx power to max possible ({} dBm)".format(
                         calibrated_power))
@@ -467,13 +436,6 @@
         else:
             power = signal_level
 
-        # Starts IP traffic while changing this setting to force the UE to be
-        # in Communication state, as UL power cannot be set in Idle state
-        self.start_traffic_for_calibration()
-
-        # Wait until it goes to communication state
-        self.anritsu.wait_for_communication_state()
-
         # Try to use measured path loss value. If this was not set, it will
         # throw an TypeError exception
         try:
@@ -503,9 +465,6 @@
                           "uncalibrated).".format(round(power)))
             return round(power)
 
-        # Stop IP traffic after setting the UL power level
-        self.stop_traffic_for_calibration()
-
     def calibrate(self, band):
         """ Calculates UL and DL path loss if it wasn't done before.
 
@@ -540,27 +499,15 @@
             Starts UDP IP traffic before running calibration. Uses APN_1
             configured in the phone.
         """
-        try:
-            self.anritsu.start_ip_traffic()
-        except AnritsuError as inst:
-            # This typically happens when traffic is already running
-            self.log.warning("{}\n".format(inst))
-        time.sleep(4)
+        self.simulator.start_data_traffic()
 
     def stop_traffic_for_calibration(self):
         """
             Stops IP traffic after calibration.
         """
-        try:
-            self.anritsu.stop_ip_traffic()
-        except AnritsuError as inst:
-            # This typically happens when traffic has already been stopped
-            self.log.warning("{}\n".format(inst))
-        time.sleep(2)
+        self.simulator.stop_data_traffic()
 
-    def downlink_calibration(self,
-                             rat=None,
-                             power_units_conversion_func=None):
+    def downlink_calibration(self, rat=None, power_units_conversion_func=None):
         """ Computes downlink path loss and returns the calibration value
 
         The DUT needs to be attached to the base station before calling this
@@ -591,9 +538,8 @@
         # Set BTS to a good output level to minimize measurement error
         initial_screen_timeout = self.dut.droid.getScreenTimeout()
         new_config = self.BtsConfig()
-        new_config.output_power = self.DL_CAL_TARGET_POWER[
-            self.anritsu._md8475_version]
-        self.configure_bts(self.bts1, new_config)
+        new_config.output_power = self.simulator.MAX_DL_POWER - 5
+        self.simulator.configure_bts(new_config)
 
         # Set phone sleep time out
         self.dut.droid.setScreenTimeout(1800)
@@ -619,7 +565,7 @@
         # Reset phone and bts to original settings
         self.dut.droid.goToSleepNow()
         self.dut.droid.setScreenTimeout(initial_screen_timeout)
-        self.configure_bts(self.bts1, restoration_config)
+        self.simulator.configure_bts(restoration_config)
         time.sleep(2)
 
         # Calculate the mean of the measurements
@@ -633,8 +579,7 @@
             avg_down_power = reported_asu_power
 
         # Calculate Path Loss
-        dl_target_power = self.DL_CAL_TARGET_POWER[
-            self.anritsu._md8475_version]
+        dl_target_power = self.simulator.MAX_DL_POWER - 5
         down_call_path_loss = dl_target_power - avg_down_power
 
         # Validate the result
@@ -668,7 +613,7 @@
         initial_screen_timeout = self.dut.droid.getScreenTimeout()
         new_config = self.BtsConfig()
         new_config.input_power = self.MAX_BTS_INPUT_POWER
-        self.configure_bts(self.bts1, new_config)
+        self.simulator.configure_bts(new_config)
 
         # Set phone sleep time out
         self.dut.droid.setScreenTimeout(1800)
@@ -706,7 +651,7 @@
         # Reset phone and bts to original settings
         self.dut.droid.goToSleepNow()
         self.dut.droid.setScreenTimeout(initial_screen_timeout)
-        self.configure_bts(self.bts1, restoration_config)
+        self.simulator.configure_bts(restoration_config)
         time.sleep(2)
 
         # Phone only supports 1x1 Uplink so always chain 0
@@ -729,26 +674,18 @@
 
         return up_call_path_loss
 
-    def set_band(self, bts, band, calibrate_if_necessary=True):
-        """ Sets the band used for communication.
-
-        When moving to a new band, recalibrate the link.
-
-        Args:
-            bts: basestation handle
-            band: desired band
-            calibrate_if_necessary: if False calibration will be skipped
-        """
-
-        bts.band = band
-        time.sleep(5)  # It takes some time to propagate the new band
-
-        # Invalidate the calibration values
+    def load_pathloss_if_required(self):
+        """ If calibration is required, try to obtain the pathloss values from
+        the calibration table and measure them if they are not available. """
+        # Invalidate the previous values
         self.dl_path_loss = None
         self.ul_path_loss = None
 
-        # Only calibrate when required.
-        if self.calibration_required and calibrate_if_necessary:
+        # Load the new ones
+        if self.calibration_required:
+
+            band = self.primary_config.band
+
             # Try loading the path loss values from the calibration table. If
             # they are not available, use the automated calibration procedure.
             try:
@@ -791,19 +728,3 @@
             Maximum throughput in mbps
         """
         raise NotImplementedError()
-
-    def start_test_case(self):
-        """ Starts a test case in the current simulation.
-
-        Requires the phone to be attached.
-        """
-
-        pass
-
-    def wait_for_rrc_idle_state(self, wait_time):
-        """ Waits for UE RRC state change to idle mode.
-
-        Raises exception when UE fails to move to idle state
-        """
-
-        self.anritsu.wait_for_idle_state(wait_time)
diff --git a/acts/framework/acts/test_utils/power/tel_simulations/GsmSimulation.py b/acts/framework/acts/test_utils/power/tel_simulations/GsmSimulation.py
index 4af6bf2..6dc2082 100644
--- a/acts/framework/acts/test_utils/power/tel_simulations/GsmSimulation.py
+++ b/acts/framework/acts/test_utils/power/tel_simulations/GsmSimulation.py
@@ -16,7 +16,9 @@
 
 import ntpath
 
+import time
 from acts.controllers.anritsu_lib.md8475a import BtsGprsMode
+from acts.controllers.anritsu_lib.md8475a import BtsNumber
 from acts.controllers.anritsu_lib import md8475_cellular_simulator as anritsusim
 from acts.test_utils.power.tel_simulations.BaseSimulation import BaseSimulation
 from acts.test_utils.tel.anritsu_utils import GSM_BAND_DCS1800
@@ -27,9 +29,7 @@
 
 
 class GsmSimulation(BaseSimulation):
-    """ Simple GSM simulation with only one basestation.
-
-    """
+    """ Single base station GSM. """
 
     # Simulation config files in the callbox computer.
     # These should be replaced in the future by setting up
@@ -55,7 +55,7 @@
     }
 
     def __init__(self, simulator, log, dut, test_config, calibration_table):
-        """ Configures Anritsu system for GSM simulation with 1 basetation
+        """ Initializes the simulator for a single-carrier GSM simulation.
 
         Loads a simple LTE simulation enviroment with 1 basestation. It also
         creates the BTS handle so we can change the parameters as desired.
@@ -69,15 +69,18 @@
                 different bands.
 
         """
-
-        super().__init__(simulator, log, dut, test_config, calibration_table)
-
         # The GSM simulation relies on the cellular simulator to be a MD8475
         if not isinstance(self.simulator, anritsusim.MD8475CellularSimulator):
             raise ValueError('The GSM simulation relies on the simulator to '
                              'be an Anritsu MD8475 A/B instrument.')
 
+        # The Anritsu controller needs to be unwrapped before calling
+        # super().__init__ because setup_simulator() requires self.anritsu and
+        # will be called during the parent class initialization.
         self.anritsu = self.simulator.anritsu
+        self.bts1 = self.anritsu.get_BTS(BtsNumber.BTS1)
+
+        super().__init__(simulator, log, dut, test_config, calibration_table)
 
         if not dut.droid.telephonySetPreferredNetworkTypesForSubscription(
                 NETWORK_MODE_GSM_ONLY,
@@ -86,13 +89,20 @@
         else:
             log.info("Preferred network type set.")
 
-    def load_config_files(self):
-        """ Loads configuration files for the simulation. """
+    def setup_simulator(self):
+        """ Do initial configuration in the simulator. """
+
+        # Load callbox config files
+        callbox_config_path = self.CALLBOX_PATH_FORMAT_STR.format(
+            self.anritsu._md8475_version)
 
         self.anritsu.load_simulation_paramfile(
-            ntpath.join(self.callbox_config_path, self.GSM_BASIC_SIM_FILE))
+            ntpath.join(callbox_config_path, self.GSM_BASIC_SIM_FILE))
         self.anritsu.load_cell_paramfile(
-            ntpath.join(self.callbox_config_path, self.GSM_CELL_FILE))
+            ntpath.join(callbox_config_path, self.GSM_CELL_FILE))
+
+        # Start simulation if it wasn't started
+        self.anritsu.start_simulation()
 
     def parse_parameters(self, parameters):
         """ Configs a GSM simulation using a list of parameters.
@@ -113,6 +123,7 @@
                 "the required band number.".format(self.PARAM_BAND))
 
         self.set_band(self.bts1, values[1])
+        self.load_pathloss_if_required()
 
         # Setup GPRS mode
 
@@ -139,3 +150,14 @@
                     self.PARAM_SLOTS))
 
         self.bts1.gsm_slots = (int(values[1]), int(values[2]))
+
+    def set_band(self, bts, band):
+        """ Sets the band used for communication.
+
+        Args:
+            bts: basestation handle
+            band: desired band
+        """
+
+        bts.band = band
+        time.sleep(5)  # It takes some time to propagate the new band
diff --git a/acts/framework/acts/test_utils/power/tel_simulations/LteCaSimulation.py b/acts/framework/acts/test_utils/power/tel_simulations/LteCaSimulation.py
index d5e2840..6273833 100644
--- a/acts/framework/acts/test_utils/power/tel_simulations/LteCaSimulation.py
+++ b/acts/framework/acts/test_utils/power/tel_simulations/LteCaSimulation.py
@@ -14,19 +14,14 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 import re
-import time
-
+from acts.controllers.anritsu_lib.md8475a import BtsNumber
 from acts.controllers.anritsu_lib.md8475a import BtsTechnology
 from acts.controllers.anritsu_lib.md8475a import LteMimoMode
-from acts.controllers.anritsu_lib.md8475a import BtsNumber
-from acts.controllers.anritsu_lib.md8475a import BtsPacketRate
-from acts.controllers.anritsu_lib.md8475a import TestProcedure
-from acts.controllers.anritsu_lib.md8475a import TestPowerControl
-from acts.controllers.anritsu_lib.md8475a import TestMeasurement
-from acts.test_utils.power.tel_simulations.LteSimulation import LteSimulation
+from acts.test_utils.power.tel_simulations import LteSimulation
 
 
-class LteCaSimulation(LteSimulation):
+class LteCaSimulation(LteSimulation.LteSimulation):
+    """ Carrier aggregation LTE simulation. """
 
     # Dictionary of lower DL channel number bound for each band.
     LOWEST_DL_CN_DICTIONARY = {
@@ -72,26 +67,20 @@
         42: 45590
     }
 
-    # Simulation config files in the callbox computer.
-    # These should be replaced in the future by setting up
-    # the same configuration manually.
-    LTE_BASIC_SIM_FILE = 'SIM_LTE_CA.wnssp'
-    LTE_BASIC_CELL_FILE = 'CELL_LTE_CA_config.wnscp'
-
     # Simulation config keywords contained in the test name
     PARAM_CA = 'ca'
 
     # Test config keywords
     KEY_FREQ_BANDS = "freq_bands"
 
-    def __init__(self, anritsu, log, dut, test_config, calibration_table):
-        """ Configures Anritsu system for LTE simulation with carrier
+    def __init__(self, simulator, log, dut, test_config, calibration_table):
+        """ Initializes the simulator for LTE simulation with carrier
         aggregation.
 
         Loads a simple LTE simulation enviroment with 5 basestations.
 
         Args:
-            anritsu: the Anritsu callbox controller
+            simulator: the cellular instrument controller
             log: a logger handle
             dut: the android device handler
             test_config: test configuration obtained from the config file
@@ -100,72 +89,57 @@
 
         """
 
-        super().__init__(anritsu, log, dut, test_config, calibration_table)
+        super().__init__(simulator, log, dut, test_config, calibration_table)
 
-        self.bts = [self.bts1, self.anritsu.get_BTS(BtsNumber.BTS2)]
+        self.anritsu = simulator.anritsu
+
+        self.bts = [
+            self.anritsu.get_BTS(BtsNumber.BTS1),
+            self.anritsu.get_BTS(BtsNumber.BTS2)
+        ]
 
         if self.anritsu._md8475_version == 'B':
             self.bts.extend([
-                anritsu.get_BTS(BtsNumber.BTS3),
-                anritsu.get_BTS(BtsNumber.BTS4)
+                self.anritsu.get_BTS(BtsNumber.BTS3),
+                self.anritsu.get_BTS(BtsNumber.BTS4)
             ])
 
         # Create a configuration object for each base station and copy initial
         # settings from the PCC base station.
         self.bts_configs = [self.primary_config]
 
-        for bts_index in range(1, len(self.bts)):
+        for bts_index in range(1, self.simulator.LTE_MAX_CARRIERS):
             new_config = self.BtsConfig()
             new_config.incorporate(self.primary_config)
-            self.configure_bts(self.bts[bts_index], new_config)
+            self.simulator.configure_bts(new_config, bts_index)
             self.bts_configs.append(new_config)
 
         # Get LTE CA frequency bands setting from the test configuration
         if self.KEY_FREQ_BANDS not in test_config:
             self.log.warning("The key '{}' is not set in the config file. "
                              "Setting to null by default.".format(
-                self.KEY_FREQ_BANDS))
+                                 self.KEY_FREQ_BANDS))
 
         self.freq_bands = test_config.get(self.KEY_FREQ_BANDS, True)
 
-    def configure_bts(self, bts_handle, config):
-        """ Adds LTE with CA specific procedures. See parent class
-        implementation for more details.
-
-        Args:
-            bts_handle: a handle to the Anritsu base station controller.
-            config: a BtsConfig object containing the desired configuration.
-        """
-
-        # The callbox won't restore the band-dependent default values if the
-        # request is to switch to the same band as the one the base station is
-        # currently using. To ensure that default values are restored, go to a
-        # different band before switching.
-        if config.band and int(bts_handle.band) == config.band:
-            # Using bands 1 and 2 but it could be any others
-            bts_handle.band = '1' if config.band != 1 else '2'
-            # Switching to config.band will be handled by the parent class
-            # implementation of this method.
-
-        super().configure_bts(bts_handle, config)
+    def setup_simulator(self):
+        """ Do initial configuration in the simulator. """
+        self.simulator.setup_lte_ca_scenario()
 
     def parse_parameters(self, parameters):
         """ Configs an LTE simulation with CA using a list of parameters.
 
-        Calls the parent method first, then consumes parameters specific to LTE
-
         Args:
             parameters: list of parameters
         """
 
         # Enable all base stations initially. The ones that are not needed after
         # parsing the CA combo string can be removed.
-        self.anritsu.set_simulation_model(
-            BtsTechnology.LTE,
-            BtsTechnology.LTE,
-            BtsTechnology.LTE,
-            BtsTechnology.LTE,
-            reset=False)
+        self.anritsu.set_simulation_model(BtsTechnology.LTE,
+                                          BtsTechnology.LTE,
+                                          BtsTechnology.LTE,
+                                          BtsTechnology.LTE,
+                                          reset=False)
 
         # Create an empty array for new configuration objects. Elements will be
         # added to this list after parsing the CA configuration from the band
@@ -214,7 +188,7 @@
 
             if ca_class.upper() == 'A':
 
-                if bts_index >= len(self.bts):
+                if bts_index >= self.simulator.LTE_MAX_CARRIERS:
                     raise ValueError("This callbox model doesn't allow the "
                                      "requested CA configuration")
 
@@ -228,7 +202,7 @@
 
             elif ca_class.upper() == 'C':
 
-                if bts_index + 1 >= len(self.bts):
+                if bts_index + 1 >= self.simulator.LTE_MAX_CARRIERS:
                     raise ValueError("This callbox model doesn't allow the "
                                      "requested CA configuration")
 
@@ -355,7 +329,7 @@
                      for elem in LteSimulation.MimoMode})
 
             if (requested_mimo == LteSimulation.MimoMode.MIMO_4x4
-                    and self.anritsu._md8475_version == 'A'):
+                    and not self.simulator.LTE_SUPPORTS_4X4_MIMO):
                 raise ValueError("The test requires 4x4 MIMO, but that is not "
                                  "supported by the MD8475A callbox.")
 
@@ -436,16 +410,16 @@
                     "The '{}' parameter was not set, using 100% RBs for both "
                     "DL and UL. To set the percentages of total RBs include "
                     "the '{}' parameter followed by two ints separated by an "
-                    "underscore indicating downlink and uplink percentages."
-                    .format(self.PARAM_PATTERN, self.PARAM_PATTERN))
+                    "underscore indicating downlink and uplink percentages.".
+                    format(self.PARAM_PATTERN, self.PARAM_PATTERN))
                 dl_pattern = 100
                 ul_pattern = 100
             else:
                 dl_pattern = int(values[1])
                 ul_pattern = int(values[2])
 
-            if (dl_pattern, ul_pattern) not in [(0, 100), (100, 0), (100,
-                                                                     100)]:
+            if (dl_pattern, ul_pattern) not in [(0, 100), (100, 0),
+                                                (100, 100)]:
                 raise ValueError(
                     "Only full RB allocation for DL or UL is supported in CA "
                     "sims. The allowed combinations are 100/0, 0/100 and "
@@ -469,58 +443,30 @@
 
                 dl_rbs, ul_rbs = self.allocation_percentages_to_rbs(
                     new_configs[bts_index].bandwidth,
-                    new_configs[bts_index].transmission_mode,
-                    dl_pattern, ul_pattern)
+                    new_configs[bts_index].transmission_mode, dl_pattern,
+                    ul_pattern)
 
                 new_configs[bts_index].dl_rbs = dl_rbs
                 new_configs[bts_index].ul_rbs = ul_rbs
                 new_configs[bts_index].dl_mcs = mcs_dl
                 new_configs[bts_index].ul_mcs = mcs_ul
 
+        # Enable the configured base stations for CA
+        for bts_config in new_configs:
+            bts_config.dl_cc_enabled = True
+
         # Setup the base stations with the obtained configurations and then save
         # these parameters in the current configuration objects
         for bts_index in range(len(new_configs)):
-            self.configure_bts(self.bts[bts_index], new_configs[bts_index])
+            self.simulator.configure_bts(new_configs[bts_index], bts_index)
             self.bts_configs[bts_index].incorporate(new_configs[bts_index])
 
-    def start_test_case(self):
-        """ Attaches the phone to all the other basestations.
-
-        Starts the CA test case. Requires being attached to
-        basestation 1 first.
-
-        """
-
         # Trigger UE capability enquiry from network to get
         # UE supported CA band combinations. Here freq_bands is a hex string.
-
         self.anritsu.trigger_ue_capability_enquiry(self.freq_bands)
 
-        testcase = self.anritsu.get_AnritsuTestCases()
-        # Setting the procedure to selection is needed because of a bug in the
-        # instrument's software (b/139547391).
-        testcase.procedure = TestProcedure.PROCEDURE_SELECTION
-        testcase.procedure = TestProcedure.PROCEDURE_MULTICELL
-        testcase.power_control = TestPowerControl.POWER_CONTROL_DISABLE
-        testcase.measurement_LTE = TestMeasurement.MEASUREMENT_DISABLE
-
-        for bts_index in range(1, self.num_carriers):
-            self.bts[bts_index].dl_cc_enabled = True
-
-        self.anritsu.start_testcase()
-
-        retry_counter = 0
-        self.log.info("Waiting for the test case to start...")
-        time.sleep(5)
-
-        while self.anritsu.get_testcase_status() == "0":
-            retry_counter += 1
-            if retry_counter == 3:
-                raise RuntimeError("The test case failed to start after {} "
-                                   "retries. The connection between the phone "
-                                   "and the basestation might be unstable."
-                                   .format(retry_counter))
-            time.sleep(10)
+        # Now that the band is set, calibrate the link for the PCC if necessary
+        self.load_pathloss_if_required()
 
     def maximum_downlink_throughput(self):
         """ Calculates maximum downlink throughput as the sum of all the active
@@ -533,17 +479,20 @@
     def start(self):
         """ Set the signal level for the secondary carriers, as the base class
         implementation of this method will only set up downlink power for the
-        primary carrier component. """
+        primary carrier component.
+
+        After that, attaches the secondary carriers."""
 
         super().start()
 
-        if not self.sim_dl_power:
-            return
+        if self.sim_dl_power:
+            self.log.info('Setting DL power for secondary carriers.')
 
-        for bts_index in range(1, self.num_carriers):
-            self.log.info("Setting DL power for BTS{}.".format(bts_index + 1))
-            new_config = self.BtsConfig()
-            new_config.output_power = self.calibrated_downlink_rx_power(
-                self.bts_configs[bts_index], self.sim_dl_power)
-            self.configure_bts(self.bts[bts_index], new_config)
-            self.bts_configs[bts_index].incorporate(new_config)
+            for bts_index in range(1, self.num_carriers):
+                new_config = self.BtsConfig()
+                new_config.output_power = self.calibrated_downlink_rx_power(
+                    self.bts_configs[bts_index], self.sim_dl_power)
+                self.simulator.configure_bts(new_config, bts_index)
+                self.bts_configs[bts_index].incorporate(new_config)
+
+        self.simulator.lte_attach_secondary_carriers()
diff --git a/acts/framework/acts/test_utils/power/tel_simulations/LteImsSimulation.py b/acts/framework/acts/test_utils/power/tel_simulations/LteImsSimulation.py
index ecbd4b9..7110246 100644
--- a/acts/framework/acts/test_utils/power/tel_simulations/LteImsSimulation.py
+++ b/acts/framework/acts/test_utils/power/tel_simulations/LteImsSimulation.py
@@ -17,6 +17,7 @@
 import acts.test_utils.tel.anritsu_utils as anritsu_utils
 import acts.controllers.anritsu_lib.md8475a as md8475a
 
+
 class LteImsSimulation(LteSimulation):
 
     LTE_BASIC_SIM_FILE = 'VoLTE_ATT_Sim.wnssp'
diff --git a/acts/framework/acts/test_utils/power/tel_simulations/LteSimulation.py b/acts/framework/acts/test_utils/power/tel_simulations/LteSimulation.py
index 224cb67..c0cf063 100644
--- a/acts/framework/acts/test_utils/power/tel_simulations/LteSimulation.py
+++ b/acts/framework/acts/test_utils/power/tel_simulations/LteSimulation.py
@@ -14,28 +14,46 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
-import time
 import math
-import ntpath
 from enum import Enum
 
 from acts.controllers.anritsu_lib import md8475_cellular_simulator as anritsusim
-from acts.controllers.anritsu_lib.md8475a import BtsBandwidth
-from acts.controllers.anritsu_lib.md8475a import BtsPacketRate
 from acts.test_utils.power.tel_simulations.BaseSimulation import BaseSimulation
 from acts.test_utils.tel.tel_defines import NETWORK_MODE_LTE_ONLY
 
 
+class TransmissionMode(Enum):
+    """ Transmission modes for LTE (e.g., TM1, TM4, ...) """
+    TM1 = "TM1"
+    TM2 = "TM2"
+    TM3 = "TM3"
+    TM4 = "TM4"
+    TM7 = "TM7"
+    TM8 = "TM8"
+    TM9 = "TM9"
+
+
+class MimoMode(Enum):
+    """ Mimo modes """
+    MIMO_1x1 = "1x1"
+    MIMO_2x2 = "2x2"
+    MIMO_4x4 = "4x4"
+
+
+class SchedulingMode(Enum):
+    """ Traffic scheduling modes (e.g., STATIC, DYNAMIC) """
+    DYNAMIC = "DYNAMIC"
+    STATIC = "STATIC"
+
+
+class DuplexMode(Enum):
+    """ DL/UL Duplex mode """
+    FDD = "FDD"
+    TDD = "TDD"
+
+
 class LteSimulation(BaseSimulation):
-    """ Simple LTE simulation with only one basestation.
-
-    """
-
-    # Simulation config files in the callbox computer.
-    # These should be replaced in the future by setting up
-    # the same configuration manually.
-    LTE_BASIC_SIM_FILE = 'SIM_default_LTE.wnssp'
-    LTE_BASIC_CELL_FILE = 'CELL_LTE_config.wnscp'
+    """ Single-carrier LTE simulation. """
 
     # Simulation config keywords contained in the test name
     PARAM_FRAME_CONFIG = "tddconfig"
@@ -56,39 +74,6 @@
     KEY_DL_256_QAM = "256_qam_dl"
     KEY_UL_64_QAM = "64_qam_ul"
 
-    class TransmissionMode(Enum):
-        ''' Transmission modes for LTE (e.g., TM1, TM4, ..)
-
-        '''
-        TM1 = "TM1"
-        TM2 = "TM2"
-        TM3 = "TM3"
-        TM4 = "TM4"
-        TM7 = "TM7"
-        TM8 = "TM8"
-        TM9 = "TM9"
-
-    class MimoMode(Enum):
-        """ Mimo modes """
-
-        MIMO_1x1 = "1x1"
-        MIMO_2x2 = "2x2"
-        MIMO_4x4 = "4x4"
-
-    class SchedulingMode(Enum):
-        ''' Traffic scheduling modes (e.g., STATIC, DYNAMIC)
-
-        '''
-        DYNAMIC = "DYNAMIC"
-        STATIC = "STATIC"
-
-    class DuplexMode(Enum):
-        ''' DL/UL Duplex mode
-
-        '''
-        FDD = "FDD"
-        TDD = "TDD"
-
     # Units in which signal level is defined in DOWNLINK_SIGNAL_LEVEL_DICTIONARY
     DOWNLINK_SIGNAL_LEVEL_UNITS = "RSRP"
 
@@ -407,7 +392,6 @@
                 should be used or not
             dl_channel: an integer indicating the downlink channel number
         """
-
         def __init__(self):
             """ Initialize the base station config by setting all its
             parameters to None. """
@@ -426,9 +410,10 @@
             self.ul_modulation_order = None
             self.tbs_pattern_on = None
             self.dl_channel = None
+            self.dl_cc_enabled = None
 
     def __init__(self, simulator, log, dut, test_config, calibration_table):
-        """ Configures Anritsu system for LTE simulation with 1 basetation
+        """ Initializes the simulator for a single-carrier LTE simulation.
 
         Loads a simple LTE simulation enviroment with 1 basestation.
 
@@ -449,8 +434,6 @@
             raise ValueError('The LTE simulation relies on the simulator to '
                              'be an Anritsu MD8475 A/B instrument.')
 
-        self.anritsu = self.simulator.anritsu
-
         if not dut.droid.telephonySetPreferredNetworkTypesForSubscription(
                 NETWORK_MODE_LTE_ONLY,
                 dut.droid.subscriptionGetDefaultSubId()):
@@ -475,9 +458,9 @@
         self.dl_256_qam = test_config.get(self.KEY_DL_256_QAM, False)
 
         if self.dl_256_qam:
-            if self.anritsu._md8475_version == 'A':
-                self.log.warning("The key '{}' is set to true but MD8475A "
-                                 "callbox doesn't support that modulation "
+            if not self.simulator.LTE_SUPPORTS_DL_256QAM:
+                self.log.warning("The key '{}' is set to true but the "
+                                 "simulator doesn't support that modulation "
                                  "order.".format(self.KEY_DL_256_QAM))
                 self.dl_256_qam = False
             else:
@@ -492,103 +475,19 @@
         self.ul_64_qam = test_config.get(self.KEY_UL_64_QAM, False)
 
         if self.ul_64_qam:
-            if self.anritsu._md8475_version == 'A':
-                self.log.warning("The key '{}' is set to true but MD8475A "
-                                 "callbox doesn't support that modulation "
+            if not self.simulator.LTE_SUPPORTS_UL_64QAM:
+                self.log.warning("The key '{}' is set to true but the "
+                                 "simulator doesn't support that modulation "
                                  "order.".format(self.KEY_UL_64_QAM))
                 self.ul_64_qam = False
             else:
                 self.primary_config.ul_modulation_order = "64QAM"
 
-        self.configure_bts(self.bts1, self.primary_config)
+        self.simulator.configure_bts(self.primary_config)
 
-    def configure_bts(self, bts_handle, config):
-        """ Configures LTE parameters in the base station handle. See parent
-        class implementation for more details.
-
-        Args:
-            bts_handle: a handle to the Anritsu base station controller.
-            config: a BtsConfig object containing the desired configuration.
-        """
-
-        super().configure_bts(bts_handle, config)
-
-        if config.band:
-            # Only calibrate for the primary carrier band
-            isPcc = bts_handle == self.bts1
-            self.set_band(bts_handle,
-                          config.band,
-                          calibrate_if_necessary=isPcc)
-
-        if config.dlul_config:
-            self.set_dlul_configuration(bts_handle, config.dlul_config)
-
-        if config.bandwidth:
-            self.set_channel_bandwidth(bts_handle, config.bandwidth)
-
-        if config.dl_channel:
-            # Temporarily adding this line to workaround a bug in the
-            # Anritsu callbox in which the channel number needs to be set
-            # to a different value before setting it to the final one.
-            bts_handle.dl_channel = str(config.dl_channel)
-            time.sleep(8)
-            bts_handle.dl_channel = str(config.dl_channel - 1)
-
-        if config.mimo_mode:
-            self.set_mimo_mode(bts_handle, config.mimo_mode)
-
-        if config.transmission_mode:
-            self.set_transmission_mode(bts_handle, config.transmission_mode)
-
-        if config.scheduling_mode:
-
-            if (config.scheduling_mode == LteSimulation.SchedulingMode.STATIC
-                    and not all([
-                        config.dl_rbs, config.ul_rbs, config.dl_mcs,
-                        config.ul_mcs
-                    ])):
-                raise ValueError('When the scheduling mode is set to manual, '
-                                 'the RB and MCS parameters are required.')
-
-            # If scheduling mode is set to Dynamic, the RB and MCS parameters
-            # will be ignored by set_scheduling_mode.
-            self.set_scheduling_mode(bts_handle,
-                                     config.scheduling_mode,
-                                     packet_rate=BtsPacketRate.LTE_MANUAL,
-                                     nrb_dl=config.dl_rbs,
-                                     nrb_ul=config.ul_rbs,
-                                     mcs_ul=config.ul_mcs,
-                                     mcs_dl=config.dl_mcs)
-
-        if config.dl_modulation_order:
-            bts_handle.lte_dl_modulation_order = config.dl_modulation_order
-
-        if config.ul_modulation_order:
-            bts_handle.lte_u_modulation_order = config.ul_modulation_order
-
-        # This variable stores a boolean value so the following is needed to
-        # differentiate False from None
-        if config.tbs_pattern_on is not None:
-            if config.tbs_pattern_on:
-                bts_handle.tbs_pattern = "FULLALLOCATION"
-            else:
-                bts_handle.tbs_pattern = "OFF"
-
-    def load_config_files(self):
-        """ Loads configuration files for the simulation. """
-
-        cell_file_name = self.LTE_BASIC_CELL_FILE
-        sim_file_name = self.LTE_BASIC_SIM_FILE
-
-        if self.anritsu._md8475_version == 'B':
-            cell_file_name += '2'
-            sim_file_name += '2'
-
-        cell_file_path = ntpath.join(self.callbox_config_path, cell_file_name)
-        sim_file_path = ntpath.join(self.callbox_config_path, sim_file_name)
-
-        self.anritsu.load_simulation_paramfile(sim_file_path)
-        self.anritsu.load_cell_paramfile(cell_file_path)
+    def setup_simulator(self):
+        """ Do initial configuration in the simulator. """
+        self.simulator.setup_lte_scenario()
 
     def parse_parameters(self, parameters):
         """ Configs an LTE simulation using a list of parameters.
@@ -614,15 +513,16 @@
         new_config.band = values[1]
 
         # Set DL/UL frame configuration
-        if self.get_duplex_mode(new_config.band) == self.DuplexMode.TDD:
+        if self.get_duplex_mode(new_config.band) == DuplexMode.TDD:
 
             values = self.consume_parameter(parameters,
                                             self.PARAM_FRAME_CONFIG, 1)
             if not values:
-                raise ValueError("When a TDD band is selected the frame "
-                                 "structure has to be indicated with the '{}' "
-                                 "parameter followed by a number from 0 to 6."
-                                 .format(self.PARAM_FRAME_CONFIG))
+                raise ValueError(
+                    "When a TDD band is selected the frame "
+                    "structure has to be indicated with the '{}' "
+                    "parameter followed by a number from 0 to 6.".format(
+                        self.PARAM_FRAME_CONFIG))
 
             new_config.dlul_config = int(values[1])
 
@@ -652,7 +552,7 @@
                 "The test name needs to include parameter '{}' followed by the "
                 "mimo mode.".format(self.PARAM_MIMO))
 
-        for mimo_mode in LteSimulation.MimoMode:
+        for mimo_mode in MimoMode:
             if values[1] == mimo_mode.value:
                 new_config.mimo_mode = mimo_mode
                 break
@@ -660,10 +560,10 @@
             raise ValueError("The {} parameter needs to be followed by either "
                              "1x1, 2x2 or 4x4.".format(self.PARAM_MIMO))
 
-        if (new_config.mimo_mode == LteSimulation.MimoMode.MIMO_4x4
-                and self.anritsu._md8475_version == 'A'):
+        if (new_config.mimo_mode == MimoMode.MIMO_4x4
+                and not self.simulator.LTE_SUPPORTS_4X4_MIMO):
             raise ValueError("The test requires 4x4 MIMO, but that is not "
-                             "supported by the MD8475A callbox.")
+                             "supported by the cellular simulator.")
 
         # Setup transmission mode
 
@@ -675,7 +575,7 @@
                 "int value from 1 to 4 indicating transmission mode.".format(
                     self.PARAM_TM))
 
-        for tm in LteSimulation.TransmissionMode:
+        for tm in TransmissionMode:
             if values[1] == tm.value[2:]:
                 new_config.transmission_mode = tm
                 break
@@ -689,20 +589,20 @@
         values = self.consume_parameter(parameters, self.PARAM_SCHEDULING, 1)
 
         if not values:
-            new_config.scheduling_mode = LteSimulation.SchedulingMode.STATIC
+            new_config.scheduling_mode = SchedulingMode.STATIC
             self.log.warning(
                 "The test name does not include the '{}' parameter. Setting to "
                 "static by default.".format(self.PARAM_SCHEDULING))
         elif values[1] == self.PARAM_SCHEDULING_DYNAMIC:
-            new_config.scheduling_mode = LteSimulation.SchedulingMode.DYNAMIC
+            new_config.scheduling_mode = SchedulingMode.DYNAMIC
         elif values[1] == self.PARAM_SCHEDULING_STATIC:
-            new_config.scheduling_mode = LteSimulation.SchedulingMode.STATIC
+            new_config.scheduling_mode = SchedulingMode.STATIC
         else:
             raise ValueError(
                 "The test name parameter '{}' has to be followed by either "
                 "'dynamic' or 'static'.".format(self.PARAM_SCHEDULING))
 
-        if new_config.scheduling_mode == LteSimulation.SchedulingMode.STATIC:
+        if new_config.scheduling_mode == SchedulingMode.STATIC:
 
             values = self.consume_parameter(parameters, self.PARAM_PATTERN, 2)
 
@@ -711,8 +611,8 @@
                     "The '{}' parameter was not set, using 100% RBs for both "
                     "DL and UL. To set the percentages of total RBs include "
                     "the '{}' parameter followed by two ints separated by an "
-                    "underscore indicating downlink and uplink percentages."
-                    .format(self.PARAM_PATTERN, self.PARAM_PATTERN))
+                    "underscore indicating downlink and uplink percentages.".
+                    format(self.PARAM_PATTERN, self.PARAM_PATTERN))
                 dl_pattern = 100
                 ul_pattern = 100
             else:
@@ -725,10 +625,9 @@
                     "positive numbers between 0 and 100.")
 
             new_config.dl_rbs, new_config.ul_rbs = (
-                self.allocation_percentages_to_rbs(new_config.bandwidth,
-                                                   new_config.transmission_mode,
-                                                   dl_pattern,
-                                                   ul_pattern))
+                self.allocation_percentages_to_rbs(
+                    new_config.bandwidth, new_config.transmission_mode,
+                    dl_pattern, ul_pattern))
 
             if self.dl_256_qam and new_config.bandwidth == 1.4:
                 new_config.dl_mcs = 26
@@ -744,18 +643,20 @@
                 new_config.ul_mcs = 23
 
         # Setup LTE RRC status change function and timer for LTE idle test case
-
+        # TODO (b/141838145): setting RRC timer parameters requires unwrapping
+        # the simulator class as it still doesn't support these methods.
         values = self.consume_parameter(parameters,
                                         self.PARAM_RRC_STATUS_CHANGE_TIMER, 1)
         if not values:
             self.log.info(
                 "The test name does not include the '{}' parameter. Disabled "
                 "by default.".format(self.PARAM_RRC_STATUS_CHANGE_TIMER))
-            self.anritsu.set_lte_rrc_status_change(False)
+            self.simulator.anritsu.set_lte_rrc_status_change(False)
         else:
             self.rrc_sc_timer = int(values[1])
-            self.anritsu.set_lte_rrc_status_change(True)
-            self.anritsu.set_lte_rrc_status_change_timer(self.rrc_sc_timer)
+            self.simulator.anritsu.set_lte_rrc_status_change(True)
+            self.simulator.anritsu.set_lte_rrc_status_change_timer(
+                self.rrc_sc_timer)
 
         # Get uplink power
 
@@ -775,9 +676,12 @@
 
         # Setup the base station with the obtained configuration and then save
         # these parameters in the current configuration object
-        self.configure_bts(self.bts1, new_config)
+        self.simulator.configure_bts(new_config)
         self.primary_config.incorporate(new_config)
 
+        # Now that the band is set, calibrate the link if necessary
+        self.load_pathloss_if_required()
+
     def calibrated_downlink_rx_power(self, bts_config, rsrp):
         """ LTE simulation overrides this method so that it can convert from
         RSRP to total signal power transmitted from the basestation.
@@ -796,9 +700,7 @@
         # Use parent method to calculate signal level
         return super().calibrated_downlink_rx_power(bts_config, power)
 
-    def downlink_calibration(self,
-                             rat=None,
-                             power_units_conversion_func=None):
+    def downlink_calibration(self, rat=None, power_units_conversion_func=None):
         """ Computes downlink path loss and returns the calibration value.
 
         See base class implementation for details.
@@ -871,11 +773,11 @@
             Maximum throughput in mbps.
 
         """
-        if bts_config.mimo_mode == LteSimulation.MimoMode.MIMO_1x1:
+        if bts_config.mimo_mode == MimoMode.MIMO_1x1:
             streams = 1
-        elif bts_config.mimo_mode == LteSimulation.MimoMode.MIMO_2x2:
+        elif bts_config.mimo_mode == MimoMode.MIMO_2x2:
             streams = 1
-        elif bts_config.mimo_mode == LteSimulation.MimoMode.MIMO_4x4:
+        elif bts_config.mimo_mode == MimoMode.MIMO_4x4:
             streams = 1
         else:
             raise ValueError('Unable to calculate maximum downlink throughput '
@@ -890,25 +792,29 @@
         tdd_subframe_config = bts_config.dlul_config
         duplex_mode = self.get_duplex_mode(bts_config.band)
 
-        if duplex_mode == self.DuplexMode.TDD.value:
+        if duplex_mode == DuplexMode.TDD.value:
             if self.dl_256_qam:
                 if mcs == "27":
                     if bts_config.tbs_pattern_on:
                         max_rate_per_stream = self.tdd_config_tput_lut_dict[
-                            'TDD_CONFIG3'][tdd_subframe_config][bandwidth]['DL']
+                            'TDD_CONFIG3'][tdd_subframe_config][bandwidth][
+                                'DL']
                     else:
                         max_rate_per_stream = self.tdd_config_tput_lut_dict[
-                            'TDD_CONFIG2'][tdd_subframe_config][bandwidth]['DL']
+                            'TDD_CONFIG2'][tdd_subframe_config][bandwidth][
+                                'DL']
             else:
                 if mcs == "28":
                     if bts_config.tbs_pattern_on:
                         max_rate_per_stream = self.tdd_config_tput_lut_dict[
-                            'TDD_CONFIG4'][tdd_subframe_config][bandwidth]['DL']
+                            'TDD_CONFIG4'][tdd_subframe_config][bandwidth][
+                                'DL']
                     else:
                         max_rate_per_stream = self.tdd_config_tput_lut_dict[
-                            'TDD_CONFIG1'][tdd_subframe_config][bandwidth]['DL']
+                            'TDD_CONFIG1'][tdd_subframe_config][bandwidth][
+                                'DL']
 
-        elif duplex_mode == self.DuplexMode.FDD.value:
+        elif duplex_mode == DuplexMode.FDD.value:
             if (not self.dl_256_qam and bts_config.tbs_pattern_on
                     and mcs == "28"):
                 max_rate_per_stream = {
@@ -919,7 +825,7 @@
                     20: 72.2
                 }.get(bandwidth, None)
             if (not self.dl_256_qam and bts_config.tbs_pattern_on
-                    and mcs ==  "27"):
+                    and mcs == "27"):
                 max_rate_per_stream = {
                     1.4: 2.94,
                 }.get(bandwidth, None)
@@ -1001,25 +907,29 @@
         tdd_subframe_config = bts_config.dlul_config
         duplex_mode = self.get_duplex_mode(bts_config.band)
 
-        if duplex_mode == self.DuplexMode.TDD.value:
+        if duplex_mode == DuplexMode.TDD.value:
             if self.ul_64_qam:
                 if mcs == "28":
                     if bts_config.tbs_pattern_on:
                         max_rate_per_stream = self.tdd_config_tput_lut_dict[
-                            'TDD_CONFIG3'][tdd_subframe_config][bandwidth]['UL']
+                            'TDD_CONFIG3'][tdd_subframe_config][bandwidth][
+                                'UL']
                     else:
                         max_rate_per_stream = self.tdd_config_tput_lut_dict[
-                            'TDD_CONFIG2'][tdd_subframe_config][bandwidth]['UL']
+                            'TDD_CONFIG2'][tdd_subframe_config][bandwidth][
+                                'UL']
             else:
                 if mcs == "23":
                     if bts_config.tbs_pattern_on:
                         max_rate_per_stream = self.tdd_config_tput_lut_dict[
-                            'TDD_CONFIG4'][tdd_subframe_config][bandwidth]['UL']
+                            'TDD_CONFIG4'][tdd_subframe_config][bandwidth][
+                                'UL']
                     else:
                         max_rate_per_stream = self.tdd_config_tput_lut_dict[
-                            'TDD_CONFIG1'][tdd_subframe_config][bandwidth]['UL']
+                            'TDD_CONFIG1'][tdd_subframe_config][bandwidth][
+                                'UL']
 
-        elif duplex_mode == self.DuplexMode.FDD.value:
+        elif duplex_mode == DuplexMode.FDD.value:
             if mcs == "23" and not self.ul_64_qam:
                 max_rate_per_stream = {
                     1.4: 2.85,
@@ -1047,132 +957,6 @@
 
         return max_rate_per_stream * rb_ratio
 
-    def set_transmission_mode(self, bts, tmode):
-        """ Sets the transmission mode for the LTE basetation
-
-        Args:
-            bts: basestation handle
-            tmode: Enum list from class 'TransmissionModeLTE'
-        """
-
-        # If the selected transmission mode does not support the number of DL
-        # antennas, throw an exception.
-        if (tmode in [self.TransmissionMode.TM1, self.TransmissionMode.TM7]
-                and bts.dl_antenna != '1'):
-            # TM1 and TM7 only support 1 DL antenna
-            raise ValueError("{} allows only one DL antenna. Change the "
-                             "number of DL antennas before setting the "
-                             "transmission mode.".format(tmode.value))
-        elif tmode == self.TransmissionMode.TM8 and bts.dl_antenna != '2':
-            # TM8 requires 2 DL antennas
-            raise ValueError("TM2 requires two DL antennas. Change the "
-                             "number of DL antennas before setting the "
-                             "transmission mode.")
-        elif (tmode in [
-                self.TransmissionMode.TM2, self.TransmissionMode.TM3,
-                self.TransmissionMode.TM4, self.TransmissionMode.TM9
-        ] and bts.dl_antenna == '1'):
-            # TM2, TM3, TM4 and TM9 require 2 or 4 DL antennas
-            raise ValueError("{} requires at least two DL atennas. Change the "
-                             "number of DL antennas before setting the "
-                             "transmission mode.".format(tmode.value))
-
-        # The TM mode is allowed for the current number of DL antennas, so it
-        # is safe to change this setting now
-        bts.transmode = tmode.value
-
-        time.sleep(5)  # It takes some time to propagate the new settings
-
-    def set_mimo_mode(self, bts, mimo):
-        """ Sets the number of DL antennas for the desired MIMO mode.
-
-        Args:
-            bts: basestation handle
-            mimo: object of class MimoMode
-        """
-
-        # If the requested mimo mode is not compatible with the current TM,
-        # warn the user before changing the value.
-
-        if mimo == self.MimoMode.MIMO_1x1:
-            if bts.transmode not in [
-                    self.TransmissionMode.TM1, self.TransmissionMode.TM7
-            ]:
-                self.log.warning(
-                    "Using only 1 DL antennas is not allowed with "
-                    "the current transmission mode. Changing the "
-                    "number of DL antennas will override this "
-                    "setting.")
-            bts.dl_antenna = 1
-        elif mimo == self.MimoMode.MIMO_2x2:
-            if bts.transmode not in [
-                    self.TransmissionMode.TM2, self.TransmissionMode.TM3,
-                    self.TransmissionMode.TM4, self.TransmissionMode.TM8,
-                    self.TransmissionMode.TM9
-            ]:
-                self.log.warning("Using two DL antennas is not allowed with "
-                                 "the current transmission mode. Changing the "
-                                 "number of DL antennas will override this "
-                                 "setting.")
-            bts.dl_antenna = 2
-        elif mimo == self.MimoMode.MIMO_4x4:
-            if bts.transmode not in [
-                    self.TransmissionMode.TM2, self.TransmissionMode.TM3,
-                    self.TransmissionMode.TM4, self.TransmissionMode.TM9
-            ]:
-                self.log.warning("Using four DL antennas is not allowed with "
-                                 "the current transmission mode. Changing the "
-                                 "number of DL antennas will override this "
-                                 "setting.")
-
-            bts.dl_antenna = 4
-        else:
-            RuntimeError("The requested MIMO mode is not supported.")
-
-    def set_scheduling_mode(self,
-                            bts,
-                            scheduling,
-                            packet_rate=None,
-                            mcs_dl=None,
-                            mcs_ul=None,
-                            nrb_dl=None,
-                            nrb_ul=None):
-        """ Sets the scheduling mode for LTE
-
-        Args:
-            bts: basestation handle
-            scheduling: DYNAMIC or STATIC scheduling (Enum list)
-            mcs_dl: Downlink MCS (only for STATIC scheduling)
-            mcs_ul: Uplink MCS (only for STATIC scheduling)
-            nrb_dl: Number of RBs for downlink (only for STATIC scheduling)
-            nrb_ul: Number of RBs for uplink (only for STATIC scheduling)
-        """
-
-        bts.lte_scheduling_mode = scheduling.value
-
-        if scheduling == self.SchedulingMode.STATIC:
-
-            if not packet_rate:
-                raise RuntimeError("Packet rate needs to be indicated when "
-                                   "selecting static scheduling.")
-
-            bts.packet_rate = packet_rate
-
-            if packet_rate == BtsPacketRate.LTE_MANUAL:
-
-                if not (mcs_dl and mcs_ul and nrb_dl and nrb_ul):
-                    raise RuntimeError("When using manual packet rate the "
-                                       "number of dl/ul RBs and the dl/ul "
-                                       "MCS needs to be indicated with the "
-                                       "optional arguments.")
-
-                bts.lte_mcs_dl = mcs_dl
-                bts.lte_mcs_ul = mcs_ul
-                bts.nrb_dl = nrb_dl
-                bts.nrb_ul = nrb_ul
-
-        time.sleep(5)  # It takes some time to propagate the new settings
-
     def allocation_percentages_to_rbs(self, bw, tm, dl, ul):
         """ Converts usage percentages to number of DL/UL RBs
 
@@ -1217,10 +1001,11 @@
 
         # Get the number of DL RBs that corresponds to
         #  the required percentage.
-        desired_dl_rbs = percentage_to_amount(
-            min_val=min_dl_rbs, max_val=max_rbs, percentage=dl)
+        desired_dl_rbs = percentage_to_amount(min_val=min_dl_rbs,
+                                              max_val=max_rbs,
+                                              percentage=dl)
 
-        if tm == self.TransmissionMode.TM3 or tm == self.TransmissionMode.TM4:
+        if tm == TransmissionMode.TM3 or tm == TransmissionMode.TM4:
 
             # For TM3 and TM4 the number of DL RBs needs to be max_rbs or a
             # multiple of the RBG size
@@ -1239,8 +1024,9 @@
 
         # Get the number of UL RBs that corresponds
         # to the required percentage
-        desired_ul_rbs = percentage_to_amount(
-            min_val=min_ul_rbs, max_val=max_rbs, percentage=ul)
+        desired_ul_rbs = percentage_to_amount(min_val=min_ul_rbs,
+                                              max_val=max_rbs,
+                                              percentage=ul)
 
         # Create a list of all possible UL RBs assignment
         # The standard allows any number that can be written as
@@ -1270,60 +1056,6 @@
 
         return dl_rbs, ul_rbs
 
-    def set_channel_bandwidth(self, bts, bandwidth):
-        """ Sets the LTE channel bandwidth (MHz)
-
-        Args:
-            bts: basestation handle
-            bandwidth: desired bandwidth (MHz)
-        """
-        if bandwidth == 20:
-            bts.bandwidth = BtsBandwidth.LTE_BANDWIDTH_20MHz
-        elif bandwidth == 15:
-            bts.bandwidth = BtsBandwidth.LTE_BANDWIDTH_15MHz
-        elif bandwidth == 10:
-            bts.bandwidth = BtsBandwidth.LTE_BANDWIDTH_10MHz
-        elif bandwidth == 5:
-            bts.bandwidth = BtsBandwidth.LTE_BANDWIDTH_5MHz
-        elif bandwidth == 3:
-            bts.bandwidth = BtsBandwidth.LTE_BANDWIDTH_3MHz
-        elif bandwidth == 1.4:
-            bts.bandwidth = BtsBandwidth.LTE_BANDWIDTH_1dot4MHz
-        else:
-            msg = "Bandwidth = {} MHz is not valid for LTE".format(bandwidth)
-            self.log.error(msg)
-            raise ValueError(msg)
-        time.sleep(5)  # It takes some time to propagate the new settings
-
-    def get_bandwidth(self, bts):
-        """ Obtains bandwidth in MHz for a base station. The Anritsu callbox
-        returns a string that needs to be mapped to the right number.
-
-        Args:
-            bts: base station handle
-
-        Returns:
-            the channel bandwidth in MHz
-        """
-
-        return BtsBandwidth.get_float_value(bts.bandwidth)
-
-    def set_dlul_configuration(self, bts, config):
-        """ Sets the frame structure for TDD bands.
-
-        Args:
-            config: the desired frame structure. An int between 0 and 6.
-        """
-
-        if not 0 <= config <= 6:
-            raise ValueError("The frame structure configuration has to be a "
-                             "number between 0 and 6")
-
-        bts.uldl_configuration = config
-
-        # Wait for the setting to propagate
-        time.sleep(5)
-
     def calibrate(self, band):
         """ Calculates UL and DL path loss if it wasn't done before
 
@@ -1342,17 +1074,17 @@
 
         # Set up a temporary calibration configuration.
         temporary_config = self.BtsConfig()
-        temporary_config.mimo_mode = LteSimulation.MimoMode.MIMO_1x1
-        temporary_config.transmission_mode = LteSimulation.TransmissionMode.TM1
+        temporary_config.mimo_mode = MimoMode.MIMO_1x1
+        temporary_config.transmission_mode = TransmissionMode.TM1
         temporary_config.bandwidth = max(
             self.allowed_bandwidth_dictionary[int(band)])
-        self.configure_bts(self.bts1, temporary_config)
+        self.simulator.configure_bts(temporary_config)
         self.primary_config.incorporate(temporary_config)
 
         super().calibrate(band)
 
         # Restore values as they were before changing them for calibration.
-        self.configure_bts(self.bts1, restore_config)
+        self.simulator.configure_bts(restore_config)
         self.primary_config.incorporate(restore_config)
 
     def start_traffic_for_calibration(self):
@@ -1380,19 +1112,6 @@
         """
 
         if 33 <= int(band) <= 46:
-            return self.DuplexMode.TDD
+            return DuplexMode.TDD
         else:
-            return self.DuplexMode.FDD
-
-    def set_band(self, bts, band, calibrate_if_necessary=True):
-        """ Sets the right duplex mode before switching to a new band.
-
-        Args:
-            bts: basestation handle
-            band: desired band
-            calibrate_if_necessary: if False calibration will be skipped
-        """
-
-        bts.duplex_mode = self.get_duplex_mode(band).value
-
-        super().set_band(bts, band, calibrate_if_necessary)
+            return DuplexMode.FDD
diff --git a/acts/framework/acts/test_utils/power/tel_simulations/UmtsSimulation.py b/acts/framework/acts/test_utils/power/tel_simulations/UmtsSimulation.py
index d136f84..4d4aeeb 100644
--- a/acts/framework/acts/test_utils/power/tel_simulations/UmtsSimulation.py
+++ b/acts/framework/acts/test_utils/power/tel_simulations/UmtsSimulation.py
@@ -15,17 +15,17 @@
 #   limitations under the License.
 
 import ntpath
+import time
 
 from acts.controllers.anritsu_lib import md8475_cellular_simulator as anritsusim
+from acts.controllers.anritsu_lib.md8475a import BtsNumber
 from acts.controllers.anritsu_lib.md8475a import BtsPacketRate
 from acts.test_utils.power.tel_simulations.BaseSimulation import BaseSimulation
 from acts.test_utils.tel.tel_defines import NETWORK_MODE_WCDMA_ONLY
 
 
 class UmtsSimulation(BaseSimulation):
-    """ Simple UMTS simulation with only one basestation.
-
-    """
+    """ Single base station simulation. """
 
     # Simulation config files in the callbox computer.
     # These should be replaced in the future by setting up
@@ -90,7 +90,7 @@
     }
 
     def __init__(self, simulator, log, dut, test_config, calibration_table):
-        """ Configures Anritsu system for UMTS simulation with 1 basetation
+        """ Initializes the cellular simulator for a UMTS simulation.
 
         Loads a simple UMTS simulation enviroment with 1 basestation. It also
         creates the BTS handle so we can change the parameters as desired.
@@ -104,15 +104,18 @@
                 different bands.
 
         """
-
-        super().__init__(simulator, log, dut, test_config, calibration_table)
-
         # The UMTS simulation relies on the cellular simulator to be a MD8475
         if not isinstance(self.simulator, anritsusim.MD8475CellularSimulator):
             raise ValueError('The UMTS simulation relies on the simulator to '
                              'be an Anritsu MD8475 A/B instrument.')
 
+        # The Anritsu controller needs to be unwrapped before calling
+        # super().__init__ because setup_simulator() requires self.anritsu and
+        # will be called during the parent class initialization.
         self.anritsu = self.simulator.anritsu
+        self.bts1 = self.anritsu.get_BTS(BtsNumber.BTS1)
+
+        super().__init__(simulator, log, dut, test_config, calibration_table)
 
         if not dut.droid.telephonySetPreferredNetworkTypesForSubscription(
                 NETWORK_MODE_WCDMA_ONLY,
@@ -124,11 +127,18 @@
         self.release_version = None
         self.packet_rate = None
 
-    def load_config_files(self):
-        """ Loads configuration files for the simulation. """
+    def setup_simulator(self):
+        """ Do initial configuration in the simulator. """
+
+        # Load callbox config files
+        callbox_config_path = self.CALLBOX_PATH_FORMAT_STR.format(
+            self.anritsu._md8475_version)
 
         self.anritsu.load_simulation_paramfile(
-            ntpath.join(self.callbox_config_path, self.UMTS_BASIC_SIM_FILE))
+            ntpath.join(callbox_config_path, self.UMTS_BASIC_SIM_FILE))
+
+        # Start simulation if it wasn't started
+        self.anritsu.start_simulation()
 
     def parse_parameters(self, parameters):
         """ Configs an UMTS simulation using a list of parameters.
@@ -149,6 +159,7 @@
                 "the required band number.".format(self.PARAM_BAND))
 
         self.set_band(self.bts1, values[1])
+        self.load_pathloss_if_required()
 
         # Setup release version
 
@@ -279,3 +290,14 @@
 
         # Stop IP traffic after setting the signal level
         self.stop_traffic_for_calibration()
+
+    def set_band(self, bts, band):
+        """ Sets the band used for communication.
+
+        Args:
+            bts: basestation handle
+            band: desired band
+        """
+
+        bts.band = band
+        time.sleep(5)  # It takes some time to propagate the new band
diff --git a/acts/framework/acts/test_utils/power/tel_simulations/__init__.py b/acts/framework/acts/test_utils/power/tel_simulations/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/acts/framework/acts/test_utils/power/tel_simulations/__init__.py
diff --git a/acts/framework/acts/test_utils/tel/TelephonyBaseTest.py b/acts/framework/acts/test_utils/tel/TelephonyBaseTest.py
index dbdcf7f..b4b40ed 100644
--- a/acts/framework/acts/test_utils/tel/TelephonyBaseTest.py
+++ b/acts/framework/acts/test_utils/tel/TelephonyBaseTest.py
@@ -103,7 +103,7 @@
             self.test_id = test_id
             self.result_detail = ""
             self.testsignal_details = ""
-            self.testsignal_extras = ""
+            self.testsignal_extras = {}
             tries = int(self.user_params.get("telephony_auto_rerun", 1))
             for ad in self.android_devices:
                 ad.log_path = self.log_path
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 0c26235..a4cb3f2 100644
--- a/acts/framework/acts/test_utils/tel/tel_test_utils.py
+++ b/acts/framework/acts/test_utils/tel/tel_test_utils.py
@@ -1567,6 +1567,9 @@
         else:
             return True
     finally:
+        if hasattr(ad, "sdm_log") and getattr(ad, "sdm_log"):
+            ad.adb.shell("i2cset -fy 3 64 6 1 b", ignore_status=True)
+            ad.adb.shell("i2cset -fy 3 65 6 1 b", ignore_status=True)
         ad.droid.telephonyStopTrackingCallStateChangeForSubscription(sub_id)
         if incall_ui_display == INCALL_UI_DISPLAY_FOREGROUND:
             ad.droid.telecomShowInCallScreen()
@@ -3216,7 +3219,7 @@
 def phone_switch_to_msim_mode(ad, retries=3, timeout=60):
     result = False
     if not ad.is_apk_installed("com.google.mdstest"):
-        raise signals.TestSkipClass("mdstest is not installed")
+        raise signals.TestAbortClass("mdstest is not installed")
     mode = ad.droid.telephonyGetPhoneCount()
     if mode == 2:
         ad.log.info("Device already in MSIM mode")
@@ -3259,7 +3262,7 @@
 def phone_switch_to_ssim_mode(ad, retries=3, timeout=30):
     result = False
     if not ad.is_apk_installed("com.google.mdstest"):
-        raise signals.TestSkipClass("mdstest is not installed")
+        raise signals.TestAbortClass("mdstest is not installed")
     mode = ad.droid.telephonyGetPhoneCount()
     if mode == 1:
         ad.log.info("Device already in SSIM mode")
@@ -3738,17 +3741,18 @@
             If None, opposite of the current state.
 
     """
-    # TODO: b/26293960 No framework API available to set IMS by SubId.
-    if not ad.droid.imsIsEnhanced4gLteModeSettingEnabledByPlatform():
-        ad.log.info("Enhanced 4G Lte Mode Setting is not enabled by platform.")
-        return False
-    current_state = ad.droid.imsIsEnhanced4gLteModeSettingEnabledByUser()
+    current_state = ad.droid.imsMmTelIsAdvancedCallingEnabled(sub_id)
     if new_state is None:
         new_state = not current_state
     if new_state != current_state:
-        ad.log.info("Toggle Enhanced 4G LTE Mode from %s to %s", current_state,
-                    new_state)
-        ad.droid.imsSetEnhanced4gMode(new_state)
+        ad.log.info("Toggle Enhanced 4G LTE Mode from %s to %s on sub_id %s", current_state,
+                    new_state, sub_id)
+        ad.droid.imsMmTelSetAdvancedCallingEnabled(sub_id, new_state)
+    check_state = ad.droid.imsMmTelIsAdvancedCallingEnabled(sub_id)
+    if check_state != new_state:
+        ad.log.error("Failed to toggle Enhanced 4G LTE Mode to %s, still set to %s on sub_id %s",
+                     new_state, check_state, sub_id)
+        return False
     return True
 
 
@@ -6660,7 +6664,7 @@
             if ad.is_sl4a_installed():
                 break
             ad.log.info("Re-install sl4a")
-            ad.adb.shell("settings put global package_verifier_enable 0")
+            ad.adb.shell("settings put global verifier_verify_adb_installs 0")
             ad.adb.install("-r /tmp/base.apk")
             time.sleep(10)
             break
diff --git a/acts/framework/acts/test_utils/wifi/wifi_performance_test_utils.py b/acts/framework/acts/test_utils/wifi/wifi_performance_test_utils.py
index e71748e..18c50a5 100644
--- a/acts/framework/acts/test_utils/wifi/wifi_performance_test_utils.py
+++ b/acts/framework/acts/test_utils/wifi/wifi_performance_test_utils.py
@@ -16,6 +16,8 @@
 
 import bokeh, bokeh.plotting
 import collections
+import itertools
+import json
 import logging
 import math
 import re
@@ -185,102 +187,6 @@
             self.llstats_cumulative)
 
 
-# Dashboard utilities
-class BlackboxMappedMetricLogger(MetricLogger):
-    """A MetricLogger for logging and publishing Blackbox metrics from a dict.
-
-    The dict maps the metric name to the metric value. For additional
-    information on reporting to Blackbox, see BlackBoxMetricLogger.
-
-    Attributes:
-        proto_module: The proto module for ActsBlackboxMetricResult.
-        metric_key: The metric key to use. If unset, the logger will use the
-                    context's identifier.
-    """
-
-    PROTO_FILE = '../../metrics/loggers/protos/acts_blackbox.proto'
-
-    def __init__(self, metric_key=None, event=None):
-        """Initializes a logger for Blackbox metrics.
-
-        Args:
-            metric_key: The metric key to use. If unset, the logger will use
-                        the context's identifier.
-            event: The event triggering the creation of this logger.
-        """
-        super().__init__(event=event)
-        self.proto_module = self._compile_proto(self.PROTO_FILE)
-        self.metric_key = metric_key
-        self._metric_map = {}
-
-    def _get_metric_key(self, metric_name):
-        """Gets the metric key to use.
-
-        If the metric_key is explicitly set, returns that value. Otherwise,
-        extracts an identifier from the context.
-
-        Args:
-            metric_name: The name of the metric to report.
-        """
-        if self.metric_key:
-            key = self.metric_key
-        else:
-            key = self._get_blackbox_identifier()
-        key = '%s.%s' % (key, metric_name)
-        return key
-
-    def set_metric_data(self, metric_map):
-        """Sets the map of metrics to be uploaded to Blackbox. Note that
-        this will overwrite all existing added by this function or add_metric.
-
-        Args:
-            metric_map: the map of metric_name -> metric_value to publish
-                to blackbox. If the metric value is set to None, the
-                metric will not be reported.
-        """
-        self._metric_map = metric_map
-
-    def add_metric(self, metric_name, metric_value):
-        """Adds a metric value to be published later.
-
-        Note that if the metric name has already been added, the metric value
-        will be overwritten.
-
-        Args:
-            metric_name: the name of the metric.
-            metric_value: the value of the metric.
-        """
-        self._metric_map[metric_name] = metric_value
-
-    def _get_blackbox_identifier(self):
-        """Returns the testcase identifier, as expected by Blackbox."""
-        # b/119787228: Blackbox requires function names to look like Java
-        # functions.
-        identifier = self.context.identifier
-        parts = identifier.rsplit('.', 1)
-        return '#'.join(parts)
-
-    def end(self, _):
-        """Creates and publishes a ProtoMetric with blackbox data.
-
-        Builds a list of ActsBlackboxMetricResult messages from the set
-        metric data, and sends them to the publisher.
-        """
-        metrics = []
-        for metric_name, metric_value in self._metric_map.items():
-            if metric_value is None:
-                continue
-            result = self.proto_module.ActsBlackboxMetricResult()
-            result.test_identifier = self._get_blackbox_identifier()
-            result.metric_key = self._get_metric_key(metric_name)
-            result.metric_value = metric_value
-
-            metrics.append(
-                ProtoMetric(name='blackbox_%s' % metric_name, data=result))
-
-        return self.publisher.publish(metrics)
-
-
 # JSON serializer
 def serialize_dict(input_dict):
     """Function to serialize dicts to enable JSON output"""
@@ -343,23 +249,23 @@
     def __init__(self,
                  title=None,
                  x_label=None,
-                 primary_y=None,
-                 secondary_y=None,
+                 primary_y_label=None,
+                 secondary_y_label=None,
                  height=700,
                  width=1300,
-                 title_size=15,
-                 axis_label_size=12):
+                 title_size='15pt',
+                 axis_label_size='12pt'):
         self.figure_data = []
         self.fig_property = {
             'title': title,
             'x_label': x_label,
-            'primary_y_label': primary_y,
-            'secondary_y_label': secondary_y,
+            'primary_y_label': primary_y_label,
+            'secondary_y_label': secondary_y_label,
             'num_lines': 0,
             'height': height,
             'width': width,
-            'title_size': '{}pt'.format(title_size),
-            'axis_label_size': '{}pt'.format(axis_label_size)
+            'title_size': title_size,
+            'axis_label_size': axis_label_size
         }
         self.TOOLS = (
             'box_zoom,box_select,pan,crosshair,redo,undo,reset,hover,save')
@@ -382,6 +288,18 @@
         self.plot.add_tools(
             bokeh.models.tools.WheelZoomTool(dimensions='height'))
 
+    def _filter_line(self, x_data, y_data, hover_text=None):
+        """Function to remove NaN points from bokeh plots."""
+        x_data_filtered = []
+        y_data_filtered = []
+        hover_text_filtered = []
+        for x, y, hover in itertools.zip_longest(x_data, y_data, hover_text):
+            if not math.isnan(y):
+                x_data_filtered.append(x)
+                y_data_filtered.append(y)
+                hover_text_filtered.append(hover)
+        return x_data_filtered, y_data_filtered, hover_text_filtered
+
     def add_line(self,
                  x_data,
                  y_data,
@@ -417,18 +335,20 @@
             style = [5, 5]
         if not hover_text:
             hover_text = ['y={}'.format(y) for y in y_data]
+        x_data_filter, y_data_filter, hover_text_filter = self._filter_line(
+            x_data, y_data, hover_text)
         self.figure_data.append({
-            'x_data': x_data,
-            'y_data': y_data,
+            'x_data': x_data_filter,
+            'y_data': y_data_filter,
             'legend': legend,
-            'hover_text': hover_text,
+            'hover_text': hover_text_filter,
             'color': color,
             'width': width,
             'style': style,
             'marker': marker,
             'marker_size': marker_size,
             'shaded_region': shaded_region,
-            'y_range_name': y_axis
+            'y_axis': y_axis
         })
         self.fig_property['num_lines'] += 1
 
@@ -473,7 +393,7 @@
             'marker': marker,
             'marker_size': marker_size,
             'shaded_region': None,
-            'y_range_name': y_axis
+            'y_axis': y_axis
         })
         self.fig_property['num_lines'] += 1
 
@@ -499,8 +419,8 @@
                     line_width=line['width'],
                     color=line['color'],
                     line_dash=line['style'],
-                    name=line['y_range_name'],
-                    y_range_name=line['y_range_name'],
+                    name=line['y_axis'],
+                    y_range_name=line['y_axis'],
                     source=source)
             if line['shaded_region']:
                 band_x = line['shaded_region']['x_vector']
@@ -522,10 +442,10 @@
                     legend=line['legend'],
                     line_color=line['color'],
                     fill_color=line['color'],
-                    name=line['y_range_name'],
-                    y_range_name=line['y_range_name'],
+                    name=line['y_axis'],
+                    y_range_name=line['y_axis'],
                     source=source)
-            if line['y_range_name'] == 'secondary':
+            if line['y_axis'] == 'secondary':
                 two_axes = True
 
         #x-axis formatting
@@ -554,10 +474,20 @@
         self.plot.title.text_font_size = self.fig_property['title_size']
 
         if output_file is not None:
-            bokeh.plotting.output_file(output_file)
-            bokeh.plotting.save(self.plot)
+            self.save_figure(output_file)
         return self.plot
 
+    def _save_figure_json(self, output_file):
+        """Function to save a json format of a figure"""
+        figure_dict = collections.OrderedDict(
+            fig_property=self.fig_property,
+            figure_data=self.figure_data,
+            tools=self.TOOLS,
+            tooltips=self.TOOLTIPS)
+        output_file = output_file.replace('.html', '_plot_data.json')
+        with open(output_file, 'w') as outfile:
+            json.dump(figure_dict, outfile, indent=4)
+
     def save_figure(self, output_file):
         """Function to save BokehFigure.
 
@@ -566,6 +496,7 @@
         """
         bokeh.plotting.output_file(output_file)
         bokeh.plotting.save(self.plot)
+        self._save_figure_json(output_file)
 
     @staticmethod
     def save_figures(figure_array, output_file_path):
@@ -575,8 +506,11 @@
             figure_array: list of BokehFigure object to be plotted
             output_file: string specifying output file path
         """
-        for figure in figure_array:
+        for idx, figure in enumerate(figure_array):
             figure.generate_figure()
+            json_file_path = output_file_path.replace(
+                '.html', '{}-plot_data.json'.format(idx))
+            figure._save_figure_json(json_file_path)
         plot_array = [figure.plot for figure in figure_array]
         all_plots = bokeh.layouts.column(children=plot_array)
         bokeh.plotting.output_file(output_file_path)
@@ -709,23 +643,22 @@
     Returns:
         ping_result: dict containing ping results and other meta data
     """
-    ping_count = int(ping_duration/ping_interval)
-    ping_deadline = int(ping_count*ping_interval)+1
+    ping_count = int(ping_duration / ping_interval)
+    ping_deadline = int(ping_count * ping_interval) + 1
     ping_cmd = 'ping -c {} -w {} -i {} -s {} -D'.format(
         ping_count,
         ping_deadline,
         ping_interval,
         ping_size,
     )
-    start_time = time.time()
     if isinstance(src_device, AndroidDevice):
         ping_cmd = '{} {}'.format(ping_cmd, dest_address)
         ping_output = src_device.adb.shell(
-            ping_cmd, timeout=ping_deadline+SHORT_SLEEP, ignore_status=True)
+            ping_cmd, timeout=ping_deadline + SHORT_SLEEP, ignore_status=True)
     elif isinstance(src_device, ssh.connection.SshConnection):
         ping_cmd = 'sudo {} {}'.format(ping_cmd, dest_address)
         ping_output = src_device.run(
-            ping_cmd, timeout=ping_deadline+SHORT_SLEEP,
+            ping_cmd, timeout=ping_deadline + SHORT_SLEEP,
             ignore_status=True).stdout
     else:
         raise TypeError(
diff --git a/acts/framework/tests/acts_test_decorators_test.py b/acts/framework/tests/acts_test_decorators_test.py
index 7d98d49..f491302 100644
--- a/acts/framework/tests/acts_test_decorators_test.py
+++ b/acts/framework/tests/acts_test_decorators_test.py
@@ -11,6 +11,7 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
+import shutil
 import tempfile
 import unittest
 
@@ -90,26 +91,26 @@
 
 class TestDecoratorIntegrationTests(unittest.TestCase):
 
-    MOCK_CONFIG = {
-        "testbed": {
-            "name": "SampleTestBed",
-        },
-        "logpath": tempfile.mkdtemp(),
-        "cli_args": None,
-        "testpaths": ["./"],
-    }
+    @classmethod
+    def setUpClass(cls):
+        cls.MOCK_CONFIG = {
+            "testbed": {
+                "name": "SampleTestBed",
+            },
+            "logpath": tempfile.mkdtemp(),
+            "cli_args": None,
+            "testpaths": ["./"],
+        }
 
-    MOCK_TEST_RUN_LIST = [(MockTest.__name__, [MockTest.TEST_CASE_LIST])]
-
-    def setUp(self):
-        pass
+        cls.MOCK_TEST_RUN_LIST = [(MockTest.__name__,
+                                   [MockTest.TEST_CASE_LIST])]
 
     def _run_with_test_logic(self, func):
         if hasattr(MockTest, MockTest.TEST_LOGIC_ATTR):
             delattr(MockTest, MockTest.TEST_LOGIC_ATTR)
         setattr(MockTest, MockTest.TEST_LOGIC_ATTR, func)
-        self.test_runner = test_runner.TestRunner(TestDecoratorIntegrationTests.MOCK_CONFIG,
-                                                  TestDecoratorIntegrationTests.MOCK_TEST_RUN_LIST)
+        self.test_runner = test_runner.TestRunner(self.MOCK_CONFIG,
+                                                  self.MOCK_TEST_RUN_LIST)
         self.test_runner.run(MockTest)
 
     def _validate_results_has_extra(self, result, extra_key, extra_value):
@@ -127,6 +128,10 @@
         self._run_with_test_logic(raise_generic)
         self._validate_results_has_extra(self.test_runner.results, UUID_KEY, TEST_TRACKER_UUID)
 
+    @classmethod
+    def tearDownClass(cls):
+        shutil.rmtree(cls.MOCK_CONFIG['logpath'])
+
 
 if __name__ == "__main__":
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/acts/framework/tests/acts_test_runner_test.py b/acts/framework/tests/acts_test_runner_test.py
index e8599a7..4769fd7 100755
--- a/acts/framework/tests/acts_test_runner_test.py
+++ b/acts/framework/tests/acts_test_runner_test.py
@@ -15,16 +15,17 @@
 #   limitations under the License.
 
 import mock
+import os
 import shutil
 import tempfile
 import unittest
 
 from acts import keys
-from acts import signals
 from acts import test_runner
 
 import acts_android_device_test
 import mock_controller
+import IntegrationTest
 
 
 class ActsTestRunnerTest(unittest.TestCase):
@@ -35,14 +36,14 @@
     def setUp(self):
         self.tmp_dir = tempfile.mkdtemp()
         self.base_mock_test_config = {
-            "testbed": {
-                "name": "SampleTestBed",
+            'testbed': {
+                'name': 'SampleTestBed',
             },
-            "logpath": self.tmp_dir,
-            "cli_args": None,
-            "testpaths": ["./"],
-            "icecream": 42,
-            "extra_param": "haha"
+            'logpath': self.tmp_dir,
+            'cli_args': None,
+            'testpaths': [os.path.dirname(IntegrationTest.__file__)],
+            'icecream': 42,
+            'extra_param': 'haha'
         }
         self.mock_run_list = [('SampleTest', None)]
 
@@ -59,11 +60,11 @@
         tb_key = keys.Config.key_testbed.value
         mock_ctrlr_config_name = mock_controller.ACTS_CONTROLLER_CONFIG_NAME
         my_config = [{
-            "serial": "xxxx",
-            "magic": "Magic1"
+            'serial': 'xxxx',
+            'magic': 'Magic1'
         }, {
-            "serial": "xxxx",
-            "magic": "Magic2"
+            'serial': 'xxxx',
+            'magic': 'Magic2'
         }]
         mock_test_config[tb_key][mock_ctrlr_config_name] = my_config
         tr = test_runner.TestRunner(mock_test_config,
@@ -73,9 +74,9 @@
         tr.run()
         tr.stop()
         results = tr.results.summary_dict()
-        self.assertEqual(results["Requested"], 2)
-        self.assertEqual(results["Executed"], 2)
-        self.assertEqual(results["Passed"], 2)
+        self.assertEqual(results['Requested'], 2)
+        self.assertEqual(results['Executed'], 2)
+        self.assertEqual(results['Passed'], 2)
 
     @mock.patch(
         'acts.controllers.adb.AdbProxy',
@@ -84,7 +85,7 @@
         'acts.controllers.fastboot.FastbootProxy',
         return_value=acts_android_device_test.MockFastbootProxy(1))
     @mock.patch(
-        'acts.controllers.android_device.list_adb_devices', return_value=["1"])
+        'acts.controllers.android_device.list_adb_devices', return_value=['1'])
     @mock.patch(
         'acts.controllers.android_device.get_all_instances',
         return_value=acts_android_device_test.get_mock_ads(1))
@@ -107,16 +108,16 @@
         tb_key = keys.Config.key_testbed.value
         mock_ctrlr_config_name = mock_controller.ACTS_CONTROLLER_CONFIG_NAME
         my_config = [{
-            "serial": "xxxx",
-            "magic": "Magic1"
+            'serial': 'xxxx',
+            'magic': 'Magic1'
         }, {
-            "serial": "xxxx",
-            "magic": "Magic2"
+            'serial': 'xxxx',
+            'magic': 'Magic2'
         }]
         mock_test_config[tb_key][mock_ctrlr_config_name] = my_config
-        mock_test_config[tb_key]["AndroidDevice"] = [{
-            "serial": "1",
-            "skip_sl4a": True
+        mock_test_config[tb_key]['AndroidDevice'] = [{
+            'serial': '1',
+            'skip_sl4a': True
         }]
         tr = test_runner.TestRunner(mock_test_config,
                                     [('IntegrationTest', None),
@@ -124,10 +125,10 @@
         tr.run()
         tr.stop()
         results = tr.results.summary_dict()
-        self.assertEqual(results["Requested"], 2)
-        self.assertEqual(results["Executed"], 2)
-        self.assertEqual(results["Passed"], 2)
+        self.assertEqual(results['Requested'], 2)
+        self.assertEqual(results['Executed'], 2)
+        self.assertEqual(results['Passed'], 2)
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     unittest.main()
diff --git a/acts/framework/tests/config/unittest_bundle.py b/acts/framework/tests/config/unittest_bundle.py
index 8e26b93..87d5bc5 100755
--- a/acts/framework/tests/config/unittest_bundle.py
+++ b/acts/framework/tests/config/unittest_bundle.py
@@ -14,13 +14,14 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
+import os
 import sys
 import unittest
 
 
 def main():
     suite = unittest.TestLoader().discover(
-        start_dir='./acts/framework/tests/config/', pattern='*_test.py')
+        start_dir=os.path.dirname(__file__), pattern='*_test.py')
     return suite
 
 
diff --git a/acts/framework/tests/controllers/android_lib/android_lib_unittest_bundle.py b/acts/framework/tests/controllers/android_lib/android_lib_unittest_bundle.py
index 3a40d31..cf8e81e 100755
--- a/acts/framework/tests/controllers/android_lib/android_lib_unittest_bundle.py
+++ b/acts/framework/tests/controllers/android_lib/android_lib_unittest_bundle.py
@@ -14,14 +14,14 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
+import os
 import sys
 import unittest
 
 
 def main():
     suite = unittest.TestLoader().discover(
-        start_dir='./acts/framework/tests/controllers/android_lib',
-        pattern='*_test.py')
+        start_dir=os.path.dirname(__file__), pattern='*_test.py')
     return suite
 
 
diff --git a/acts/framework/tests/event/event_bus_integration_test.py b/acts/framework/tests/event/event_bus_integration_test.py
index 7dadf40..c58727d 100755
--- a/acts/framework/tests/event/event_bus_integration_test.py
+++ b/acts/framework/tests/event/event_bus_integration_test.py
@@ -13,6 +13,7 @@
 #   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 shutil
 import tempfile
 import unittest
 from threading import RLock
@@ -65,6 +66,9 @@
         TestClass.instance_event_received = []
         TestClass.static_event_received = []
 
+    def tearDown(self):
+        shutil.rmtree(self.tmp_dir)
+
     def test_test_class_subscribed_fn_receives_event(self):
         """Tests that TestClasses have their subscribed functions called."""
         TestRunner(self.config, [('TestClass', [])]).run(TestClass)
diff --git a/acts/framework/tests/event/event_unittest_bundle.py b/acts/framework/tests/event/event_unittest_bundle.py
index b310cb5..56c3e09 100755
--- a/acts/framework/tests/event/event_unittest_bundle.py
+++ b/acts/framework/tests/event/event_unittest_bundle.py
@@ -14,13 +14,14 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
+import os
 import sys
 import unittest
 
 
 def main():
     suite = unittest.TestLoader().discover(
-        start_dir='./acts/framework/tests/event', pattern='*_test.py')
+        start_dir=os.path.dirname(__file__), pattern='*_test.py')
     return suite
 
 
diff --git a/acts/framework/tests/libs/logging/logging_unittest_bundle.py b/acts/framework/tests/libs/logging/logging_unittest_bundle.py
index 6f384ca..cf8e81e 100755
--- a/acts/framework/tests/libs/logging/logging_unittest_bundle.py
+++ b/acts/framework/tests/libs/logging/logging_unittest_bundle.py
@@ -14,13 +14,14 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
+import os
 import sys
 import unittest
 
 
 def main():
     suite = unittest.TestLoader().discover(
-        start_dir='./acts/framework/tests/libs/logging', pattern='*_test.py')
+        start_dir=os.path.dirname(__file__), pattern='*_test.py')
     return suite
 
 
diff --git a/acts/framework/tests/libs/metrics/unittest_bundle.py b/acts/framework/tests/libs/metrics/unittest_bundle.py
index 8bf7411..87d5bc5 100755
--- a/acts/framework/tests/libs/metrics/unittest_bundle.py
+++ b/acts/framework/tests/libs/metrics/unittest_bundle.py
@@ -14,13 +14,14 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
+import os
 import sys
 import unittest
 
 
 def main():
     suite = unittest.TestLoader().discover(
-        start_dir='./acts/framework/tests/libs/metrics', pattern='*_test.py')
+        start_dir=os.path.dirname(__file__), pattern='*_test.py')
     return suite
 
 
diff --git a/acts/framework/tests/libs/ota/unittest_bundle.py b/acts/framework/tests/libs/ota/unittest_bundle.py
index e0019f1..87d5bc5 100755
--- a/acts/framework/tests/libs/ota/unittest_bundle.py
+++ b/acts/framework/tests/libs/ota/unittest_bundle.py
@@ -14,13 +14,14 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
+import os
 import sys
 import unittest
 
 
 def main():
     suite = unittest.TestLoader().discover(
-        start_dir='./acts/framework/tests/libs/ota', pattern='*_test.py')
+        start_dir=os.path.dirname(__file__), pattern='*_test.py')
     return suite
 
 
diff --git a/acts/framework/tests/libs/proc/proc_unittest_bundle.py b/acts/framework/tests/libs/proc/proc_unittest_bundle.py
index 2a25587..cf8e81e 100755
--- a/acts/framework/tests/libs/proc/proc_unittest_bundle.py
+++ b/acts/framework/tests/libs/proc/proc_unittest_bundle.py
@@ -14,13 +14,14 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
+import os
 import sys
 import unittest
 
 
 def main():
     suite = unittest.TestLoader().discover(
-        start_dir='./acts/framework/tests/libs/proc', pattern='*_test.py')
+        start_dir=os.path.dirname(__file__), pattern='*_test.py')
     return suite
 
 
diff --git a/acts/framework/tests/metrics/loggers/blackbox_test.py b/acts/framework/tests/metrics/loggers/blackbox_test.py
index bda9cc3..d40b00d 100644
--- a/acts/framework/tests/metrics/loggers/blackbox_test.py
+++ b/acts/framework/tests/metrics/loggers/blackbox_test.py
@@ -13,18 +13,19 @@
 #   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 warnings
-
-from mock import Mock
-from mock import patch
+import shutil
 import tempfile
 import unittest
+import warnings
 from unittest import TestCase
+
 from acts.base_test import BaseTestClass
 from acts.metrics.loggers.blackbox import BlackboxMetricLogger
 from acts.test_runner import TestRunner
+from mock import Mock
+from mock import patch
 
-COMPILE_IMPORT_PROTO = 'acts.metrics.logger.compile_import_proto'
+COMPILE_PROTO = 'acts.metrics.logger.MetricLogger._compile_proto'
 GET_CONTEXT_FOR_EVENT = 'acts.metrics.logger.get_context_for_event'
 PROTO_METRIC_PUBLISHER = 'acts.metrics.logger.ProtoMetricPublisher'
 
@@ -42,10 +43,10 @@
         self.publisher = Mock()
         self._get_blackbox_identifier = lambda: str(id(self.context))
 
-    @patch(COMPILE_IMPORT_PROTO)
-    def test_default_init_attributes(self, compile_import_proto):
+    @patch(COMPILE_PROTO)
+    def test_default_init_attributes(self, compile_proto):
         metric_name = Mock()
-        compile_import_proto.return_value = self.proto_module
+        compile_proto.return_value = self.proto_module
 
         logger = BlackboxMetricLogger(metric_name)
 
@@ -53,8 +54,8 @@
         self.assertEqual(logger.proto_module, self.proto_module)
         self.assertIsNone(logger.metric_key)
 
-    @patch(COMPILE_IMPORT_PROTO)
-    def test_init_with_params(self, compile_import_proto):
+    @patch(COMPILE_PROTO)
+    def test_init_with_params(self, compile_proto):
         metric_name = Mock()
         metric_key = Mock()
 
@@ -64,9 +65,8 @@
 
     @patch(PROTO_METRIC_PUBLISHER)
     @patch(GET_CONTEXT_FOR_EVENT)
-    @patch(COMPILE_IMPORT_PROTO)
-    def test_init_with_event(self, compile_import_proto, get_context,
-                             publisher_cls):
+    @patch(COMPILE_PROTO)
+    def test_init_with_event(self, compile_proto, get_context, publisher_cls):
         metric_name = Mock()
 
         logger = BlackboxMetricLogger(metric_name, event=self.event)
@@ -74,10 +74,10 @@
         self.assertIsNotNone(logger.context)
         self.assertIsNotNone(logger.publisher)
 
-    @patch(COMPILE_IMPORT_PROTO)
-    def test_end_populates_result(self, compile_import_proto):
+    @patch(COMPILE_PROTO)
+    def test_end_populates_result(self, compile_proto):
         result = Mock()
-        compile_import_proto.return_value = self.proto_module
+        compile_proto.return_value = self.proto_module
         self.proto_module.ActsBlackboxMetricResult.return_value = result
 
         logger = BlackboxMetricLogger(self.TEST_METRIC_NAME)
@@ -93,12 +93,12 @@
                          '%s.%s' % ('Class#test', self.TEST_METRIC_NAME))
         self.assertEqual(result.metric_value, logger.metric_value)
 
-    @patch(COMPILE_IMPORT_PROTO)
+    @patch(COMPILE_PROTO)
     def test_end_uses_metric_value_on_metric_value_not_none(
-            self, compile_import_proto):
+            self, compile_proto):
         result = Mock()
         expected_result = Mock()
-        compile_import_proto.return_value = self.proto_module
+        compile_proto.return_value = self.proto_module
         self.proto_module.ActsBlackboxMetricResult.return_value = result
 
         logger = BlackboxMetricLogger(self.TEST_METRIC_NAME)
@@ -110,10 +110,10 @@
 
         self.assertEqual(result.metric_value, expected_result)
 
-    @patch(COMPILE_IMPORT_PROTO)
-    def test_end_uses_custom_metric_key(self, compile_import_proto):
+    @patch(COMPILE_PROTO)
+    def test_end_uses_custom_metric_key(self, compile_proto):
         result = Mock()
-        compile_import_proto.return_value = self.proto_module
+        compile_proto.return_value = self.proto_module
         self.proto_module.ActsBlackboxMetricResult.return_value = result
         metric_key = 'metric_key'
 
@@ -122,6 +122,7 @@
         logger.context = self.context
         logger.publisher = self.publisher
         logger._get_blackbox_identifier = self._get_blackbox_identifier
+        logger.metric_value = 'foo'
 
         logger.end(self.event)
 
@@ -129,10 +130,10 @@
         self.assertEqual(result.metric_key, expected_metric_key)
 
     @patch('acts.metrics.loggers.blackbox.ProtoMetric')
-    @patch(COMPILE_IMPORT_PROTO)
-    def test_end_does_publish(self, compile_import_proto, proto_metric_cls):
+    @patch(COMPILE_PROTO)
+    def test_end_does_publish(self, compile_proto, proto_metric_cls):
         result = Mock()
-        compile_import_proto.return_value = self.proto_module
+        compile_proto.return_value = self.proto_module
         self.proto_module.ActsBlackboxMetricResult.return_value = result
         metric_key = 'metric_key'
 
@@ -141,13 +142,26 @@
         logger.context = self.context
         logger.publisher = self.publisher
         logger._get_blackbox_identifier = self._get_blackbox_identifier
+        logger.metric_value = 'foo'
 
         logger.end(self.event)
 
         proto_metric_cls.assert_called_once_with(
             name=self.TEST_FILE_NAME, data=result)
         self.publisher.publish.assert_called_once_with(
-            proto_metric_cls.return_value)
+            [proto_metric_cls.return_value])
+
+
+class _BaseTestClassWithCleanup(BaseTestClass):
+    """Subclass of ACTS base test that generates a temp directory for
+    proto compiler output and cleans up upon exit.
+    """
+    def __init__(self, controllers):
+        super().__init__(controllers)
+        self.proto_dir = tempfile.mkdtemp()
+
+    def __del__(self):
+        shutil.rmtree(self.proto_dir)
 
 
 class BlackboxMetricLoggerIntegrationTest(TestCase):
@@ -179,17 +193,19 @@
 
         runner.run()
         runner.stop()
+        shutil.rmtree(config['logpath'])
         return runner
 
     @patch('acts.metrics.logger.ProtoMetricPublisher')
     def test_test_case_metric(self, publisher_cls):
         result = 5.0
 
-        class MyTest(BaseTestClass):
+        class MyTest(_BaseTestClassWithCleanup):
             def __init__(self, controllers):
-                BaseTestClass.__init__(self, controllers)
+                super().__init__(controllers)
                 self.tests = ('test_case', )
-                self.metric = BlackboxMetricLogger.for_test_case('my_metric')
+                self.metric = BlackboxMetricLogger.for_test_case(
+                    'my_metric', compiler_out=self.proto_dir)
 
             def test_case(self):
                 self.metric.metric_value = result
@@ -198,7 +214,7 @@
 
         args_list = publisher_cls().publish.call_args_list
         self.assertEqual(len(args_list), 1)
-        metric = self.__get_only_arg(args_list[0])
+        metric = self.__get_only_arg(args_list[0])[0]
         self.assertEqual(metric.name, 'blackbox_my_metric')
         self.assertEqual(metric.data.test_identifier, 'MyTest#test_case')
         self.assertEqual(metric.data.metric_key, 'MyTest#test_case.my_metric')
@@ -208,14 +224,16 @@
     def test_multiple_test_case_metrics(self, publisher_cls):
         result = 5.0
 
-        class MyTest(BaseTestClass):
+        class MyTest(_BaseTestClassWithCleanup):
             def __init__(self, controllers):
-                BaseTestClass.__init__(self, controllers)
+                super().__init__(controllers)
                 self.tests = ('test_case', )
                 self.metric_1 = (
-                    BlackboxMetricLogger.for_test_case('my_metric_1'))
+                    BlackboxMetricLogger.for_test_case(
+                        'my_metric_1', compiler_out=self.proto_dir))
                 self.metric_2 = (
-                    BlackboxMetricLogger.for_test_case('my_metric_2'))
+                    BlackboxMetricLogger.for_test_case(
+                        'my_metric_2', compiler_out=self.proto_dir))
 
             def test_case(self):
                 self.metric_1.metric_value = result
@@ -225,7 +243,7 @@
 
         args_list = publisher_cls().publish.call_args_list
         self.assertEqual(len(args_list), 2)
-        metrics = [self.__get_only_arg(args) for args in args_list]
+        metrics = [self.__get_only_arg(args)[0] for args in args_list]
         self.assertEqual({metric.name
                           for metric in metrics},
                          {'blackbox_my_metric_1', 'blackbox_my_metric_2'})
@@ -242,21 +260,22 @@
     def test_test_case_metric_with_custom_key(self, publisher_cls):
         result = 5.0
 
-        class MyTest(BaseTestClass):
+        class MyTest(_BaseTestClassWithCleanup):
             def __init__(self, controllers):
-                BaseTestClass.__init__(self, controllers)
+                super().__init__(controllers)
                 self.tests = ('test_case', )
-                BlackboxMetricLogger.for_test_case(
-                    'my_metric', metric_key='my_metric_key')
+                self.metrics = BlackboxMetricLogger.for_test_case(
+                    'my_metric', metric_key='my_metric_key',
+                    compiler_out=self.proto_dir)
 
             def test_case(self):
-                self.result = result
+                self.metrics.metric_value = result
 
         self.run_acts_test(MyTest)
 
         args_list = publisher_cls().publish.call_args_list
         self.assertEqual(len(args_list), 1)
-        metric = self.__get_only_arg(args_list[0])
+        metric = self.__get_only_arg(args_list[0])[0]
         self.assertEqual(metric.data.metric_key, 'my_metric_key.my_metric')
 
     @patch('acts.metrics.logger.ProtoMetricPublisher')
@@ -265,14 +284,15 @@
         result_1 = 5.0
         result_2 = 8.0
 
-        class MyTest(BaseTestClass):
+        class MyTest(_BaseTestClassWithCleanup):
             def __init__(self, controllers):
-                BaseTestClass.__init__(self, controllers)
+                super().__init__(controllers)
                 self.tests = (
                     'test_case_1',
                     'test_case_2',
                 )
-                self.metric = BlackboxMetricLogger.for_test_class('my_metric')
+                self.metric = BlackboxMetricLogger.for_test_class(
+                    'my_metric', compiler_out=self.proto_dir)
 
             def setup_class(self):
                 self.metric.metric_value = 0
@@ -287,7 +307,7 @@
 
         args_list = publisher_cls().publish.call_args_list
         self.assertEqual(len(args_list), 1)
-        metric = self.__get_only_arg(args_list[0])
+        metric = self.__get_only_arg(args_list[0])[0]
         self.assertEqual(metric.data.metric_value, result_1 + result_2)
         self.assertEqual(metric.data.test_identifier, MyTest.__name__)
 
diff --git a/acts/framework/tests/metrics/unittest_bundle.py b/acts/framework/tests/metrics/unittest_bundle.py
index 9ba0bc5..56c3e09 100755
--- a/acts/framework/tests/metrics/unittest_bundle.py
+++ b/acts/framework/tests/metrics/unittest_bundle.py
@@ -14,13 +14,14 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
+import os
 import sys
 import unittest
 
 
 def main():
     suite = unittest.TestLoader().discover(
-        start_dir='./acts/framework/tests/metrics/', pattern='*_test.py')
+        start_dir=os.path.dirname(__file__), pattern='*_test.py')
     return suite
 
 
diff --git a/acts/framework/tests/test_utils/instrumentation/instrumentation_base_test_test.py b/acts/framework/tests/test_utils/instrumentation/instrumentation_base_test_test.py
index 04ac8e8..0a3ddde 100755
--- a/acts/framework/tests/test_utils/instrumentation/instrumentation_base_test_test.py
+++ b/acts/framework/tests/test_utils/instrumentation/instrumentation_base_test_test.py
@@ -29,11 +29,13 @@
         'lvl2': {'file1': 'FILE'}
     },
     'MockController': {
-        'param1': 1
+        'param1': 1,
+        'param2': 4
     },
     'MockInstrumentationBaseTest': {
         'MockController': {
-            'param2': 2
+            'param2': 2,
+            'param3': 5
         },
         'test_case': {
             'MockController': {
@@ -83,21 +85,21 @@
         controller config for the current test case.
         """
         self.instrumentation_test.current_test_name = 'test_case'
-        config = self.instrumentation_test._get_controller_config(
+        config = self.instrumentation_test._get_merged_config(
             'MockController')
-        self.assertNotIn('param1', config)
-        self.assertNotIn('param2', config)
-        self.assertIn('param3', config)
+        self.assertEqual(config.get('param1'), 1)
+        self.assertEqual(config.get('param2'), 2)
+        self.assertEqual(config.get('param3'), 3)
 
     def test_get_controller_config_for_test_class(self):
         """Test that _get_controller_config returns the controller config for
         the current test class (while no test case is running).
         """
-        config = self.instrumentation_test._get_controller_config(
+        config = self.instrumentation_test._get_merged_config(
             'MockController')
-        self.assertIn('param1', config)
-        self.assertIn('param2', config)
-        self.assertNotIn('param3', config)
+        self.assertEqual(config.get('param1'), 1)
+        self.assertEqual(config.get('param2'), 2)
+        self.assertEqual(config.get('param3'), 5)
 
 
 if __name__ == '__main__':
diff --git a/acts/framework/tests/test_utils/instrumentation/unit_test_suite.py b/acts/framework/tests/test_utils/instrumentation/unit_test_suite.py
index c929b65..d253cb3 100755
--- a/acts/framework/tests/test_utils/instrumentation/unit_test_suite.py
+++ b/acts/framework/tests/test_utils/instrumentation/unit_test_suite.py
@@ -14,14 +14,14 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
+import os
 import sys
 import unittest
 
 
 def main():
     suite = unittest.TestLoader().discover(
-        start_dir='./acts/framework/tests/test_utils/instrumentation',
-        pattern='*_test.py')
+        start_dir=os.path.dirname(__file__), pattern='*_test.py')
     return suite
 
 
diff --git a/acts/tests/google/ble/api/BleAdvertiseApiTest.py b/acts/tests/google/ble/api/BleAdvertiseApiTest.py
index 2a6cb26..26c459f 100644
--- a/acts/tests/google/ble/api/BleAdvertiseApiTest.py
+++ b/acts/tests/google/ble/api/BleAdvertiseApiTest.py
@@ -35,8 +35,8 @@
 
 
 class BleAdvertiseApiTest(BluetoothBaseTest):
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.ad_dut = self.android_devices[0]
 
     @BluetoothBaseTest.bt_test_wrap
diff --git a/acts/tests/google/ble/api/BleScanApiTest.py b/acts/tests/google/ble/api/BleScanApiTest.py
index 1398715..06f2362 100644
--- a/acts/tests/google/ble/api/BleScanApiTest.py
+++ b/acts/tests/google/ble/api/BleScanApiTest.py
@@ -47,8 +47,8 @@
 
 
 class BleScanApiTest(BluetoothBaseTest):
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.ad_dut = self.android_devices[0]
 
     def _format_defaults(self, input):
diff --git a/acts/tests/google/ble/api/GattApiTest.py b/acts/tests/google/ble/api/GattApiTest.py
index 5444e51..cc87979 100644
--- a/acts/tests/google/ble/api/GattApiTest.py
+++ b/acts/tests/google/ble/api/GattApiTest.py
@@ -24,11 +24,10 @@
 
 
 class GattApiTest(BluetoothBaseTest):
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.ad = self.android_devices[0]
 
-    def setup_class(self):
         return setup_multiple_devices_for_bt_test(self.android_devices)
 
     def setup_test(self):
diff --git a/acts/tests/google/ble/beacon_tests/BeaconSwarmTest.py b/acts/tests/google/ble/beacon_tests/BeaconSwarmTest.py
index 9ebfe1e..0df9a7b 100644
--- a/acts/tests/google/ble/beacon_tests/BeaconSwarmTest.py
+++ b/acts/tests/google/ble/beacon_tests/BeaconSwarmTest.py
@@ -41,10 +41,6 @@
     advertising_device_name_list = []
     discovered_mac_address_list = []
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
-        self.scn_ad = self.android_devices[0]
-
     def setup_test(self):
         self.discovered_mac_address_list = []
         for a in self.android_devices:
@@ -56,6 +52,7 @@
         return True
 
     def setup_class(self):
+        self.scn_ad = self.android_devices[0]
         if not setup_multiple_devices_for_bt_test(self.android_devices):
             return False
         return self._start_special_advertisements()
diff --git a/acts/tests/google/ble/bt5/AdvertisingSetTest.py b/acts/tests/google/ble/bt5/AdvertisingSetTest.py
index 66b0028..de4192f 100644
--- a/acts/tests/google/ble/bt5/AdvertisingSetTest.py
+++ b/acts/tests/google/ble/bt5/AdvertisingSetTest.py
@@ -62,14 +62,12 @@
         ]
     }
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
-        self.adv_ad = self.android_devices[0]
-
     def setup_class(self):
         super(AdvertisingSetTest, self).setup_class()
+        self.adv_ad = self.android_devices[0]
+
         if not self.adv_ad.droid.bluetoothIsLeExtendedAdvertisingSupported():
-            raise signals.TestSkipClass(
+            raise signals.TestAbortClass(
                 "Advertiser does not support LE Extended Advertising")
 
     def teardown_test(self):
diff --git a/acts/tests/google/ble/bt5/Bt5ScanTest.py b/acts/tests/google/ble/bt5/Bt5ScanTest.py
index e4cf4c5..e2c9c83 100644
--- a/acts/tests/google/ble/bt5/Bt5ScanTest.py
+++ b/acts/tests/google/ble/bt5/Bt5ScanTest.py
@@ -60,19 +60,17 @@
         ]
     }
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super(Bt5ScanTest, self).setup_class()
         self.scn_ad = self.android_devices[0]
         self.adv_ad = self.android_devices[1]
 
-    def setup_class(self):
-        super(Bt5ScanTest, self).setup_class()
         if not self.scn_ad.droid.bluetoothIsLeExtendedAdvertisingSupported():
-            raise signals.TestSkipClass(
+            raise signals.TestAbortClass(
                 "Scanner does not support LE Extended Advertising")
 
         if not self.adv_ad.droid.bluetoothIsLeExtendedAdvertisingSupported():
-            raise signals.TestSkipClass(
+            raise signals.TestAbortClass(
                 "Advertiser does not support LE Extended Advertising")
 
     def teardown_test(self):
diff --git a/acts/tests/google/ble/bt5/PhyTest.py b/acts/tests/google/ble/bt5/PhyTest.py
index 9b95ead..0b1ecfa 100644
--- a/acts/tests/google/ble/bt5/PhyTest.py
+++ b/acts/tests/google/ble/bt5/PhyTest.py
@@ -42,11 +42,11 @@
     def setup_class(self):
         super(PhyTest, self).setup_class()
         if not self.cen_ad.droid.bluetoothIsLe2MPhySupported():
-            raise signals.TestSkipClass(
+            raise signals.TestAbortClass(
                 "Central device does not support LE 2M PHY")
 
         if not self.per_ad.droid.bluetoothIsLe2MPhySupported():
-            raise signals.TestSkipClass(
+            raise signals.TestAbortClass(
                 "Peripheral device does not support LE 2M PHY")
 
     # Some controllers auto-update PHY to 2M, and both client and server
diff --git a/acts/tests/google/ble/concurrency/ConcurrentBleAdvertisementDiscoveryTest.py b/acts/tests/google/ble/concurrency/ConcurrentBleAdvertisementDiscoveryTest.py
index 950a370..2af4c05 100644
--- a/acts/tests/google/ble/concurrency/ConcurrentBleAdvertisementDiscoveryTest.py
+++ b/acts/tests/google/ble/concurrency/ConcurrentBleAdvertisementDiscoveryTest.py
@@ -46,8 +46,8 @@
     max_advertisements = -1
     advertise_callback_list = []
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.droid_list = get_advanced_droid_list(self.android_devices)
         self.scn_ad = self.android_devices[0]
         self.adv_ad = self.android_devices[1]
diff --git a/acts/tests/google/ble/concurrency/ConcurrentBleAdvertisingTest.py b/acts/tests/google/ble/concurrency/ConcurrentBleAdvertisingTest.py
index 62f06d1..94ee0f7 100644
--- a/acts/tests/google/ble/concurrency/ConcurrentBleAdvertisingTest.py
+++ b/acts/tests/google/ble/concurrency/ConcurrentBleAdvertisingTest.py
@@ -45,8 +45,8 @@
     default_timeout = 10
     max_advertisements = -1
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.droid_list = get_advanced_droid_list(self.android_devices)
         self.scn_ad = self.android_devices[0]
         self.adv_ad = self.android_devices[1]
diff --git a/acts/tests/google/ble/concurrency/ConcurrentBleScanningTest.py b/acts/tests/google/ble/concurrency/ConcurrentBleScanningTest.py
index c3e71f2..512aed8 100644
--- a/acts/tests/google/ble/concurrency/ConcurrentBleScanningTest.py
+++ b/acts/tests/google/ble/concurrency/ConcurrentBleScanningTest.py
@@ -39,8 +39,8 @@
     default_timeout = 20
     max_concurrent_scans = 27
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.scn_ad = self.android_devices[0]
         self.adv_ad = self.android_devices[1]
 
diff --git a/acts/tests/google/ble/concurrency/ConcurrentGattConnectTest.py b/acts/tests/google/ble/concurrency/ConcurrentGattConnectTest.py
index 96cdf0a..ec5e09c 100644
--- a/acts/tests/google/ble/concurrency/ConcurrentGattConnectTest.py
+++ b/acts/tests/google/ble/concurrency/ConcurrentGattConnectTest.py
@@ -79,12 +79,10 @@
     advertisement_names = []
     list_of_arguments_list = []
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
-        self.pri_dut = self.android_devices[0]
-
     def setup_class(self):
         super(BluetoothBaseTest, self).setup_class()
+        self.pri_dut = self.android_devices[0]
+
 
         # Create 5 advertisements from different android devices
         for i in range(1, self.max_connections + 1):
diff --git a/acts/tests/google/ble/conn_oriented_chan/BleCoc2ConnTest.py b/acts/tests/google/ble/conn_oriented_chan/BleCoc2ConnTest.py
index 4229630..353f507 100644
--- a/acts/tests/google/ble/conn_oriented_chan/BleCoc2ConnTest.py
+++ b/acts/tests/google/ble/conn_oriented_chan/BleCoc2ConnTest.py
@@ -42,8 +42,8 @@
 
 
 class BleCoc2ConnTest(BluetoothBaseTest):
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.client_ad = self.android_devices[0]
         # The client which is scanning will need location to be enabled in order to
         # start scan and get scan results.
@@ -53,7 +53,6 @@
         if len(self.android_devices) > 2:
             self.server2_ad = self.android_devices[2]
 
-    def setup_class(self):
         return setup_multiple_devices_for_bt_test(self.android_devices)
 
     def teardown_test(self):
diff --git a/acts/tests/google/ble/conn_oriented_chan/BleCocTest.py b/acts/tests/google/ble/conn_oriented_chan/BleCocTest.py
index 29bbe1a..97ace9b 100644
--- a/acts/tests/google/ble/conn_oriented_chan/BleCocTest.py
+++ b/acts/tests/google/ble/conn_oriented_chan/BleCocTest.py
@@ -46,8 +46,8 @@
         "strange new worlds, to seek out new life and new civilizations,"
         " to boldly go where no man has gone before.")
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.client_ad = self.android_devices[0]
         # The client which is scanning will need location to be enabled in order to
         # start scan and get scan results.
@@ -57,7 +57,6 @@
         if len(self.android_devices) > 2:
             self.server2_ad = self.android_devices[2]
 
-    def setup_class(self):
         return setup_multiple_devices_for_bt_test(self.android_devices)
 
     def teardown_test(self):
diff --git a/acts/tests/google/ble/examples/BleExamplesTest.py b/acts/tests/google/ble/examples/BleExamplesTest.py
index e84e201..1ced2db 100644
--- a/acts/tests/google/ble/examples/BleExamplesTest.py
+++ b/acts/tests/google/ble/examples/BleExamplesTest.py
@@ -34,8 +34,8 @@
     scn_droid = None
     adv_droid = None
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.scn_droid, self.scn_ed = (self.android_devices[0].droid,
                                        self.android_devices[0].ed)
         self.adv_droid, self.adv_ed = (self.android_devices[1].droid,
diff --git a/acts/tests/google/ble/examples/GattServerExampleTest.py b/acts/tests/google/ble/examples/GattServerExampleTest.py
index 6a741a7..e1f6476 100644
--- a/acts/tests/google/ble/examples/GattServerExampleTest.py
+++ b/acts/tests/google/ble/examples/GattServerExampleTest.py
@@ -55,8 +55,8 @@
 
 
 class GattServerExampleTest(BluetoothBaseTest):
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.dut = self.android_devices[0]
 
     @BluetoothBaseTest.bt_test_wrap
diff --git a/acts/tests/google/ble/filtering/FilteringTest.py b/acts/tests/google/ble/filtering/FilteringTest.py
index 3a3aaac..d1bdc39 100644
--- a/acts/tests/google/ble/filtering/FilteringTest.py
+++ b/acts/tests/google/ble/filtering/FilteringTest.py
@@ -64,8 +64,8 @@
     service_uuid_2 = "FFFFFFFF-0000-1000-8000-00805f9b34fb"
     service_uuid_3 = "3846D7A0-69C8-11E4-BA00-0002A5D5C51B"
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.scn_ad = self.android_devices[0]
         self.adv_ad = self.android_devices[1]
         self.log.info("Scanner device model: {}".format(
diff --git a/acts/tests/google/ble/filtering/UniqueFilteringTest.py b/acts/tests/google/ble/filtering/UniqueFilteringTest.py
index 35945e5..c2e837c 100644
--- a/acts/tests/google/ble/filtering/UniqueFilteringTest.py
+++ b/acts/tests/google/ble/filtering/UniqueFilteringTest.py
@@ -38,8 +38,8 @@
 class UniqueFilteringTest(BluetoothBaseTest):
     default_timeout = 10
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.scn_ad = self.android_devices[0]
         self.adv_ad = self.android_devices[1]
 
diff --git a/acts/tests/google/ble/gatt/GattConnectTest.py b/acts/tests/google/ble/gatt/GattConnectTest.py
index c276c0e..52f3601 100644
--- a/acts/tests/google/ble/gatt/GattConnectTest.py
+++ b/acts/tests/google/ble/gatt/GattConnectTest.py
@@ -58,8 +58,8 @@
     default_timeout = 10
     default_discovery_timeout = 3
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.cen_ad = self.android_devices[0]
         self.per_ad = self.android_devices[1]
 
diff --git a/acts/tests/google/ble/gatt/GattToolTest.py b/acts/tests/google/ble/gatt/GattToolTest.py
index fc61cb5..8e7a9f0 100644
--- a/acts/tests/google/ble/gatt/GattToolTest.py
+++ b/acts/tests/google/ble/gatt/GattToolTest.py
@@ -49,8 +49,8 @@
     adv_instances = []
     timer_list = []
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         # Central role Android device
         self.cen_ad = self.android_devices[0]
         self.ble_mac_address = self.user_params['ble_mac_address']
diff --git a/acts/tests/google/ble/power/GattPowerTest.py b/acts/tests/google/ble/power/GattPowerTest.py
index c4239bd..2817d74 100644
--- a/acts/tests/google/ble/power/GattPowerTest.py
+++ b/acts/tests/google/ble/power/GattPowerTest.py
@@ -50,14 +50,12 @@
     PMC_GATT_CMD = ("am broadcast -a com.android.pmc.GATT ")
     GATT_SERVER_MSG = "%s--es GattServer 1" % (PMC_GATT_CMD)
 
-    def __init__(self, controllers):
-        PowerBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super(GattPowerTest, self).setup_class()
 
         self.cen_ad = self.android_devices[0]
         self.per_ad = self.android_devices[1]
 
-    def setup_class(self):
-        super(GattPowerTest, self).setup_class()
         if not bluetooth_enabled_check(self.per_ad):
             self.log.error("Failed to turn on Bluetooth on peripheral")
 
diff --git a/acts/tests/google/ble/scan/BleBackgroundScanTest.py b/acts/tests/google/ble/scan/BleBackgroundScanTest.py
index 3a10793..6839602 100644
--- a/acts/tests/google/ble/scan/BleBackgroundScanTest.py
+++ b/acts/tests/google/ble/scan/BleBackgroundScanTest.py
@@ -45,13 +45,11 @@
     active_scan_callback_list = []
     active_adv_callback_list = []
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super(BluetoothBaseTest, self).setup_class()
         self.scn_ad = self.android_devices[0]
         self.adv_ad = self.android_devices[1]
 
-    def setup_class(self):
-        super(BluetoothBaseTest, self).setup_class()
         utils.set_location_service(self.scn_ad, True)
         utils.set_location_service(self.adv_ad, True)
         return True
diff --git a/acts/tests/google/ble/scan/BleOnLostOnFoundTest.py b/acts/tests/google/ble/scan/BleOnLostOnFoundTest.py
index dd40b6a..01f7976 100644
--- a/acts/tests/google/ble/scan/BleOnLostOnFoundTest.py
+++ b/acts/tests/google/ble/scan/BleOnLostOnFoundTest.py
@@ -39,13 +39,11 @@
     active_scan_callback_list = []
     active_adv_callback_list = []
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super(BluetoothBaseTest, self).setup_class()
         self.scn_ad = self.android_devices[0]
         self.adv_ad = self.android_devices[1]
 
-    def setup_class(self):
-        super(BluetoothBaseTest, self).setup_class()
         utils.set_location_service(self.scn_ad, True)
         utils.set_location_service(self.adv_ad, True)
         return True
diff --git a/acts/tests/google/ble/scan/BleOpportunisticScanTest.py b/acts/tests/google/ble/scan/BleOpportunisticScanTest.py
index 7b64cfe..9e59128 100644
--- a/acts/tests/google/ble/scan/BleOpportunisticScanTest.py
+++ b/acts/tests/google/ble/scan/BleOpportunisticScanTest.py
@@ -45,13 +45,11 @@
     active_scan_callback_list = []
     active_adv_callback_list = []
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super(BluetoothBaseTest, self).setup_class()
         self.scn_ad = self.android_devices[0]
         self.adv_ad = self.android_devices[1]
 
-    def setup_class(self):
-        super(BluetoothBaseTest, self).setup_class()
         utils.set_location_service(self.scn_ad, True)
         utils.set_location_service(self.adv_ad, True)
         return True
diff --git a/acts/tests/google/ble/scan/BleScanScreenStateTest.py b/acts/tests/google/ble/scan/BleScanScreenStateTest.py
index b6d128a..07ae898 100644
--- a/acts/tests/google/ble/scan/BleScanScreenStateTest.py
+++ b/acts/tests/google/ble/scan/BleScanScreenStateTest.py
@@ -42,13 +42,11 @@
     scan_callback = -1
     shorter_scan_timeout = 4
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super(BluetoothBaseTest, self).setup_class()
         self.scn_ad = self.android_devices[0]
         self.adv_ad = self.android_devices[1]
 
-    def setup_class(self):
-        super(BluetoothBaseTest, self).setup_class()
         utils.set_location_service(self.scn_ad, True)
         utils.set_location_service(self.adv_ad, True)
         return True
diff --git a/acts/tests/google/ble/system_tests/BleStressTest.py b/acts/tests/google/ble/system_tests/BleStressTest.py
index be0a9fe..f97907f 100644
--- a/acts/tests/google/ble/system_tests/BleStressTest.py
+++ b/acts/tests/google/ble/system_tests/BleStressTest.py
@@ -38,8 +38,8 @@
     default_timeout = 10
     PAIRING_TIMEOUT = 20
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.droid_list = get_advanced_droid_list(self.android_devices)
         self.scn_ad = self.android_devices[0]
         self.adv_ad = self.android_devices[1]
diff --git a/acts/tests/google/bt/AkXB10PairingTest.py b/acts/tests/google/bt/AkXB10PairingTest.py
index 51e1e59..10e7335 100644
--- a/acts/tests/google/bt/AkXB10PairingTest.py
+++ b/acts/tests/google/bt/AkXB10PairingTest.py
@@ -28,8 +28,8 @@
 class AkXB10PairingTest(BluetoothBaseTest):
     DISCOVERY_TIME = 5
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.dut = self.android_devices[0]
         # Do factory reset and then do delay for 3-seconds
         self.dut.droid.bluetoothFactoryReset()
diff --git a/acts/tests/google/bt/BtAirplaneModeTest.py b/acts/tests/google/bt/BtAirplaneModeTest.py
index bb90b10..e2dd7eb 100644
--- a/acts/tests/google/bt/BtAirplaneModeTest.py
+++ b/acts/tests/google/bt/BtAirplaneModeTest.py
@@ -31,8 +31,8 @@
     grace_timeout = 4
     WAIT_TIME_ANDROID_STATE_SETTLING = 5
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.dut = self.android_devices[0]
 
     def setup_test(self):
diff --git a/acts/tests/google/bt/BtBasicFunctionalityTest.py b/acts/tests/google/bt/BtBasicFunctionalityTest.py
index 0cb4ea8..3194d76 100644
--- a/acts/tests/google/bt/BtBasicFunctionalityTest.py
+++ b/acts/tests/google/bt/BtBasicFunctionalityTest.py
@@ -36,12 +36,11 @@
     default_timeout = 10
     scan_discovery_time = 5
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.droid_ad = self.android_devices[0]
         self.droid1_ad = self.android_devices[1]
 
-    def setup_class(self):
         return setup_multiple_devices_for_bt_test(self.android_devices)
 
     def setup_test(self):
diff --git a/acts/tests/google/bt/BtFactoryResetTest.py b/acts/tests/google/bt/BtFactoryResetTest.py
index 8c9d399..f33b210 100644
--- a/acts/tests/google/bt/BtFactoryResetTest.py
+++ b/acts/tests/google/bt/BtFactoryResetTest.py
@@ -25,8 +25,8 @@
     default_timeout = 10
     grace_timeout = 4
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.pri_dut = self.android_devices[0]
         self.sec_dut = self.android_devices[1]
 
diff --git a/acts/tests/google/bt/BtKillProcessTest.py b/acts/tests/google/bt/BtKillProcessTest.py
index 2b17d28..ed53e20 100644
--- a/acts/tests/google/bt/BtKillProcessTest.py
+++ b/acts/tests/google/bt/BtKillProcessTest.py
@@ -25,8 +25,8 @@
 
 
 class BtKillProcessTest(BluetoothBaseTest):
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.dut = self.android_devices[0]
 
     def _get_bt_pid(self):
diff --git a/acts/tests/google/bt/RfcommTest.py b/acts/tests/google/bt/RfcommTest.py
index 272fc89..58de1be 100644
--- a/acts/tests/google/bt/RfcommTest.py
+++ b/acts/tests/google/bt/RfcommTest.py
@@ -47,12 +47,11 @@
         "strange new worlds, to seek out new life and new civilizations,"
         " to boldly go where no man has gone before.")
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.client_ad = self.android_devices[0]
         self.server_ad = self.android_devices[1]
 
-    def setup_class(self):
         return setup_multiple_devices_for_bt_test(self.android_devices)
 
     def teardown_test(self):
diff --git a/acts/tests/google/bt/SonyXB2PairingTest.py b/acts/tests/google/bt/SonyXB2PairingTest.py
index 3907135..4dcf863 100644
--- a/acts/tests/google/bt/SonyXB2PairingTest.py
+++ b/acts/tests/google/bt/SonyXB2PairingTest.py
@@ -28,8 +28,8 @@
 class SonyXB2PairingTest(BluetoothBaseTest):
     DISCOVERY_TIME = 5
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.dut = self.android_devices[0]
         # Do factory reset and then do delay for 3-seconds
         self.dut.droid.bluetoothFactoryReset()
diff --git a/acts/tests/google/bt/audio_lab/BtChameleonTest.py b/acts/tests/google/bt/audio_lab/BtChameleonTest.py
index 4a43cd3..d268344 100644
--- a/acts/tests/google/bt/audio_lab/BtChameleonTest.py
+++ b/acts/tests/google/bt/audio_lab/BtChameleonTest.py
@@ -47,8 +47,8 @@
     audio_file_2k1k_300_sec = "audio_file_2k1k_300_sec.wav"
     android_sdcard_music_path = "/sdcard/Music"
 
-    def __init__(self, controllers):
-        BtFunhausBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.chameleon = self.chameleon_devices[0]
         self.dut = self.android_devices[0]
         self.raw_audio_dest = "{}/{}".format(self.android_devices[0].log_path,
diff --git a/acts/tests/google/bt/audio_lab/BtFunhausTest.py b/acts/tests/google/bt/audio_lab/BtFunhausTest.py
index e82c955..42cbc22 100644
--- a/acts/tests/google/bt/audio_lab/BtFunhausTest.py
+++ b/acts/tests/google/bt/audio_lab/BtFunhausTest.py
@@ -26,8 +26,8 @@
     music_file_to_play = ""
     device_fails_to_connect_list = []
 
-    def __init__(self, controllers):
-        BtFunhausBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
 
     @test_tracker_info(uuid='80a4cc4c-7c2a-428d-9eaf-46239a7926df')
     def test_run_bt_audio_12_hours(self):
diff --git a/acts/tests/google/bt/audio_lab/ThreeButtonDongleTest.py b/acts/tests/google/bt/audio_lab/ThreeButtonDongleTest.py
index cf9add5..abf97be 100644
--- a/acts/tests/google/bt/audio_lab/ThreeButtonDongleTest.py
+++ b/acts/tests/google/bt/audio_lab/ThreeButtonDongleTest.py
@@ -26,8 +26,8 @@
 class ThreeButtonDongleTest(BluetoothBaseTest):
     iterations = 10
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.dut = self.android_devices[0]
         self.dongle = self.relay_devices[0]
         self.log.info("Target dongle is {}".format(self.dongle.name))
diff --git a/acts/tests/google/bt/car_bt/BtCarBasicFunctionalityTest.py b/acts/tests/google/bt/car_bt/BtCarBasicFunctionalityTest.py
index 431e49e..99f2851 100644
--- a/acts/tests/google/bt/car_bt/BtCarBasicFunctionalityTest.py
+++ b/acts/tests/google/bt/car_bt/BtCarBasicFunctionalityTest.py
@@ -36,11 +36,10 @@
     default_timeout = 10
     scan_discovery_time = 5
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.car_ad = self.android_devices[0]
 
-    def setup_class(self):
         return setup_multiple_devices_for_bt_test(self.android_devices)
 
     @test_tracker_info(uuid='b52a032a-3438-4b84-863f-c46a969882a4')
diff --git a/acts/tests/google/bt/car_bt/BtCarPairingTest.py b/acts/tests/google/bt/car_bt/BtCarPairingTest.py
index b4fde56..603f1a8 100644
--- a/acts/tests/google/bt/car_bt/BtCarPairingTest.py
+++ b/acts/tests/google/bt/car_bt/BtCarPairingTest.py
@@ -33,8 +33,8 @@
 
 
 class BtCarPairingTest(BluetoothBaseTest):
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.car = self.android_devices[0]
         self.ph = self.android_devices[1]
 
diff --git a/acts/tests/google/bt/car_bt/BtCarPbapTest.py b/acts/tests/google/bt/car_bt/BtCarPbapTest.py
index ab605a2..6d5bccb 100644
--- a/acts/tests/google/bt/car_bt/BtCarPbapTest.py
+++ b/acts/tests/google/bt/car_bt/BtCarPbapTest.py
@@ -40,16 +40,14 @@
 class BtCarPbapTest(BluetoothBaseTest):
     contacts_destination_path = ""
 
-    def __init__(self, controllers):
-        BaseTestClass.__init__(self, controllers)
+    def setup_class(self):
+        if not super(BtCarPbapTest, self).setup_class():
+            return False
         self.pce = self.android_devices[0]
         self.pse = self.android_devices[1]
         self.pse2 = self.android_devices[2]
         self.contacts_destination_path = self.log_path + "/"
 
-    def setup_class(self):
-        if not super(BtCarPbapTest, self).setup_class():
-            return False
         permissions_list = [
             "android.permission.READ_CONTACTS",
             "android.permission.WRITE_CONTACTS",
diff --git a/acts/tests/google/bt/gatt/GattOverBrEdrTest.py b/acts/tests/google/bt/gatt/GattOverBrEdrTest.py
index dcf916d..7985540 100644
--- a/acts/tests/google/bt/gatt/GattOverBrEdrTest.py
+++ b/acts/tests/google/bt/gatt/GattOverBrEdrTest.py
@@ -47,13 +47,11 @@
     default_discovery_timeout = 3
     per_droid_mac_address = None
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super(BluetoothBaseTest, self).setup_class()
         self.cen_ad = self.android_devices[0]
         self.per_ad = self.android_devices[1]
 
-    def setup_class(self):
-        super(BluetoothBaseTest, self).setup_class()
         self.per_droid_mac_address = self.per_ad.droid.bluetoothGetLocalAddress(
         )
         if not self.per_droid_mac_address:
diff --git a/acts/tests/google/bt/hid/HidDeviceTest.py b/acts/tests/google/bt/hid/HidDeviceTest.py
index cdd1094..e7e1778 100644
--- a/acts/tests/google/bt/hid/HidDeviceTest.py
+++ b/acts/tests/google/bt/hid/HidDeviceTest.py
@@ -34,8 +34,8 @@
     tests = None
     default_timeout = 10
 
-    def __init__(self, controllers):
-        BaseTestClass.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.host_ad = self.android_devices[0]
         self.device_ad = self.android_devices[1]
 
diff --git a/acts/tests/google/bt/ota/BtOtaTest.py b/acts/tests/google/bt/ota/BtOtaTest.py
index 91e51bb..86e3098 100644
--- a/acts/tests/google/bt/ota/BtOtaTest.py
+++ b/acts/tests/google/bt/ota/BtOtaTest.py
@@ -32,14 +32,14 @@
 
         # Pairing devices
         if not pair_pri_to_sec(self.dut, self.android_devices[1]):
-            raise signals.TestSkipClass(
+            raise signals.TestAbortClass(
                 "Failed to bond devices prior to update")
 
         #Run OTA below, if ota fails then abort all tests
         try:
             ota_updater.update(self.dut)
         except Exception as err:
-            raise signals.TestSkipClass(
+            raise signals.TestAbortClass(
                 "Failed up apply OTA update. Aborting tests")
 
     @BluetoothBaseTest.bt_test_wrap
diff --git a/acts/tests/google/bt/pan/BtPanTest.py b/acts/tests/google/bt/pan/BtPanTest.py
index 0539851..01f6078 100644
--- a/acts/tests/google/bt/pan/BtPanTest.py
+++ b/acts/tests/google/bt/pan/BtPanTest.py
@@ -32,8 +32,8 @@
 
 
 class BtPanTest(BluetoothBaseTest):
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.pan_dut = self.android_devices[0]
         self.panu_dut = self.android_devices[1]
 
diff --git a/acts/tests/google/bt/performance/BtCodecSweepTest.py b/acts/tests/google/bt/performance/BtCodecSweepTest.py
index c8e6819..a6504a5 100644
--- a/acts/tests/google/bt/performance/BtCodecSweepTest.py
+++ b/acts/tests/google/bt/performance/BtCodecSweepTest.py
@@ -28,8 +28,8 @@
 
 class BtCodecSweepTest(A2dpCodecBaseTest):
 
-    def __init__(self, configs):
-        super().__init__(configs)
+    def setup_class(self):
+        super().setup_class()
         self.bt_logger = BluetoothMetricLogger.for_test_case()
         self.start_time = time.time()
 
diff --git a/acts/tests/google/bt/performance/BtInterferenceRSSITest.py b/acts/tests/google/bt/performance/BtInterferenceRSSITest.py
index dbc1e9e..6c92c61 100644
--- a/acts/tests/google/bt/performance/BtInterferenceRSSITest.py
+++ b/acts/tests/google/bt/performance/BtInterferenceRSSITest.py
@@ -26,8 +26,8 @@
             module) terminates the sequence and keeps it from looping.
     """
 
-    def __init__(self, configs):
-        super().__init__(configs)
+    def setup_class(self):
+        super().setup_class()
         req_params = ["bt_atten_sequences", "RelayDevice", "codec"]
         opt_params = ["audio_params"]
         self.unpack_userparams(req_params, opt_params)
diff --git a/acts/tests/google/bt/performance/BtRangeCodecTest.py b/acts/tests/google/bt/performance/BtRangeCodecTest.py
old mode 100755
new mode 100644
index 8070997..e20b864
--- a/acts/tests/google/bt/performance/BtRangeCodecTest.py
+++ b/acts/tests/google/bt/performance/BtRangeCodecTest.py
@@ -31,8 +31,8 @@
 
 class BtRangeCodecTest(A2dpCodecBaseTest):
 
-    def __init__(self, configs):
-        super().__init__(configs)
+    def setup_class(self):
+        super().setup_class()
         self.bt_logger = log.BluetoothMetricLogger.for_test_case()
         self.start_time = time.time()
         self.attenuator = self.attenuators[0]
diff --git a/acts/tests/google/bt/pts/A2dpPtsTest.py b/acts/tests/google/bt/pts/A2dpPtsTest.py
index 1b16c2a..25ed3ce 100644
--- a/acts/tests/google/bt/pts/A2dpPtsTest.py
+++ b/acts/tests/google/bt/pts/A2dpPtsTest.py
@@ -28,8 +28,8 @@
     ble_advertise_interval = 100
     pts_action_mapping = None
 
-    def __init__(self, controllers):
-        super(A2dpPtsTest, self).__init__(controllers)
+    def setup_class(self):
+        super(A2dpPtsTest, self).setup_class()
         self.dut.initialize_bluetooth_controller()
         # self.dut.set_bluetooth_local_name(self.dut_bluetooth_local_name)
         local_dut_mac_address = self.dut.get_local_bluetooth_address()
@@ -58,8 +58,6 @@
 
         self.pts.set_ics_and_ixit(ics, ixit)
 
-    def setup_class(self):
-        super(A2dpPtsTest, self).setup_class()
         self.dut.unbond_all_known_devices()
         self.dut.start_pairing_helper()
 
diff --git a/acts/tests/google/bt/pts/BtCmdLineTest.py b/acts/tests/google/bt/pts/BtCmdLineTest.py
index c75aa35..8d925ed 100644
--- a/acts/tests/google/bt/pts/BtCmdLineTest.py
+++ b/acts/tests/google/bt/pts/BtCmdLineTest.py
@@ -34,8 +34,8 @@
 class BtCmdLineTest(BluetoothBaseTest):
     target_mac_address = ""
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         if not "target_mac_address" in self.user_params.keys():
             self.log.warning("Missing user config \"target_mac_address\"!")
             self.target_mac_address = ""
@@ -71,6 +71,7 @@
             music_path = self.user_params[music_path_str]
             self._add_music_to_primary_android_device(music_path,
                                                       android_music_path)
+        return True
 
     def _add_music_to_primary_android_device(self, music_path,
                                              android_music_path):
@@ -82,9 +83,6 @@
                 self.android_devices[0].adb.push("{} {}".format(
                     file, android_music_path))
 
-    def setup_class(self):
-        return True
-
     def test_pts_cmd_line_helper(self):
         cmd_line = CmdInput()
         cmd_line.setup_vars(self.android_devices, self.target_mac_address,
diff --git a/acts/tests/google/bt/pts/GattPtsTest.py b/acts/tests/google/bt/pts/GattPtsTest.py
index 318fb51..7883f37 100644
--- a/acts/tests/google/bt/pts/GattPtsTest.py
+++ b/acts/tests/google/bt/pts/GattPtsTest.py
@@ -32,8 +32,8 @@
     ble_advertise_interval = 100
     pts_action_mapping = None
 
-    def __init__(self, controllers):
-        super(GattPtsTest, self).__init__(controllers)
+    def setup_class(self):
+        super(GattPtsTest, self).setup_class()
         self.dut_bluetooth_local_name = "fs_test"
         self.dut.initialize_bluetooth_controller()
         self.dut.set_bluetooth_local_name(self.dut_bluetooth_local_name)
@@ -74,8 +74,6 @@
 
         self.pts.set_ics_and_ixit(ics, ixit)
 
-    def setup_class(self):
-        super(GattPtsTest, self).setup_class()
         self.dut.unbond_all_known_devices()
         self.dut.start_pairing_helper()
 
diff --git a/acts/tests/google/bt/pts/SdpPtsTest.py b/acts/tests/google/bt/pts/SdpPtsTest.py
index 2535671..84c7ab7 100644
--- a/acts/tests/google/bt/pts/SdpPtsTest.py
+++ b/acts/tests/google/bt/pts/SdpPtsTest.py
@@ -97,8 +97,8 @@
 
 
 class SdpPtsTest(PtsBaseClass):
-    def __init__(self, controllers):
-        super(SdpPtsTest, self).__init__(controllers)
+    def setup_class(self):
+        super(SdpPtsTest, self).setup_class()
         self.dut.initialize_bluetooth_controller()
         # self.dut.set_bluetooth_local_name(self.dut_bluetooth_local_name)
         local_dut_mac_address = self.dut.get_local_bluetooth_address()
@@ -127,8 +127,6 @@
 
         self.pts.set_ics_and_ixit(ics, ixit)
 
-    def setup_class(self):
-        super(SdpPtsTest, self).setup_class()
         self.dut.unbond_all_known_devices()
         self.dut.set_discoverable(True)
 
diff --git a/acts/tests/google/bt/sdp/SdpSetupTest.py b/acts/tests/google/bt/sdp/SdpSetupTest.py
index cb63724..938d720 100644
--- a/acts/tests/google/bt/sdp/SdpSetupTest.py
+++ b/acts/tests/google/bt/sdp/SdpSetupTest.py
@@ -77,8 +77,8 @@
 
 
 class SdpSetupTest(BaseTestClass):
-    def __init__(self, controllers):
-        BaseTestClass.__init__(self, controllers)
+    def setup_class(self):
+        super(SdpSetupTest, self).setup_class()
         if 'dut' in self.user_params:
             if self.user_params['dut'] == 'fuchsia_devices':
                 self.dut = create_bluetooth_device(self.fuchsia_devices[0])
@@ -92,8 +92,6 @@
             self.dut = create_bluetooth_device(self.fuchsia_devices[0])
         self.dut.initialize_bluetooth_controller()
 
-    def setup_class(self):
-        super(SdpSetupTest, self).setup_class()
 
     def setup_test(self):
         self.dut.sdp_clean_up()
diff --git a/acts/tests/google/bt/system_tests/BtStressTest.py b/acts/tests/google/bt/system_tests/BtStressTest.py
index 163ee37..0473aa0 100644
--- a/acts/tests/google/bt/system_tests/BtStressTest.py
+++ b/acts/tests/google/bt/system_tests/BtStressTest.py
@@ -33,8 +33,8 @@
     default_timeout = 20
     iterations = 100
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
 
     def teardown_test(self):
         super(BluetoothBaseTest, self).teardown_test()
diff --git a/acts/tests/google/bt/system_tests/RfcommLongevityTest.py b/acts/tests/google/bt/system_tests/RfcommLongevityTest.py
index 3e39344..d1d4fe5 100644
--- a/acts/tests/google/bt/system_tests/RfcommLongevityTest.py
+++ b/acts/tests/google/bt/system_tests/RfcommLongevityTest.py
@@ -39,8 +39,8 @@
         "strange new worlds, to seek out new life and new civilizations,"
         " to boldly go where no man has gone before.")
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.client_ad = self.android_devices[0]
         self.server_ad = self.android_devices[1]
 
diff --git a/acts/tests/google/bt/system_tests/RfcommStressTest.py b/acts/tests/google/bt/system_tests/RfcommStressTest.py
index 8e56ef0..3fac543 100644
--- a/acts/tests/google/bt/system_tests/RfcommStressTest.py
+++ b/acts/tests/google/bt/system_tests/RfcommStressTest.py
@@ -38,8 +38,8 @@
         "strange new worlds, to seek out new life and new civilizations,"
         " to boldly go where no man has gone before.")
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.client_ad = self.android_devices[0]
         self.server_ad = self.android_devices[1]
 
diff --git a/acts/tests/google/experimental/BluetoothLatencyTest.py b/acts/tests/google/experimental/BluetoothLatencyTest.py
index ebb3019..811a41c 100644
--- a/acts/tests/google/experimental/BluetoothLatencyTest.py
+++ b/acts/tests/google/experimental/BluetoothLatencyTest.py
@@ -41,8 +41,8 @@
              data_transfer_type: Data transfer protocol used for the test
         """
 
-    def __init__(self, configs):
-        BaseTestClass.__init__(self, configs)
+    def setup_class(self):
+        super().setup_class()
 
         # Sanity check of the devices under test
         # TODO(b/119051823): Investigate using a config validator to replace this.
diff --git a/acts/tests/google/experimental/BluetoothPairAndConnectTest.py b/acts/tests/google/experimental/BluetoothPairAndConnectTest.py
index f021702..e54e4e7 100644
--- a/acts/tests/google/experimental/BluetoothPairAndConnectTest.py
+++ b/acts/tests/google/experimental/BluetoothPairAndConnectTest.py
@@ -52,8 +52,8 @@
        bt_utils: BTUtils test action object
     """
 
-    def __init__(self, configs):
-        BaseTestClass.__init__(self, configs)
+    def setup_class(self):
+        super().setup_class()
         # Sanity check of the devices under test
         # TODO(b/119051823): Investigate using a config validator to replace this.
         if not self.android_devices:
diff --git a/acts/tests/google/experimental/BluetoothReconnectTest.py b/acts/tests/google/experimental/BluetoothReconnectTest.py
index 717f444..a03ec7b 100644
--- a/acts/tests/google/experimental/BluetoothReconnectTest.py
+++ b/acts/tests/google/experimental/BluetoothReconnectTest.py
@@ -46,8 +46,8 @@
        dut_bt_addr: The Bluetooth address of the Apollo earbuds
     """
 
-    def __init__(self, configs):
-        BaseTestClass.__init__(self, configs)
+    def setup_class(self):
+        super().setup_class()
         # sanity check of the dut devices.
         # TODO(b/119051823): Investigate using a config validator to replace this.
         if not self.android_devices:
diff --git a/acts/tests/google/experimental/BluetoothThroughputTest.py b/acts/tests/google/experimental/BluetoothThroughputTest.py
index 8b4fd48..3403ded 100644
--- a/acts/tests/google/experimental/BluetoothThroughputTest.py
+++ b/acts/tests/google/experimental/BluetoothThroughputTest.py
@@ -37,8 +37,8 @@
          data_transfer_type: Data transfer protocol used for the test
     """
 
-    def __init__(self, configs):
-        BaseTestClass.__init__(self, configs)
+    def setup_class(self):
+        super().setup_class()
 
         # Sanity check of the devices under test
         # TODO(b/119051823): Investigate using a config validator to replace this.
diff --git a/acts/tests/google/fuchsia/bt/BleFuchsiaAndroidTest.py b/acts/tests/google/fuchsia/bt/BleFuchsiaAndroidTest.py
index 59c5006..6c5798a 100644
--- a/acts/tests/google/fuchsia/bt/BleFuchsiaAndroidTest.py
+++ b/acts/tests/google/fuchsia/bt/BleFuchsiaAndroidTest.py
@@ -37,8 +37,8 @@
     active_adv_callback_list = []
     droid = None
 
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
 
         # Android device under test
         self.ad = self.android_devices[0]
diff --git a/acts/tests/google/fuchsia/bt/BleFuchsiaTest.py b/acts/tests/google/fuchsia/bt/BleFuchsiaTest.py
index 4597ed7..7b368ca 100644
--- a/acts/tests/google/fuchsia/bt/BleFuchsiaTest.py
+++ b/acts/tests/google/fuchsia/bt/BleFuchsiaTest.py
@@ -30,8 +30,8 @@
     active_adv_callback_list = []
     droid = None
 
-    def __init__(self, controllers):
-        BaseTestClass.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
 
         if (len(self.fuchsia_devices) < 2):
             self.log.error("BleFuchsiaTest Init: Not enough fuchsia devices.")
diff --git a/acts/tests/google/fuchsia/bt/FuchsiaBtMacAddressTest.py b/acts/tests/google/fuchsia/bt/FuchsiaBtMacAddressTest.py
index ec2042c..c4124b7 100644
--- a/acts/tests/google/fuchsia/bt/FuchsiaBtMacAddressTest.py
+++ b/acts/tests/google/fuchsia/bt/FuchsiaBtMacAddressTest.py
@@ -32,10 +32,9 @@
 class FuchsiaBtMacAddressTest(BaseTestClass):
     scan_timeout_seconds = 10
 
-    def __init__(self, controllers):
-        BaseTestClass.__init__(self, controllers)
-
     def setup_class(self):
+        super().setup_class()
+
         if len(self.fuchsia_devices) < 2:
             raise signals.TestAbortAll("Need at least two Fuchsia devices")
         for device in self.fuchsia_devices:
diff --git a/acts/tests/google/fuchsia/bt/FuchsiaBtScanTest.py b/acts/tests/google/fuchsia/bt/FuchsiaBtScanTest.py
index 5e0ebc3..722a446 100644
--- a/acts/tests/google/fuchsia/bt/FuchsiaBtScanTest.py
+++ b/acts/tests/google/fuchsia/bt/FuchsiaBtScanTest.py
@@ -32,12 +32,11 @@
 class FuchsiaBtScanTest(BaseTestClass):
     scan_timeout_seconds = 30
 
-    def __init__(self, controllers):
-        BaseTestClass.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.pri_dut = self.fuchsia_devices[0]
         self.sec_dut = self.fuchsia_devices[1]
 
-    def setup_class(self):
         self.pri_dut.btc_lib.initBluetoothControl()
         self.sec_dut.btc_lib.initBluetoothControl()
 
diff --git a/acts/tests/google/fuchsia/bt/FuchsiaCmdLineTest.py b/acts/tests/google/fuchsia/bt/FuchsiaCmdLineTest.py
index d34dc62..63c7845 100644
--- a/acts/tests/google/fuchsia/bt/FuchsiaCmdLineTest.py
+++ b/acts/tests/google/fuchsia/bt/FuchsiaCmdLineTest.py
@@ -32,8 +32,8 @@
 class FuchsiaCmdLineTest(BaseTestClass):
     target_device_name = ""
 
-    def __init__(self, controllers):
-        BaseTestClass.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         if not "target_device_name" in self.user_params.keys():
             self.log.warning("Missing user config \"target_device_name\"!")
             self.target_device_name = ""
diff --git a/acts/tests/google/fuchsia/bt/gatt/GattConnectionStressTest.py b/acts/tests/google/fuchsia/bt/gatt/GattConnectionStressTest.py
index caba8f5..5c46548 100644
--- a/acts/tests/google/fuchsia/bt/gatt/GattConnectionStressTest.py
+++ b/acts/tests/google/fuchsia/bt/gatt/GattConnectionStressTest.py
@@ -42,8 +42,8 @@
     scan_timeout_seconds = 10
     default_iterations = 1000
 
-    def __init__(self, controllers):
-        BaseTestClass.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.fuchsia_client_dut = self.fuchsia_devices[0]
         self.fuchsia_server_dut = self.fuchsia_devices[1]
         self.default_iterations = self.user_params.get(
diff --git a/acts/tests/google/fuchsia/bt/gatt/GattServerSetupTest.py b/acts/tests/google/fuchsia/bt/gatt/GattServerSetupTest.py
index 67ef6f8..83418e4 100644
--- a/acts/tests/google/fuchsia/bt/gatt/GattServerSetupTest.py
+++ b/acts/tests/google/fuchsia/bt/gatt/GattServerSetupTest.py
@@ -31,8 +31,8 @@
 class GattServerSetupTest(BaseTestClass):
     err_message = "Setting up database failed with: {}"
 
-    def __init__(self, controllers):
-        BaseTestClass.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.fuchsia_dut = self.fuchsia_devices[0]
 
     def setup_database(self, database):
diff --git a/acts/tests/google/fuchsia/examples/Sl4fSanityTest.py b/acts/tests/google/fuchsia/examples/Sl4fSanityTest.py
index 7d95e2d..d2116a9 100644
--- a/acts/tests/google/fuchsia/examples/Sl4fSanityTest.py
+++ b/acts/tests/google/fuchsia/examples/Sl4fSanityTest.py
@@ -29,10 +29,9 @@
 
 class Sl4fSanityTest(BaseTestClass):
 
-    def __init__(self, controllers):
-        BaseTestClass.__init__(self, controllers)
-
     def setup_class(self):
+        super().setup_class()
+
         success_str = ("Congratulations! Fuchsia controllers have been "
                        "initialized successfully!")
         err_str = ("Sorry, please try verifying FuchsiaDevice is in your "
@@ -40,7 +39,7 @@
         if len(self.fuchsia_devices) > 0:
             self.log.info(success_str)
         else:
-            raise signals.TestSkipClass("err_str")
+            raise signals.TestAbortClass("err_str")
 
     def test_example(self):
         self.log.info("Congratulations! You've run your first test.")
diff --git a/acts/tests/google/fuchsia/logging/FuchsiaLoggingTest.py b/acts/tests/google/fuchsia/logging/FuchsiaLoggingTest.py
index e76f274..28d6998 100644
--- a/acts/tests/google/fuchsia/logging/FuchsiaLoggingTest.py
+++ b/acts/tests/google/fuchsia/logging/FuchsiaLoggingTest.py
@@ -20,8 +20,8 @@
 
 
 class FuchsiaLoggingTest(BaseTestClass):
-    def __init__(self, controllers):
-        BaseTestClass.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.dut = self.fuchsia_devices[0]
         self.message = "Logging Test"
 
diff --git a/acts/tests/google/fuchsia/wlan/ConnectionStressTest.py b/acts/tests/google/fuchsia/wlan/ConnectionStressTest.py
index 02d21af..51bc59c 100644
--- a/acts/tests/google/fuchsia/wlan/ConnectionStressTest.py
+++ b/acts/tests/google/fuchsia/wlan/ConnectionStressTest.py
@@ -44,8 +44,8 @@
     channel_2G = hostapd_constants.AP_DEFAULT_CHANNEL_2G
     channel_5G = hostapd_constants.AP_DEFAULT_CHANNEL_5G
 
-    def __init__(self, controllers):
-        BaseTestClass.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.ssid = rand_ascii_str(10)
         self.fd = self.fuchsia_devices[0]
         self.dut = create_wlan_device(self.fd)
diff --git a/acts/tests/google/fuchsia/wlan/DownloadStressTest.py b/acts/tests/google/fuchsia/wlan/DownloadStressTest.py
index 97d5720..f3f3803 100644
--- a/acts/tests/google/fuchsia/wlan/DownloadStressTest.py
+++ b/acts/tests/google/fuchsia/wlan/DownloadStressTest.py
@@ -52,8 +52,8 @@
     num_of_small_downloads = 5
     download_threads_result = []
 
-    def __init__(self, controllers):
-        BaseTestClass.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.ssid = rand_ascii_str(10)
         self.fd = self.fuchsia_devices[0]
         self.wlan_device = create_wlan_device(self.fd)
@@ -62,7 +62,6 @@
             self.user_params.get("download_stress_test_iterations",
                                  self.num_of_iterations))
 
-    def setup_class(self):
         setup_ap_and_associate(
             access_point=self.ap,
             client=self.wlan_device,
diff --git a/acts/tests/google/fuchsia/wlan/PingStressTest.py b/acts/tests/google/fuchsia/wlan/PingStressTest.py
index 911e3d7..2aa1d00 100644
--- a/acts/tests/google/fuchsia/wlan/PingStressTest.py
+++ b/acts/tests/google/fuchsia/wlan/PingStressTest.py
@@ -43,10 +43,9 @@
     google_dns_1 = '8.8.8.8'
     google_dns_2 = '8.8.4.4'
 
-    def __init__(self, controllers):
-        BaseTestClass.__init__(self, controllers)
-
     def setup_class(self):
+        super().setup_class()
+
         self.ssid = rand_ascii_str(10)
         self.fd = self.fuchsia_devices[0]
         self.wlan_device = create_wlan_device(self.fd)
diff --git a/acts/tests/google/fuchsia/wlan/RebootAPStressTest.py b/acts/tests/google/fuchsia/wlan/RebootAPStressTest.py
index 6e37409..cbe9d12 100644
--- a/acts/tests/google/fuchsia/wlan/RebootAPStressTest.py
+++ b/acts/tests/google/fuchsia/wlan/RebootAPStressTest.py
@@ -56,8 +56,8 @@
     # after AP reboot.
     wait_after_ap_reboot_s = 1
 
-    def __init__(self, controllers):
-        BaseTestClass.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.ssid = rand_ascii_str(10)
         self.wlan_device = create_wlan_device(self.fuchsia_devices[0])
         self.ap = self.access_points[0]
diff --git a/acts/tests/google/fuchsia/wlan/RebootStressTest.py b/acts/tests/google/fuchsia/wlan/RebootStressTest.py
index 86bafbb..fb9a870 100644
--- a/acts/tests/google/fuchsia/wlan/RebootStressTest.py
+++ b/acts/tests/google/fuchsia/wlan/RebootStressTest.py
@@ -38,8 +38,8 @@
     # Eg: "reboot_stress_test_iterations": "10"
     num_of_iterations = 3
 
-    def __init__(self, controllers):
-        BaseTestClass.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.ssid = rand_ascii_str(10)
         self.fd = self.fuchsia_devices[0]
         self.wlan_device = create_wlan_device(self.fd)
@@ -48,7 +48,6 @@
             self.user_params.get("reboot_stress_test_iterations",
                                  self.num_of_iterations))
 
-    def setup_class(self):
         setup_ap_and_associate(
             access_point=self.ap,
             client=self.wlan_device,
diff --git a/acts/tests/google/fugu/AndroidFuguRemotePairingTest.py b/acts/tests/google/fugu/AndroidFuguRemotePairingTest.py
old mode 100755
new mode 100644
index 03b443f..a41f9fc
--- a/acts/tests/google/fugu/AndroidFuguRemotePairingTest.py
+++ b/acts/tests/google/fugu/AndroidFuguRemotePairingTest.py
@@ -22,8 +22,8 @@
 from acts.test_utils.bt.BluetoothBaseTest import BluetoothBaseTest
 
 class AndroidFuguRemotePairingTest(BluetoothBaseTest):
-    def __init__(self, controllers):
-        BluetoothBaseTest.__init__(self, controllers)
+    def setup_class(self):
+        super().setup_class()
         self.dut = self.android_devices[0]
         self.fugu_remote = self.relay_devices[0]
 
diff --git a/acts/tests/google/gnss/AGNSSPerformanceTest.py b/acts/tests/google/gnss/AGNSSPerformanceTest.py
index 60dce02..a14a1ba 100644
--- a/acts/tests/google/gnss/AGNSSPerformanceTest.py
+++ b/acts/tests/google/gnss/AGNSSPerformanceTest.py
@@ -18,7 +18,7 @@
 
 from acts import base_test
 from acts import asserts
-from acts.controllers.gnssinst_lib.rohdeschwarz import contest
+from acts.controllers.rohdeschwarz_lib import contest
 from acts.test_utils.tel import tel_test_utils
 import json
 
diff --git a/acts/tests/google/gnss/FlpTtffTest.py b/acts/tests/google/gnss/FlpTtffTest.py
index 77e8cf0..0a36923 100644
--- a/acts/tests/google/gnss/FlpTtffTest.py
+++ b/acts/tests/google/gnss/FlpTtffTest.py
@@ -56,7 +56,6 @@
         for network in self.pixel_lab_network:
             SSID = network['SSID']
             self.ssid_map[SSID] = network
-
         if int(self.ad.adb.shell("settings get global airplane_mode_on")) != 0:
             self.ad.log.info("Force airplane mode off")
             force_airplane_mode(self.ad, False)
diff --git a/acts/tests/google/gnss/GnssSanityTest.py b/acts/tests/google/gnss/GnssSanityTest.py
index 4d707d5..28c2ccf 100644
--- a/acts/tests/google/gnss/GnssSanityTest.py
+++ b/acts/tests/google/gnss/GnssSanityTest.py
@@ -69,6 +69,8 @@
 from acts.test_utils.gnss.gnss_test_utils import check_xtra_download
 from acts.test_utils.gnss.gnss_test_utils import gnss_tracking_via_gtw_gpstool
 from acts.test_utils.gnss.gnss_test_utils import parse_gtw_gpstool_log
+from acts.test_utils.gnss.gnss_test_utils import enable_supl_mode
+from acts.test_utils.gnss.gnss_test_utils import start_toggle_gnss_by_gtw_gpstool
 
 
 class GnssSanityTest(BaseTestClass):
@@ -77,8 +79,8 @@
         super().setup_class()
         self.ad = self.android_devices[0]
         req_params = ["pixel_lab_network", "standalone_cs_criteria",
-                      "supl_cs_criteria", "xtra_ws_criteria", "xtra_cs_criteria",
-                      "weak_signal_supl_cs_criteria",
+                      "supl_cs_criteria", "xtra_ws_criteria",
+                      "xtra_cs_criteria", "weak_signal_supl_cs_criteria",
                       "weak_signal_xtra_ws_criteria",
                       "weak_signal_xtra_cs_criteria",
                       "default_gnss_signal_attenuation",
@@ -98,7 +100,6 @@
         else:
             self.wifi_xtra_cs_criteria = self.xtra_cs_criteria
         self.flash_new_radio_or_mbn()
-
         set_attenuator_gnss_signal(self.ad, self.attenuators,
                                    self.default_gnss_signal_attenuation)
         _init_device(self.ad)
@@ -259,7 +260,8 @@
                     self.ad.log.error("\n%s" % error)
             else:
                 self.ad.log.info("NO \"%s\" initialization error found." % attr)
-        asserts.assert_true(error_mismatch, "Error message found after GNSS init")
+        asserts.assert_true(error_mismatch, "Error message found after GNSS "
+                                            "init")
 
     @test_tracker_info(uuid="ff318483-411c-411a-8b1a-422bd54f4a3f")
     def test_supl_capabilities(self):
@@ -436,7 +438,8 @@
             4. DUT hang up call.
 
         Expected Results:
-            All SUPL TTFF Cold Start results should be less than supl_cs_criteria.
+            All SUPL TTFF Cold Start results should be less than
+            supl_cs_criteria.
         """
         begin_time = get_current_epoch_time()
         start_qxdm_logger(self.ad, begin_time)
@@ -539,9 +542,9 @@
             start_ttff_by_gtw_gpstool(self.ad, ttff_mode="cs", iteration=3)
             ttff_data = process_ttff_by_gtw_gpstool(self.ad, begin_time,
                                                     self.pixel_lab_location)
-            supl_ssr_test_result = check_ttff_data(self.ad, ttff_data,
-                                                   ttff_mode="Cold Start",
-                                                   criteria=self.supl_cs_criteria)
+            supl_ssr_test_result = check_ttff_data(
+                self.ad, ttff_data, ttff_mode="Cold Start",
+                criteria=self.supl_cs_criteria)
             self.ad.log.info("SUPL after Modem SSR test %d times -> %s"
                              % (times, supl_ssr_test_result))
             supl_ssr_test_result_all.append(supl_ssr_test_result)
@@ -713,7 +716,9 @@
         start_ttff_by_gtw_gpstool(self.ad, ttff_mode="ws", iteration=10)
         ws_ttff_data = process_ttff_by_gtw_gpstool(self.ad, begin_time,
                                                    self.pixel_lab_location)
-        ws_result = check_ttff_data(self.ad, ws_ttff_data, ttff_mode="Warm Start",
+        ws_result = check_ttff_data(self.ad,
+                                    ws_ttff_data,
+                                    ttff_mode="Warm Start",
                                     criteria=self.xtra_ws_criteria)
         xtra_result.append(ws_result)
         begin_time = get_current_epoch_time()
@@ -721,7 +726,9 @@
         start_ttff_by_gtw_gpstool(self.ad, ttff_mode="cs", iteration=10)
         cs_ttff_data = process_ttff_by_gtw_gpstool(self.ad, begin_time,
                                                    self.pixel_lab_location)
-        cs_result = check_ttff_data(self.ad, cs_ttff_data, ttff_mode="Cold Start",
+        cs_result = check_ttff_data(self.ad,
+                                    cs_ttff_data,
+                                    ttff_mode="Cold Start",
                                     criteria=self.xtra_cs_criteria)
         xtra_result.append(cs_result)
         asserts.assert_true(all(xtra_result),
@@ -752,7 +759,9 @@
         start_ttff_by_gtw_gpstool(self.ad, ttff_mode="ws", iteration=10)
         ws_ttff_data = process_ttff_by_gtw_gpstool(self.ad, begin_time,
                                                    self.pixel_lab_location)
-        ws_result = check_ttff_data(self.ad, ws_ttff_data, ttff_mode="Warm Start",
+        ws_result = check_ttff_data(self.ad,
+                                    ws_ttff_data,
+                                    ttff_mode="Warm Start",
                                     criteria=self.weak_signal_xtra_ws_criteria)
         xtra_result.append(ws_result)
         begin_time = get_current_epoch_time()
@@ -760,7 +769,9 @@
         start_ttff_by_gtw_gpstool(self.ad, ttff_mode="cs", iteration=10)
         cs_ttff_data = process_ttff_by_gtw_gpstool(self.ad, begin_time,
                                                    self.pixel_lab_location)
-        cs_result = check_ttff_data(self.ad, cs_ttff_data, ttff_mode="Cold Start",
+        cs_result = check_ttff_data(self.ad,
+                                    cs_ttff_data,
+                                    ttff_mode="Cold Start",
                                     criteria=self.weak_signal_xtra_cs_criteria)
         xtra_result.append(cs_result)
         asserts.assert_true(all(xtra_result),
@@ -787,13 +798,15 @@
         self.ad.log.info("Turn airplane mode on")
         force_airplane_mode(self.ad, True)
         wifi_toggle_state(self.ad, True)
-        connect_to_wifi_network(self.ad,
-                                self.ssid_map[self.pixel_lab_network[0]["SSID"]])
+        connect_to_wifi_network(
+            self.ad, self.ssid_map[self.pixel_lab_network[0]["SSID"]])
         process_gnss_by_gtw_gpstool(self.ad, self.standalone_cs_criteria)
         start_ttff_by_gtw_gpstool(self.ad, ttff_mode="ws", iteration=10)
         ws_ttff_data = process_ttff_by_gtw_gpstool(self.ad, begin_time,
                                                    self.pixel_lab_location)
-        ws_result = check_ttff_data(self.ad, ws_ttff_data, ttff_mode="Warm Start",
+        ws_result = check_ttff_data(self.ad,
+                                    ws_ttff_data,
+                                    ttff_mode="Warm Start",
                                     criteria=self.xtra_ws_criteria)
         xtra_result.append(ws_result)
         begin_time = get_current_epoch_time()
@@ -801,7 +814,9 @@
         start_ttff_by_gtw_gpstool(self.ad, ttff_mode="cs", iteration=10)
         cs_ttff_data = process_ttff_by_gtw_gpstool(self.ad, begin_time,
                                                    self.pixel_lab_location)
-        cs_result = check_ttff_data(self.ad, cs_ttff_data, ttff_mode="Cold Start",
+        cs_result = check_ttff_data(self.ad,
+                                    cs_ttff_data,
+                                    ttff_mode="Cold Start",
                                     criteria=self.wifi_xtra_cs_criteria)
         xtra_result.append(cs_result)
         asserts.assert_true(all(xtra_result),
@@ -833,9 +848,9 @@
             start_ttff_by_gtw_gpstool(self.ad, ttff_mode="cs", iteration=3)
             ttff_data = process_ttff_by_gtw_gpstool(self.ad, begin_time,
                                                     self.pixel_lab_location)
-            xtra_ssr_test_result = check_ttff_data(self.ad, ttff_data,
-                                                   ttff_mode="Cold Start",
-                                                   criteria=self.xtra_cs_criteria)
+            xtra_ssr_test_result = check_ttff_data(
+                self.ad, ttff_data, ttff_mode="Cold Start",
+                criteria=self.xtra_cs_criteria)
             self.ad.log.info("XTRA after Modem SSR test %d times -> %s"
                              % (times, xtra_ssr_test_result))
             xtra_ssr_test_result_all.append(xtra_ssr_test_result)
@@ -889,8 +904,8 @@
         self.ad.log.info("Turn airplane mode on")
         force_airplane_mode(self.ad, True)
         wifi_toggle_state(self.ad, True)
-        connect_to_wifi_network(self.ad,
-                                self.ssid_map[self.pixel_lab_network[0]["SSID"]])
+        connect_to_wifi_network(
+            self.ad, self.ssid_map[self.pixel_lab_network[0]["SSID"]])
         for i in range(1, 6):
             begin_time = get_current_epoch_time()
             process_gnss_by_gtw_gpstool(self.ad, self.standalone_cs_criteria)
@@ -901,3 +916,23 @@
             self.ad.log.info("Iteraion %d => %s" % (i, wifi_xtra_result))
         asserts.assert_true(all(wifi_xtra_result_all),
                             "Fail to Download XTRA file")
+
+    @test_tracker_info(uuid="2a9f2890-3c0a-48b8-821d-bf97e36355e9")
+    def test_quick_toggle_gnss_state(self):
+        """Verify GNSS can still work properly after quick toggle GNSS off
+        to on.
+
+        Steps:
+            1. Launch GTW_GPSTool.
+            2. Go to "Advance setting"
+            3. Set Cycle = 10 & Time-out = 60
+            4. Go to "Toggle GPS" tab
+            5. Execute "Start"
+
+        Expected Results:
+            No single Timeout is seen in 10 iterations.
+        """
+        enable_supl_mode(self.ad)
+        reboot(self.ad)
+        start_qxdm_logger(self.ad, get_current_epoch_time())
+        start_toggle_gnss_by_gtw_gpstool(self.ad, iteration=10)
diff --git a/acts/tests/google/native/NativeTest.py b/acts/tests/google/native/NativeTest.py
index be5fd2a..90ebceb 100644
--- a/acts/tests/google/native/NativeTest.py
+++ b/acts/tests/google/native/NativeTest.py
@@ -24,7 +24,6 @@
 
     def __init__(self, controllers):
         BaseTestClass.__init__(self, controllers)
-        self.droid = self.native_android_devices[0].droid
         self.tests = (
                 "test_bool_return_true",
                 "test_bool_return_false",
@@ -33,6 +32,10 @@
                 "test_max_param_size",
         )
 
+    def setup_class(self):
+        super().setup_class()
+        self.droid = self.native_android_devices[0].droid
+
     def test_bool_return_true(self):
         return self.droid.TestBoolTrueReturn()
 
diff --git a/acts/tests/google/native/bt/BtNativeTest.py b/acts/tests/google/native/bt/BtNativeTest.py
index 5315e34..55674bc 100644
--- a/acts/tests/google/native/bt/BtNativeTest.py
+++ b/acts/tests/google/native/bt/BtNativeTest.py
@@ -1,4 +1,3 @@
-mport time
 from acts.base_test import BaseTestClass
 from acts.controllers import native_android_device
 from acts.test_utils.bt.native_bt_test_utils import setup_native_bluetooth
@@ -10,13 +9,15 @@
 
     def __init__(self, controllers):
         BaseTestClass.__init__(self, controllers)
-        setup_native_bluetooth(self.native_android_devices)
-        self.droid = self.native_android_devices[0].droid
         self.tests = (
             "test_binder_get_name",
             "test_binder_get_name_invalid_parameter",
             "test_binder_set_name_get_name",
             "test_binder_get_address", )
+
+    def setup_class(self):
+        setup_native_bluetooth(self.native_android_devices)
+        self.droid = self.native_android_devices[0].droid
         if len(self.native_android_devices) > 1:
             self.droid1 = self.native_android_devices[1].droid
             self.tests = self.tests + ("test_two_devices_set_get_name", )
diff --git a/acts/tests/google/net/CoreNetworkingOTATest.py b/acts/tests/google/net/CoreNetworkingOTATest.py
index 2444971..5b350f8 100755
--- a/acts/tests/google/net/CoreNetworkingOTATest.py
+++ b/acts/tests/google/net/CoreNetworkingOTATest.py
@@ -84,7 +84,7 @@
           for ad in self.android_devices:
               ota_updater.update(ad)
         except Exception as err:
-            raise signals.TestSkipClass(
+            raise signals.TestAbortClass(
                 "Failed up apply OTA update. Aborting tests")
 
     def on_fail(self, test_name, begin_time):
diff --git a/acts/tests/google/net/DnsOverTlsTest.py b/acts/tests/google/net/DnsOverTlsTest.py
index e69a5ae..e8a883d 100644
--- a/acts/tests/google/net/DnsOverTlsTest.py
+++ b/acts/tests/google/net/DnsOverTlsTest.py
@@ -86,28 +86,27 @@
         """
         return stop_tcpdump(ad, self.tcpdump_pid, self.test_name)
 
-    def _verify_dns_queries_over_tls(self, pcap_file, dns, tls=True):
+    def _verify_dns_queries_over_tls(self, pcap_file, tls=True):
         """ Verify if DNS queries were over TLS or not
 
         Args:
             1. pcap_file: tcpdump file
-            2. dns: private DNS set in strict mode
-            3. tls: if queries should be over TLS or port 853
+            2. tls: if queries should be over TLS or port 853
         """
-        if not dns:
-            dns = cconst.DNS_GOOGLE
         try:
             packets = rdpcap(pcap_file)
-        except Scapy_Exception:
+        except Scapy_Excaption:
             asserts.fail("Not a valid pcap file")
         for pkt in packets:
             summary = "%s" % pkt.summary()
-            if tls and UDP in pkt and pkt[UDP].dport == 53 and \
-                dns not in summary and 'mtalk.google.com' not in summary:
-                  asserts.fail("Found query to port 53: %s" % summary)
-            elif not tls and TCP in pkt and pkt[TCP].dport == 853 and \
-                not pkt[TCP].flags:
-                  asserts.fail("Found query to port 853: %s" % summary)
+            for host in self.ping_hosts:
+                host = host.split('.')[-2]
+                if tls and UDP in pkt and pkt[UDP].dport == 53 and \
+                    host in summary:
+                      asserts.fail("Found query to port 53: %s" % summary)
+                elif not tls and TCP in pkt and pkt[TCP].dport == 853 and \
+                    not pkt[TCP].flags:
+                      asserts.fail("Found query to port 853: %s" % summary)
 
     def _verify_rst_packets(self, pcap_file):
         """ Verify if RST packets are found in the pcap file
@@ -155,7 +154,7 @@
         pcap_file = self._stop_tcp_dump(self.dut)
 
         # verify DNS queries
-        self._verify_dns_queries_over_tls(pcap_file, hostname, use_tls)
+        self._verify_dns_queries_over_tls(pcap_file, use_tls)
 
         # reset wifi
         wutils.reset_wifi(self.dut)
diff --git a/acts/tests/google/power/tel/lab/PowerTelHotspotTest.py b/acts/tests/google/power/tel/lab/PowerTelHotspotTest.py
index 59a9dc6..66aa458 100644
--- a/acts/tests/google/power/tel/lab/PowerTelHotspotTest.py
+++ b/acts/tests/google/power/tel/lab/PowerTelHotspotTest.py
@@ -106,12 +106,14 @@
             dut.droid.wifiSetCountryCode(country_code)
 
         # Setup tethering
-        wutils.start_wifi_tethering(
-            self.dut, self.network[wutils.WifiEnums.SSID_KEY],
-            self.network[wutils.WifiEnums.PWD_KEY], self.wifi_band)
+        wutils.start_wifi_tethering(self.dut,
+                                    self.network[wutils.WifiEnums.SSID_KEY],
+                                    self.network[wutils.WifiEnums.PWD_KEY],
+                                    self.wifi_band)
 
-        wutils.wifi_connect(
-            self.android_devices[1], self.network, check_connectivity=False)
+        wutils.wifi_connect(self.android_devices[1],
+                            self.network,
+                            check_connectivity=False)
 
         # Start data traffic
         iperf_helpers = self.start_tel_traffic(self.android_devices[1])
diff --git a/acts/tests/google/power/tel/lab/PowerTelIdleTest.py b/acts/tests/google/power/tel/lab/PowerTelIdleTest.py
index 7af7cdc..934fe20 100644
--- a/acts/tests/google/power/tel/lab/PowerTelIdleTest.py
+++ b/acts/tests/google/power/tel/lab/PowerTelIdleTest.py
@@ -24,17 +24,16 @@
     cellular idle scenarios to verify the ability to set power consumption
     to a minimum during connectivity power tests.
     """
-
     def power_tel_idle_test(self):
         """ Measures power when the device is on LTE RRC idle state. """
 
         idle_wait_time = self.simulation.rrc_sc_timer + 30
 
         # Wait for RRC status change to trigger
-        self.simulation.wait_for_rrc_idle_state(idle_wait_time)
+        self.cellular_simulator.wait_until_idle_state(idle_wait_time)
 
         # Measure power
         self.collect_power_data()
 
         # Check if power measurement is below the required value
-        self.pass_fail_check()
\ No newline at end of file
+        self.pass_fail_check()
diff --git a/acts/tests/google/power/tel/lab/PowerTelTrafficTest.py b/acts/tests/google/power/tel/lab/PowerTelTrafficTest.py
index 9e9a85f..97094e3 100644
--- a/acts/tests/google/power/tel/lab/PowerTelTrafficTest.py
+++ b/acts/tests/google/power/tel/lab/PowerTelTrafficTest.py
@@ -55,6 +55,11 @@
 
         super().__init__(controllers)
 
+        # Verify that at least one PacketSender controller has been initialized
+        if not hasattr(self, 'packet_senders'):
+            raise RuntimeError('At least one packet sender controller needs '
+                               'to be defined in the test config files.')
+
         # These variables are passed to iPerf when starting data
         # traffic with the -b parameter to limit throughput on
         # the application layer.
@@ -212,8 +217,9 @@
                                "current simulation class.")
             else:
 
-                self.log.info("The expected {} throughput is {} Mbit/s.".format(
-                    direction, expected_t))
+                self.log.info(
+                    "The expected {} throughput is {} Mbit/s.".format(
+                        direction, expected_t))
                 asserts.assert_true(
                     0.90 < throughput / expected_t < 1.10,
                     "{} throughput differed more than 10% from the expected "
@@ -237,7 +243,8 @@
         """
 
         # The iPerf server is hosted in this computer
-        self.iperf_server_address = scapy.get_if_addr(self.pkt_sender.interface)
+        self.iperf_server_address = scapy.get_if_addr(
+            self.packet_senders[0].interface)
 
         # Start iPerf traffic
         iperf_helpers = []
@@ -320,7 +327,8 @@
 
         config = {
             'traffic_type': 'TCP',
-            'duration': self.mon_duration + self.mon_offset + self.IPERF_MARGIN,
+            'duration':
+            self.mon_duration + self.mon_offset + self.IPERF_MARGIN,
             'start_meas_time': 4,
             'server_idx': server_idx,
             'port': self.iperf_servers[server_idx].port,
diff --git a/acts/tests/google/tel/live/TelLiveConnectivityMonitorBaseTest.py b/acts/tests/google/tel/live/TelLiveConnectivityMonitorBaseTest.py
index c9378e4..135f583 100644
--- a/acts/tests/google/tel/live/TelLiveConnectivityMonitorBaseTest.py
+++ b/acts/tests/google/tel/live/TelLiveConnectivityMonitorBaseTest.py
@@ -37,6 +37,7 @@
 from acts.test_utils.tel.tel_test_utils import get_device_epoch_time
 from acts.test_utils.tel.tel_test_utils import get_model_name
 from acts.test_utils.tel.tel_test_utils import get_operator_name
+from acts.test_utils.tel.tel_test_utils import get_outgoing_voice_sub_id
 from acts.test_utils.tel.tel_test_utils import hangup_call
 from acts.test_utils.tel.tel_test_utils import last_call_drop_reason
 from acts.test_utils.tel.tel_test_utils import reboot_device
@@ -125,9 +126,11 @@
         self.ad_reference = self.android_devices[1]
         self.dut_model = get_model_name(self.dut)
         self.dut_operator = get_operator_name(self.log, self.dut)
-        self.dut_capabilities = self.dut.telephony.get("capabilities", [])
-        self.dut_wfc_modes = self.dut.telephony.get("wfc_modes", [])
-        self.reference_capabilities = self.ad_reference.telephony.get(
+        self.dut_subID = get_outgoing_voice_sub_id(self.dut)
+        self.dut_capabilities = self.dut.telephony["subscription"][self.dut_subID].get("capabilities", [])
+        self.dut_wfc_modes = self.dut.telephony["subscription"][self.dut_subID].get("wfc_modes", [])
+        self.ad_reference_subID = get_outgoing_voice_sub_id(self.ad_reference)
+        self.reference_capabilities = self.ad_reference.telephony["subscription"][self.ad_reference_subID].get(
             "capabilities", [])
         self.dut.log.info("DUT capabilities: %s", self.dut_capabilities)
         self.skip_reset_between_cases = False
diff --git a/acts/tests/google/tel/live/TelLiveImsSettingsTest.py b/acts/tests/google/tel/live/TelLiveImsSettingsTest.py
index 64f81ca..7a6d384 100644
--- a/acts/tests/google/tel/live/TelLiveImsSettingsTest.py
+++ b/acts/tests/google/tel/live/TelLiveImsSettingsTest.py
@@ -86,9 +86,9 @@
             subid].get("capabilities", [])
         self.dut.log.info("DUT capabilities: %s", self.dut_capabilities)
         if CAPABILITY_VOLTE not in self.dut_capabilities:
-            raise signals.TestSkipClass("VoLTE is not supported")
+            raise signals.TestAbortClass("VoLTE is not supported")
         if CAPABILITY_WFC not in self.dut_capabilities:
-            raise signals.TestSkipClass("WFC is not supported")
+            raise signals.TestAbortClass("WFC is not supported")
 
         self.default_volte = (CAPABILITY_VOLTE in self.dut_capabilities) and (
             self.carrier_configs[CarrierConfigs.
diff --git a/acts/tests/google/tel/live/TelLiveNoQXDMLogTest.py b/acts/tests/google/tel/live/TelLiveNoQXDMLogTest.py
index 94c2cbf..86e9927 100644
--- a/acts/tests/google/tel/live/TelLiveNoQXDMLogTest.py
+++ b/acts/tests/google/tel/live/TelLiveNoQXDMLogTest.py
@@ -69,10 +69,12 @@
     def setup_class(self):
         super().setup_class()
         self.dut = self.android_devices[0]
-        self.ad_reference = self.android_devices[1] if len(
-            self.android_devices) > 1 else None
+        if len(self.android_devices) > 1:
+            self.ad_reference = self.android_devices[1]
+            setattr(self.ad_reference, "qxdm_log", False)
+        else:
+            self.ad_reference = None
         setattr(self.dut, "qxdm_log", False)
-        setattr(self.ad_reference, "qxdm_log", False)
         self.stress_test_number = int(
             self.user_params.get("stress_test_number", 5))
         self.skip_reset_between_cases = False
@@ -379,9 +381,8 @@
         begin_time = get_current_epoch_time()
         for i in range(3):
             try:
-                bugreport_path = os.path.join(ad.log_path, self.test_name)
-                create_dir(bugreport_path)
                 ad.take_bug_report(self.test_name, begin_time)
+                bugreport_path = ad.device_log_path
                 break
             except Exception as e:
                 ad.log.error("bugreport attempt %s error: %s", i + 1, e)
@@ -406,9 +407,11 @@
                 exe_cmd("tar -xvf %s" %
                         (bugreport_path + "/dumpstate_board.tar"))
                 os.chdir(current_dir)
-                if os.path.isfile(bugreport_path + "/power_anomaly_data.txt"):
-                    ad.log.info("Modem Power Anomaly File Exists!!")
-                    return True
+            else:
+                ad.log.info("The dumpstate_path file %s does not exist" % dumpstate_path)
+            if os.path.isfile(bugreport_path + "/power_anomaly_data.txt"):
+                ad.log.info("Modem Power Anomaly File Exists!!")
+                return True
             ad.log.info("Modem Power Anomaly File DO NOT Exist!!")
             return False
         except Exception as e:
@@ -504,7 +507,8 @@
                 ad.wait_for_boot_completion()
                 ad.root_adb()
                 ad.log.info("Re-install sl4a")
-                ad.adb.shell("settings put global package_verifier_enable 0")
+                ad.adb.shell("settings put global verifier_verify_adb_installs"
+                             " 0")
                 ad.adb.install("-r /tmp/base.apk")
                 time.sleep(10)
                 try:
diff --git a/acts/tests/google/tel/live/TelLiveRebootStressTest.py b/acts/tests/google/tel/live/TelLiveRebootStressTest.py
index 70677e1..2936d9e 100644
--- a/acts/tests/google/tel/live/TelLiveRebootStressTest.py
+++ b/acts/tests/google/tel/live/TelLiveRebootStressTest.py
@@ -95,8 +95,9 @@
         self.user_params["check_crash"] = False
         self.skip_reset_between_cases = False
 
-        self.dut_capabilities = self.dut.telephony.get("capabilities", [])
-        self.dut_wfc_modes = self.dut.telephony.get("wfc_modes", [])
+        self.dut_subID = get_outgoing_voice_sub_id(self.dut)
+        self.dut_capabilities = self.dut.telephony["subscription"][self.dut_subID].get("capabilities", [])
+        self.dut_wfc_modes = self.dut.telephony["subscription"][self.dut_subID].get("wfc_modes", [])
         self.default_testing_func_names = []
         for method in ("_check_volte", "_check_vt", "_check_csfb",
                        "_check_tethering", "_check_wfc_apm",
diff --git a/acts/tests/google/tel/live/TelLiveSettingsTest.py b/acts/tests/google/tel/live/TelLiveSettingsTest.py
index 791e9e7..10b045f 100644
--- a/acts/tests/google/tel/live/TelLiveSettingsTest.py
+++ b/acts/tests/google/tel/live/TelLiveSettingsTest.py
@@ -51,7 +51,8 @@
         self.number_of_devices = 1
         self.stress_test_number = self.get_stress_test_number()
         self.carrier_configs = dumpsys_carrier_config(self.dut)
-        self.dut_capabilities = self.dut.telephony.get("capabilities", [])
+        self.dut_subID = get_outgoing_voice_sub_id(self.dut)
+        self.dut_capabilities = self.dut.telephony["subscription"][self.dut_subID].get("capabilities", [])
 
     @test_tracker_info(uuid="c6149bd6-7080-453d-af37-1f9bd350a764")
     @TelephonyBaseTest.tel_test_wrap
diff --git a/acts/tests/google/tel/live/TelLiveStressTest.py b/acts/tests/google/tel/live/TelLiveStressTest.py
index 899e758..6a4276d 100644
--- a/acts/tests/google/tel/live/TelLiveStressTest.py
+++ b/acts/tests/google/tel/live/TelLiveStressTest.py
@@ -125,7 +125,9 @@
                 self.file_download_method = "curl"
         else:
             self.android_devices = self.android_devices[:2]
+        self.sdm_log = self.user_params.get("sdm_log", False)
         for ad in self.android_devices:
+            setattr(ad, "sdm_log", self.sdm_log)
             ad.adb.shell("setprop nfc.debug_enable 1")
             if self.user_params.get("turn_on_tcpdump", False):
                 start_adb_tcpdump(ad, interface="any", mask="all")
@@ -150,7 +152,6 @@
         self.dut_incall = False
         self.dsds_esim = self.user_params.get("dsds_esim", False)
         self.cbrs_esim = self.user_params.get("cbrs_esim", False)
-        self.sdm_log = self.user_params.get("sdm_log", False)
         telephony_info = getattr(self.dut, "telephony", {})
         self.dut_capabilities = telephony_info.get("capabilities", [])
         self.dut_wfc_modes = telephony_info.get("wfc_modes", [])
@@ -1102,7 +1103,7 @@
     def test_lte_volte_parallel_stress(self):
         """ VoLTE on stress test"""
         if CAPABILITY_VOLTE not in self.dut_capabilities:
-            raise signals.TestSkipClass("VoLTE is not supported")
+            raise signals.TestAbortClass("VoLTE is not supported")
         return self.parallel_tests(
             setup_func=self._setup_lte_volte_enabled,
             call_verification_func=is_phone_in_call_volte)
@@ -1120,7 +1121,7 @@
     def test_wfc_parallel_stress(self):
         """ Wifi calling APM mode off stress test"""
         if CAPABILITY_WFC not in self.dut_capabilities:
-            raise signals.TestSkipClass("WFC is not supported")
+            raise signals.TestAbortClass("WFC is not supported")
         if WFC_MODE_WIFI_PREFERRED not in self.dut_wfc_modes:
             raise signals.TestSkip("WFC_MODE_WIFI_PREFERRED is not supported")
         return self.parallel_tests(
@@ -1132,7 +1133,7 @@
     def test_wfc_apm_parallel_stress(self):
         """ Wifi calling in APM mode on stress test"""
         if CAPABILITY_WFC not in self.dut_capabilities:
-            raise signals.TestSkipClass("WFC is not supported")
+            raise signals.TestAbortClass("WFC is not supported")
         return self.parallel_tests(
             setup_func=self._setup_wfc_apm,
             call_verification_func=is_phone_in_call_iwlan)
@@ -1158,7 +1159,7 @@
     def test_volte_modeprefchange_parallel_stress(self):
         """ VoLTE Mode Pref call stress test"""
         if CAPABILITY_VOLTE not in self.dut_capabilities:
-            raise signals.TestSkipClass("VoLTE is not supported")
+            raise signals.TestAbortClass("VoLTE is not supported")
         return self.parallel_with_network_change_tests(
             setup_func=self._setup_lte_volte_enabled)
 
diff --git a/acts/tests/google/wifi/WifiAutoUpdateTest.py b/acts/tests/google/wifi/WifiAutoUpdateTest.py
index 04fb850..33369a2 100755
--- a/acts/tests/google/wifi/WifiAutoUpdateTest.py
+++ b/acts/tests/google/wifi/WifiAutoUpdateTest.py
@@ -93,7 +93,7 @@
         try:
             ota_updater.update(self.dut)
         except Exception as err:
-            raise signals.TestSkipClass(
+            raise signals.TestAbortClass(
                 "Failed up apply OTA update. Aborting tests")
 
     def setup_test(self):
diff --git a/acts/tests/google/wifi/WifiCrashStressTest.py b/acts/tests/google/wifi/WifiCrashStressTest.py
index bf17ada..837112a 100644
--- a/acts/tests/google/wifi/WifiCrashStressTest.py
+++ b/acts/tests/google/wifi/WifiCrashStressTest.py
@@ -41,7 +41,7 @@
         wutils.wifi_test_device_init(self.dut)
         wutils.wifi_test_device_init(self.dut_client)
         if not self.dut.is_apk_installed("com.google.mdstest"):
-            raise signals.TestSkipClass("mdstest is not installed")
+            raise signals.TestAbortClass("mdstest is not installed")
         req_params = ["dbs_supported_models", "stress_count"]
         opt_param = ["reference_networks"]
         self.unpack_userparams(
diff --git a/acts/tests/google/wifi/WifiPingTest.py b/acts/tests/google/wifi/WifiPingTest.py
index 551719d..8abe9eb 100644
--- a/acts/tests/google/wifi/WifiPingTest.py
+++ b/acts/tests/google/wifi/WifiPingTest.py
@@ -25,6 +25,7 @@
 from acts import base_test
 from acts import utils
 from acts.controllers.utils_lib import ssh
+from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
 from acts.test_utils.wifi import ota_chamber
 from acts.test_utils.wifi import wifi_performance_test_utils as wputils
 from acts.test_utils.wifi import wifi_retail_ap as retail_ap
@@ -57,9 +58,9 @@
     def __init__(self, controllers):
         base_test.BaseTestClass.__init__(self, controllers)
         self.testcase_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_case())
+            BlackboxMappedMetricLogger.for_test_case())
         self.testclass_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_class())
+            BlackboxMappedMetricLogger.for_test_class())
         self.publish_testcase_metrics = True
 
         self.tests = self.generate_test_cases(
@@ -107,6 +108,11 @@
         self.testclass_results = []
 
         # Turn WiFi ON
+        if self.testclass_params.get('airplane_mode', 1):
+            self.log.info('Turning on airplane mode.')
+            asserts.assert_true(
+                utils.force_airplane_mode(self.dut, True),
+                "Can not turn on airplane mode.")
         wutils.wifi_toggle_state(self.dut, True)
 
     def teardown_class(self):
@@ -190,15 +196,15 @@
             self.testcase_metric_logger.add_metric('ping_range',
                                                    result['range'])
         # Evaluate test pass/fail
+        test_message = ('Attenuation at range is {}dB. Golden range is {}dB. '
+                        'LLStats at Range: {}'.format(
+                            result['range'], rvr_range,
+                            result['llstats_at_range']))
         if result['range'] - rvr_range < -self.testclass_params[
                 'range_gap_threshold']:
-            asserts.fail(
-                'Attenuation at range is {}dB. Golden range is {}dB'.format(
-                    result['range'], rvr_range))
+            asserts.fail(test_message)
         else:
-            asserts.explicit_pass(
-                'Attenuation at range is {}dB. Golden range is {}dB'.format(
-                    result['range'], rvr_range))
+            asserts.explicit_pass(test_message)
 
     def pass_fail_check(self, result):
         if 'range' in result['testcase_params']['test_type']:
@@ -233,6 +239,15 @@
             ping_loss_over_att)
         ping_range_result['range'] = (ping_range_result['atten_at_range'] +
                                       ping_range_result['fixed_attenuation'])
+        ping_range_result['llstats_at_range'] = (
+            'TX MCS = {0} ({1:.1f}%). '
+            'RX MCS = {2} ({3:.1f}%)'.format(
+                ping_range_result['llstats'][range_index]['summary']
+                ['common_tx_mcs'], ping_range_result['llstats'][range_index]
+                ['summary']['common_tx_mcs_freq'] * 100,
+                ping_range_result['llstats'][range_index]['summary']
+                ['common_rx_mcs'], ping_range_result['llstats'][range_index]
+                ['summary']['common_rx_mcs_freq'] * 100))
 
         # Save results
         results_file_path = os.path.join(
@@ -241,22 +256,24 @@
             json.dump(ping_range_result, results_file, indent=4)
 
         # Plot results
-        figure = wputils.BokehFigure(
-            self.current_test_name,
-            x_label='Timestamp (s)',
-            primary_y='Round Trip Time (ms)')
-        for idx, result in enumerate(ping_range_result['ping_results']):
-            if len(result['rtt']) > 1:
-                x_data = [
-                    t - result['time_stamp'][0] for t in result['time_stamp']
-                ]
-                figure.add_line(
-                    x_data, result['rtt'],
-                    'RTT @ {}dB'.format(ping_range_result['attenuation'][idx]))
+        if 'range' not in self.current_test_name:
+            figure = wputils.BokehFigure(
+                self.current_test_name,
+                x_label='Timestamp (s)',
+                primary_y_label='Round Trip Time (ms)')
+            for idx, result in enumerate(ping_range_result['ping_results']):
+                if len(result['rtt']) > 1:
+                    x_data = [
+                        t - result['time_stamp'][0]
+                        for t in result['time_stamp']
+                    ]
+                    figure.add_line(
+                        x_data, result['rtt'], 'RTT @ {}dB'.format(
+                            ping_range_result['attenuation'][idx]))
 
-        output_file_path = os.path.join(
-            self.log_path, '{}.html'.format(self.current_test_name))
-        figure.generate_figure(output_file_path)
+            output_file_path = os.path.join(
+                self.log_path, '{}.html'.format(self.current_test_name))
+            figure.generate_figure(output_file_path)
 
     def get_range_from_rvr(self):
         """Function gets range from RvR golden results
@@ -302,6 +319,7 @@
             test_result: dict containing ping results and other meta data
         """
         # Prepare results dict
+        llstats_obj = wputils.LinkLayerStats(self.dut)
         test_result = collections.OrderedDict()
         test_result['testcase_params'] = testcase_params.copy()
         test_result['test_name'] = self.current_test_name
@@ -311,6 +329,7 @@
             'fixed_attenuation'][str(testcase_params['channel'])]
         test_result['rssi_results'] = []
         test_result['ping_results'] = []
+        test_result['llstats'] = []
         # Run ping and sweep attenuation as needed
         zero_counter = 0
         for atten in testcase_params['atten_range']:
@@ -321,12 +340,17 @@
                 int(testcase_params['ping_duration'] / 2 /
                     self.RSSI_POLL_INTERVAL), self.RSSI_POLL_INTERVAL,
                 testcase_params['ping_duration'] / 2)
+            # Refresh link layer stats
+            llstats_obj.update_stats()
             current_ping_stats = wputils.get_ping_stats(
                 self.ping_server, self.dut_ip,
                 testcase_params['ping_duration'],
                 testcase_params['ping_interval'], testcase_params['ping_size'])
             current_rssi = rssi_future.result()
             test_result['rssi_results'].append(current_rssi)
+            llstats_obj.update_stats()
+            curr_llstats = llstats_obj.llstats_incremental.copy()
+            test_result['llstats'].append(curr_llstats)
             if current_ping_stats['connected']:
                 self.log.info(
                     'Attenuation = {0}dB\tPacket Loss = {1}%\t'
@@ -395,9 +419,12 @@
         band = self.access_point.band_lookup_by_channel(
             testcase_params['channel'])
         current_network = self.dut.droid.wifiGetConnectionInfo()
-        valid_connection = wutils.validate_connection(self.dut)
-        if valid_connection and current_network['SSID'] == self.main_network[
-                band]['SSID']:
+        try:
+            connected = wutils.validate_connection(self.dut) is not None
+        except:
+            connected = False
+        if connected and current_network['SSID'] == self.main_network[band][
+                'SSID']:
             self.log.info('Already connected to desired network')
         else:
             wutils.reset_wifi(self.dut)
@@ -541,9 +568,9 @@
     def __init__(self, controllers):
         base_test.BaseTestClass.__init__(self, controllers)
         self.testcase_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_case())
+            BlackboxMappedMetricLogger.for_test_case())
         self.testclass_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_class())
+            BlackboxMappedMetricLogger.for_test_class())
         self.publish_testcase_metrics = False
 
     def setup_class(self):
@@ -567,10 +594,13 @@
                 range_vs_angle[curr_config]['position'].append(
                     curr_params['position'])
                 range_vs_angle[curr_config]['range'].append(test['range'])
+                range_vs_angle[curr_config]['llstats_at_range'].append(
+                    test['llstats_at_range'])
             else:
                 range_vs_angle[curr_config] = {
                     'position': [curr_params['position']],
-                    'range': [test['range']]
+                    'range': [test['range']],
+                    'llstats_at_range': [test['llstats_at_range']]
                 }
         chamber_mode = self.testclass_results[0]['testcase_params'][
             'chamber_mode']
@@ -581,11 +611,14 @@
         figure = wputils.BokehFigure(
             title='Range vs. Position',
             x_label=x_label,
-            primary_y='Range (dB)',
+            primary_y_label='Range (dB)',
         )
         for channel, channel_data in range_vs_angle.items():
-            figure.add_line(channel_data['position'], channel_data['range'],
-                            'Channel {}'.format(channel))
+            figure.add_line(
+                x_data=channel_data['position'],
+                y_data=channel_data['range'],
+                hover_text=channel_data['llstats_at_range'],
+                legend='Channel {}'.format(channel))
             average_range = sum(channel_data['range']) / len(
                 channel_data['range'])
             self.log.info('Average range for Channel {} is: {}dB'.format(
diff --git a/acts/tests/google/wifi/WifiRoamingPerformanceTest.py b/acts/tests/google/wifi/WifiRoamingPerformanceTest.py
index f05cc01..da57bf5 100644
--- a/acts/tests/google/wifi/WifiRoamingPerformanceTest.py
+++ b/acts/tests/google/wifi/WifiRoamingPerformanceTest.py
@@ -16,13 +16,13 @@
 
 import collections
 import json
-import logging
 import math
 import os
 import time
 from acts import asserts
 from acts import base_test
 from acts import context
+from acts import utils
 from acts.controllers import iperf_server as ipf
 from acts.controllers.utils_lib import ssh
 from acts.test_utils.wifi import wifi_performance_test_utils as wputils
@@ -89,6 +89,11 @@
         self.log.info("RF Map (by Atten): {}".format(self.rf_map_by_atten))
 
         #Turn WiFi ON
+        if self.testclass_params.get('airplane_mode', 1):
+            self.log.info('Turning on airplane mode.')
+            asserts.assert_true(
+                utils.force_airplane_mode(self.dut, True),
+                "Can not turn on airplane mode.")
         wutils.wifi_toggle_state(self.dut, True)
 
     def pass_fail_traffic_continuity(self, result):
@@ -206,8 +211,8 @@
             figure = wputils.BokehFigure(
                 title=self.current_test_name,
                 x_label='Time (ms)',
-                primary_y=primary_y_axis,
-                secondary_y='RSSI (dBm)')
+                primary_y_label=primary_y_axis,
+                secondary_y_label='RSSI (dBm)')
             roam_stats[secondary_atten] = collections.OrderedDict()
             for result in results_list:
                 self.detect_roam_events(result)
@@ -361,8 +366,8 @@
             figure = wputils.BokehFigure(
                 title=self.current_test_name,
                 x_label='Time (ms)',
-                primary_y='RTT (ms)',
-                secondary_y='RSSI (dBm)')
+                primary_y_label='RTT (ms)',
+                secondary_y_label='RSSI (dBm)')
         figure.add_line(
             x_data=result['ping_result']['time_stamp'],
             y_data=result['ping_result']['rtt'],
@@ -395,8 +400,8 @@
             figure = wputils.BokehFigure(
                 title=self.current_test_name,
                 x_label='Time (s)',
-                primary_y='Throughput (Mbps)',
-                secondary_y='RSSI (dBm)')
+                primary_y_label='Throughput (Mbps)',
+                secondary_y_label='RSSI (dBm)')
         iperf_time_stamps = [
             idx * IPERF_INTERVAL for idx in range(len(result['throughput']))
         ]
diff --git a/acts/tests/google/wifi/WifiRssiTest.py b/acts/tests/google/wifi/WifiRssiTest.py
index 7b1e68e..91bfa9f 100644
--- a/acts/tests/google/wifi/WifiRssiTest.py
+++ b/acts/tests/google/wifi/WifiRssiTest.py
@@ -28,6 +28,7 @@
 from acts import utils
 from acts.controllers.utils_lib import ssh
 from acts.controllers import iperf_server as ipf
+from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
 from acts.test_utils.wifi import ota_chamber
 from acts.test_utils.wifi import wifi_performance_test_utils as wputils
 from acts.test_utils.wifi import wifi_retail_ap as retail_ap
@@ -55,9 +56,9 @@
     def __init__(self, controllers):
         base_test.BaseTestClass.__init__(self, controllers)
         self.testcase_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_case())
+            BlackboxMappedMetricLogger.for_test_case())
         self.testclass_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_class())
+            BlackboxMappedMetricLogger.for_test_class())
         self.publish_test_metrics = True
 
     def setup_class(self):
@@ -92,6 +93,11 @@
         self.testclass_results = []
 
         # Turn WiFi ON
+        if self.testclass_params.get('airplane_mode', 1):
+            self.log.info('Turning on airplane mode.')
+            asserts.assert_true(
+                utils.force_airplane_mode(self.dut, True),
+                "Can not turn on airplane mode.")
         wutils.wifi_toggle_state(self.dut, True)
 
     def teardown_test(self):
@@ -301,7 +307,7 @@
         figure = wputils.BokehFigure(
             self.current_test_name,
             x_label='Attenuation (dB)',
-            primary_y='RSSI (dBm)')
+            primary_y_label='RSSI (dBm)')
         figure.add_line(
             postprocessed_results['total_attenuation'],
             postprocessed_results['signal_poll_rssi']['mean'],
@@ -345,7 +351,7 @@
         figure = wputils.BokehFigure(
             self.current_test_name,
             x_label='Time (s)',
-            primary_y=center_curves * 'Centered' + 'RSSI (dBm)',
+            primary_y_label=center_curves * 'Centered' + 'RSSI (dBm)',
         )
 
         # yapf: disable
@@ -421,8 +427,8 @@
         figure = wputils.BokehFigure(
             self.current_test_name,
             x_label='RSSI (dBm)',
-            primary_y='p(RSSI = x)',
-            secondary_y='p(RSSI <= x)')
+            primary_y_label='p(RSSI = x)',
+            secondary_y_label='p(RSSI <= x)')
         for rssi_key, rssi_data in rssi_dist.items():
             figure.add_line(
                 x_data=rssi_data['rssi_values'],
@@ -876,9 +882,9 @@
     def __init__(self, controllers):
         base_test.BaseTestClass.__init__(self, controllers)
         self.testcase_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_case())
+            BlackboxMappedMetricLogger.for_test_case())
         self.testclass_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_class())
+            BlackboxMappedMetricLogger.for_test_class())
         self.publish_test_metrics = False
 
     def setup_class(self):
@@ -947,7 +953,7 @@
             current_plot = wputils.BokehFigure(
                 title='Channel {} - Rssi vs. Position'.format(channel),
                 x_label=x_label,
-                primary_y='RSSI (dBm)',
+                primary_y_label='RSSI (dBm)',
             )
             for rssi_metric, rssi_metric_value in channel_data['rssi'].items():
                 legend = rssi_metric
diff --git a/acts/tests/google/wifi/WifiRvrTest.py b/acts/tests/google/wifi/WifiRvrTest.py
index 7d72c16..43c9bbb 100644
--- a/acts/tests/google/wifi/WifiRvrTest.py
+++ b/acts/tests/google/wifi/WifiRvrTest.py
@@ -25,6 +25,7 @@
 from acts import utils
 from acts.controllers import iperf_server as ipf
 from acts.controllers.utils_lib import ssh
+from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
 from acts.test_utils.wifi import ota_chamber
 from acts.test_utils.wifi import wifi_performance_test_utils as wputils
 from acts.test_utils.wifi import wifi_retail_ap as retail_ap
@@ -50,9 +51,9 @@
     def __init__(self, controllers):
         base_test.BaseTestClass.__init__(self, controllers)
         self.testcase_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_case())
+            BlackboxMappedMetricLogger.for_test_case())
         self.testclass_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_class())
+            BlackboxMappedMetricLogger.for_test_class())
         self.publish_testcase_metrics = True
 
     def setup_class(self):
@@ -99,6 +100,11 @@
         self.testclass_results = []
 
         # Turn WiFi ON
+        if self.testclass_params.get('airplane_mode', 1):
+            self.log.info('Turning on airplane mode.')
+            asserts.assert_true(
+                utils.force_airplane_mode(self.dut, True),
+                "Can not turn on airplane mode.")
         wutils.wifi_toggle_state(self.dut, True)
 
     def teardown_test(self):
@@ -124,7 +130,7 @@
                         result['testcase_params']['mode'],
                         result['testcase_params']['traffic_type']),
                     x_label='Attenuation (dB)',
-                    primary_y='Throughput (Mbps)')
+                    primary_y_label='Throughput (Mbps)')
             plots[plot_id].add_line(
                 result['total_attenuation'],
                 result['throughput_receive'],
@@ -251,7 +257,7 @@
         figure = wputils.BokehFigure(
             title=test_name,
             x_label='Attenuation (dB)',
-            primary_y='Throughput (Mbps)')
+            primary_y_label='Throughput (Mbps)')
         try:
             golden_path = next(file_name
                                for file_name in self.golden_files_list
@@ -314,11 +320,13 @@
         ]
         for idx in range(len(tput_below_limit)):
             if all(tput_below_limit[idx:]):
-                rvr_result['metrics']['high_tput_range'] = rvr_result[
-                    'total_attenuation'][max(idx, 1) - 1]
+                if idx == 0:
+                    #Throughput was never above limit
+                    rvr_result['metrics']['high_tput_range'] = -1
+                else:
+                    rvr_result['metrics']['high_tput_range'] = rvr_result[
+                        'total_attenuation'][max(idx, 1) - 1]
                 break
-        else:
-            rvr_result['metrics']['high_tput_range'] = -1
         if self.publish_testcase_metrics:
             self.testcase_metric_logger.add_metric(
                 'high_tput_range', rvr_result['metrics']['high_tput_range'])
@@ -468,15 +476,18 @@
         # Check battery level before test
         if not wputils.health_check(
                 self.dut, 20) and testcase_params['traffic_direction'] == 'UL':
-            asserts.skip('Battery level too low. Skipping test.')
+            asserts.skip('Overheating or Battery level low. Skipping test.')
         # Turn screen off to preserve battery
         self.dut.go_to_sleep()
         band = self.access_point.band_lookup_by_channel(
             testcase_params['channel'])
         current_network = self.dut.droid.wifiGetConnectionInfo()
-        valid_connection = wutils.validate_connection(self.dut)
-        if valid_connection and current_network['SSID'] == self.main_network[
-                band]['SSID']:
+        try:
+            connected = wutils.validate_connection(self.dut) is not None
+        except:
+            connected = False
+        if connected and current_network['SSID'] == self.main_network[band][
+                'SSID']:
             self.log.info('Already connected to desired network')
         else:
             wutils.reset_wifi(self.dut)
@@ -682,9 +693,9 @@
     def __init__(self, controllers):
         base_test.BaseTestClass.__init__(self, controllers)
         self.testcase_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_case())
+            BlackboxMappedMetricLogger.for_test_case())
         self.testclass_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_class())
+            BlackboxMappedMetricLogger.for_test_class())
         self.publish_testcase_metrics = False
 
     def setup_class(self):
@@ -726,7 +737,7 @@
                         result['testcase_params']['traffic_type'],
                         result['testcase_params']['traffic_direction']),
                     x_label='Attenuation (dB)',
-                    primary_y='Throughput (Mbps)')
+                    primary_y_label='Throughput (Mbps)')
             # Compile test id data and metrics
             compiled_data[test_id]['throughput'].append(
                 result['throughput_receive'])
diff --git a/acts/tests/google/wifi/WifiSensitivityTest.py b/acts/tests/google/wifi/WifiSensitivityTest.py
index b262679..1947684 100644
--- a/acts/tests/google/wifi/WifiSensitivityTest.py
+++ b/acts/tests/google/wifi/WifiSensitivityTest.py
@@ -27,6 +27,7 @@
 from acts import utils
 from acts.controllers import iperf_client
 from acts.controllers.utils_lib import ssh
+from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
 from acts.test_utils.wifi import ota_chamber
 from acts.test_utils.wifi import wifi_performance_test_utils as wputils
 from acts.test_utils.wifi import wifi_test_utils as wutils
@@ -126,9 +127,9 @@
     def __init__(self, controllers):
         base_test.BaseTestClass.__init__(self, controllers)
         self.testcase_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_case())
+            BlackboxMappedMetricLogger.for_test_case())
         self.testclass_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_class())
+            BlackboxMappedMetricLogger.for_test_class())
         self.publish_testcase_metrics = True
 
     def setup_class(self):
@@ -175,6 +176,11 @@
         self.testclass_results = []
 
         # Turn WiFi ON
+        if self.testclass_params.get('airplane_mode', 1):
+            self.log.info('Turning on airplane mode.')
+            asserts.assert_true(
+                utils.force_airplane_mode(self.dut, True),
+                "Can not turn on airplane mode.")
         wutils.wifi_toggle_state(self.dut, True)
 
     def teardown_class(self):
@@ -378,9 +384,12 @@
         band = self.access_point.band_lookup_by_channel(
             testcase_params['channel'])
         current_network = self.dut.droid.wifiGetConnectionInfo()
-        valid_connection = wutils.validate_connection(self.dut)
-        if valid_connection and current_network['SSID'] == self.main_network[
-                band]['SSID']:
+        try:
+            connected = wutils.validate_connection(self.dut) is not None
+        except:
+            connected = False
+        if connected and current_network['SSID'] == self.main_network[band][
+                'SSID']:
             self.log.info('Already connected to desired network')
         else:
             wutils.reset_wifi(self.dut)
@@ -615,9 +624,9 @@
     def __init__(self, controllers):
         base_test.BaseTestClass.__init__(self, controllers)
         self.testcase_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_case())
+            BlackboxMappedMetricLogger.for_test_case())
         self.testclass_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_class())
+            BlackboxMappedMetricLogger.for_test_class())
         self.publish_testcase_metrics = False
 
     def setup_class(self):
@@ -680,7 +689,7 @@
             curr_plot = wputils.BokehFigure(
                 title=str(test_id_str),
                 x_label='Orientation (deg)',
-                primary_y='Sensitivity (dBm)')
+                primary_y_label='Sensitivity (dBm)')
             for channel, channel_results in test_data.items():
                 curr_plot.add_line(
                     channel_results['orientation'],
diff --git a/acts/tests/google/wifi/WifiSoftApPerformanceTest.py b/acts/tests/google/wifi/WifiSoftApPerformanceTest.py
index f764b9f..a31812f 100644
--- a/acts/tests/google/wifi/WifiSoftApPerformanceTest.py
+++ b/acts/tests/google/wifi/WifiSoftApPerformanceTest.py
@@ -21,7 +21,7 @@
 from acts import utils
 from acts.controllers import iperf_server as ipf
 from acts.controllers import iperf_client as ipc
-from acts.metrics.loggers.blackbox import BlackboxMetricLogger
+from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
 from acts.test_utils.wifi import wifi_test_utils as wutils
 from acts.test_utils.wifi import wifi_performance_test_utils as wputils
 from WifiRvrTest import WifiRvrTest
@@ -36,9 +36,9 @@
         self.tests = ("test_rvr_TCP_DL_2GHz", "test_rvr_TCP_UL_2GHz",
                       "test_rvr_TCP_DL_5GHz", "test_rvr_TCP_UL_5GHz")
         self.testcase_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_case())
+            BlackboxMappedMetricLogger.for_test_case())
         self.testclass_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_class())
+            BlackboxMappedMetricLogger.for_test_class())
         self.publish_testcase_metrics = True
 
     def setup_class(self):
diff --git a/acts/tests/google/wifi/WifiStressTest.py b/acts/tests/google/wifi/WifiStressTest.py
index 7ca8034..40a3108 100644
--- a/acts/tests/google/wifi/WifiStressTest.py
+++ b/acts/tests/google/wifi/WifiStressTest.py
@@ -61,7 +61,8 @@
         req_params = []
         opt_param = [
             "open_network", "reference_networks", "iperf_server_address",
-            "stress_count", "stress_hours", "attn_vals", "pno_interval"]
+            "stress_count", "stress_hours", "attn_vals", "pno_interval",
+            "iperf_server_port"]
         self.unpack_userparams(
             req_param_names=req_params, opt_param_names=opt_param)
 
@@ -76,12 +77,6 @@
         self.open_2g = self.open_network[0]["2g"]
         self.open_5g = self.open_network[0]["5g"]
         self.networks = [self.wpa_2g, self.wpa_5g, self.open_2g, self.open_5g]
-        if "iperf_server_address" in self.user_params:
-            self.iperf_server = self.iperf_servers[0]
-        if hasattr(self, 'iperf_server'):
-            self.iperf_server.start()
-            if(len(self.iperf_servers) > 1):
-                self.iperf_servers[1].start()
 
     def setup_test(self):
         self.dut.droid.wakeLockAcquireBright()
@@ -100,10 +95,6 @@
 
     def teardown_class(self):
         wutils.reset_wifi(self.dut)
-        if hasattr(self, 'iperf_server'):
-            self.iperf_server.stop()
-            if(len(self.iperf_servers) > 1):
-                self.iperf_servers[1].stop()
         if "AccessPoint" in self.user_params:
             del self.user_params["reference_networks"]
             del self.user_params["open_network"]
@@ -295,7 +286,7 @@
                 self.scan_and_connect_by_id(self.wpa_5g, net_id)
                 # Start IPerf traffic from phone to server.
                 # Upload data for 10s.
-                args = "-p {} -t {}".format(self.iperf_server.port, 10)
+                args = "-p {} -t {}".format(self.iperf_server_port, 10)
                 self.log.info("Running iperf client {}".format(args))
                 result, data = self.dut.run_iperf_client(self.iperf_server_address, args)
                 if not result:
@@ -328,7 +319,7 @@
         sec = self.stress_hours * 60 * 60
         start_time = time.time()
 
-        dl_args = "-p {} -t {} -R".format(self.iperf_server.port, sec)
+        dl_args = "-p {} -t {} -R".format(self.iperf_server_port, sec)
         dl = threading.Thread(target=self.run_long_traffic, args=(sec, dl_args, q))
         dl.start()
         if(len(self.iperf_servers) > 1):
diff --git a/acts/tests/google/wifi/WifiTethering2GOpenOTATest.py b/acts/tests/google/wifi/WifiTethering2GOpenOTATest.py
index a603e01..0716158 100755
--- a/acts/tests/google/wifi/WifiTethering2GOpenOTATest.py
+++ b/acts/tests/google/wifi/WifiTethering2GOpenOTATest.py
@@ -52,7 +52,7 @@
         try:
           ota_updater.update(self.hotspot_device)
         except Exception as err:
-            raise signals.TestSkipClass(
+            raise signals.TestAbortClass(
                 "Failed up apply OTA update. Aborting tests")
 
     def on_fail(self, test_name, begin_time):
diff --git a/acts/tests/google/wifi/WifiTethering2GPskOTATest.py b/acts/tests/google/wifi/WifiTethering2GPskOTATest.py
index e9fedcd..7399e32 100755
--- a/acts/tests/google/wifi/WifiTethering2GPskOTATest.py
+++ b/acts/tests/google/wifi/WifiTethering2GPskOTATest.py
@@ -52,7 +52,7 @@
         try:
           ota_updater.update(self.hotspot_device)
         except Exception as err:
-            raise signals.TestSkipClass(
+            raise signals.TestAbortClass(
                 "Failed up apply OTA update. Aborting tests")
 
     def on_fail(self, test_name, begin_time):
diff --git a/acts/tests/google/wifi/WifiTethering5GOpenOTATest.py b/acts/tests/google/wifi/WifiTethering5GOpenOTATest.py
index 6648d0e..985e7a7 100755
--- a/acts/tests/google/wifi/WifiTethering5GOpenOTATest.py
+++ b/acts/tests/google/wifi/WifiTethering5GOpenOTATest.py
@@ -52,7 +52,7 @@
         try:
           ota_updater.update(self.hotspot_device)
         except Exception as err:
-            raise signals.TestSkipClass(
+            raise signals.TestAbortClass(
                 "Failed up apply OTA update. Aborting tests")
 
     def on_fail(self, test_name, begin_time):
diff --git a/acts/tests/google/wifi/WifiTethering5GPskOTATest.py b/acts/tests/google/wifi/WifiTethering5GPskOTATest.py
index 7450578..9e68f22 100755
--- a/acts/tests/google/wifi/WifiTethering5GPskOTATest.py
+++ b/acts/tests/google/wifi/WifiTethering5GPskOTATest.py
@@ -52,7 +52,7 @@
         try:
           ota_updater.update(self.hotspot_device)
         except Exception as err:
-            raise signals.TestSkipClass(
+            raise signals.TestAbortClass(
                 "Failed up apply OTA update. Aborting tests")
 
     def on_fail(self, test_name, begin_time):
diff --git a/acts/tests/google/wifi/WifiThroughputStabilityTest.py b/acts/tests/google/wifi/WifiThroughputStabilityTest.py
index fd51961..f3e942f 100644
--- a/acts/tests/google/wifi/WifiThroughputStabilityTest.py
+++ b/acts/tests/google/wifi/WifiThroughputStabilityTest.py
@@ -27,6 +27,7 @@
 from acts import utils
 from acts.controllers import iperf_server as ipf
 from acts.controllers.utils_lib import ssh
+from acts.metrics.loggers.blackbox import BlackboxMappedMetricLogger
 from acts.test_utils.wifi import ota_chamber
 from acts.test_utils.wifi import wifi_performance_test_utils as wputils
 from acts.test_utils.wifi import wifi_retail_ap as retail_ap
@@ -52,9 +53,9 @@
         base_test.BaseTestClass.__init__(self, controllers)
         # Define metrics to be uploaded to BlackBox
         self.testcase_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_case())
+            BlackboxMappedMetricLogger.for_test_case())
         self.testclass_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_class())
+            BlackboxMappedMetricLogger.for_test_class())
         self.publish_testcase_metrics = True
         # Generate test cases
         self.tests = self.generate_test_cases(
@@ -132,6 +133,11 @@
         self.testclass_results = []
 
         # Turn WiFi ON
+        if self.testclass_params.get('airplane_mode', 1):
+            self.log.info('Turning on airplane mode.')
+            asserts.assert_true(
+                utils.force_airplane_mode(self.dut, True),
+                "Can not turn on airplane mode.")
         wutils.wifi_toggle_state(self.dut, True)
 
     def teardown_test(self):
@@ -221,7 +227,7 @@
             json.dump(test_result_dict, results_file)
         # Plot and save
         figure = wputils.BokehFigure(
-            test_name, x_label='Time (s)', primary_y='Throughput (Mbps)')
+            test_name, x_label='Time (s)', primary_y_label='Throughput (Mbps)')
         time_data = list(range(0, len(instantaneous_rates_Mbps)))
         figure.add_line(
             time_data,
@@ -270,9 +276,12 @@
         band = self.access_point.band_lookup_by_channel(
             testcase_params['channel'])
         current_network = self.dut.droid.wifiGetConnectionInfo()
-        valid_connection = wutils.validate_connection(self.dut)
-        if valid_connection and current_network['SSID'] == self.main_network[
-                band]['SSID']:
+        try:
+            connected = wutils.validate_connection(self.dut) is not None
+        except:
+            connected = False
+        if connected and current_network['SSID'] == self.main_network[band][
+                'SSID']:
             self.log.info('Already connected to desired network')
         else:
             wutils.wifi_toggle_state(self.dut, True)
@@ -448,9 +457,9 @@
         base_test.BaseTestClass.__init__(self, controllers)
         # Define metrics to be uploaded to BlackBox
         self.testcase_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_case())
+            BlackboxMappedMetricLogger.for_test_case())
         self.testclass_metric_logger = (
-            wputils.BlackboxMappedMetricLogger.for_test_class())
+            BlackboxMappedMetricLogger.for_test_class())
         self.publish_testcase_metrics = False
 
     def setup_class(self):
@@ -517,7 +526,7 @@
             current_plot = wputils.BokehFigure(
                 title='Channel {} - Rate vs. Position'.format(channel),
                 x_label=x_label,
-                primary_y='Rate (Mbps)',
+                primary_y_label='Rate (Mbps)',
             )
             for test_id, test_data in channel_data.items():
                 test_id_dict = dict(test_id)
diff --git a/acts/tests/meta/ActsUnitTest.py b/acts/tests/meta/ActsUnitTest.py
new file mode 100755
index 0000000..f383ade
--- /dev/null
+++ b/acts/tests/meta/ActsUnitTest.py
@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+#
+#   Copyright 2019 - 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 logging
+import os
+import subprocess
+import sys
+
+import acts
+from acts import base_test
+from acts import signals
+
+# The files under acts/framework to consider as unit tests.
+UNITTEST_FILES = [
+    'tests/acts_adb_test.py',
+    'tests/acts_android_device_test.py',
+    'tests/acts_asserts_test.py',
+    'tests/acts_base_class_test.py',
+    'tests/config/unittest_bundle.py',
+    'tests/acts_context_test.py',
+    'tests/acts_error_test.py',
+    'tests/acts_host_utils_test.py',
+    'tests/acts_import_test_utils_test.py',
+    'tests/acts_import_unit_test.py',
+    'tests/acts_job_test.py',
+    'tests/libs/ota/unittest_bundle.py',
+    'tests/acts_logger_test.py',
+    'tests/libs/metrics/unittest_bundle.py',
+    'tests/acts_records_test.py',
+    'tests/acts_relay_controller_test.py',
+    'tests/acts_test_runner_test.py',
+    'tests/acts_unittest_suite.py',
+    'tests/acts_utils_test.py',
+    'tests/controllers/android_lib/android_lib_unittest_bundle.py',
+    'tests/event/event_unittest_bundle.py',
+    'tests/test_utils/instrumentation/unit_test_suite.py',
+    'tests/libs/logging/logging_unittest_bundle.py',
+    'tests/metrics/unittest_bundle.py',
+    'tests/libs/proc/proc_unittest_bundle.py',
+    'tests/controllers/sl4a_lib/test_suite.py',
+    'tests/test_runner_test.py',
+    'tests/libs/version_selector_test.py',
+]
+
+# The number of seconds to wait before considering the unit test to have timed
+# out.
+UNITTEST_TIMEOUT = 60
+
+
+class ActsUnitTest(base_test.BaseTestClass):
+    """A class to run the ACTS unit tests in parallel.
+
+    This is a hack to run the ACTS unit tests through CI. Please use the main
+    function below if you need to run these tests.
+    """
+
+    def test_units(self):
+        """Runs all the ACTS unit tests in parallel."""
+        acts_unittest_path = os.path.dirname(acts.__path__[0])
+        test_processes = []
+
+        fail_test = False
+
+        for unittest_file in UNITTEST_FILES:
+            file_path = os.path.join(acts_unittest_path, unittest_file)
+            test_processes.append(
+                subprocess.Popen(
+                    [sys.executable, file_path],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT))
+
+        for test_process in test_processes:
+            killed = False
+            try:
+                stdout, _ = test_process.communicate(timeout=UNITTEST_TIMEOUT)
+            except subprocess.TimeoutExpired:
+                killed = True
+                self.log.error('Unit test %s timed out after %s seconds.' %
+                               (test_process.args, UNITTEST_TIMEOUT))
+                test_process.kill()
+                stdout, _ = test_process.communicate()
+            if test_process.returncode != 0 or killed:
+                self.log.error('=' * 79)
+                self.log.error('Unit Test %s failed with error %s.' %
+                               (test_process.args, test_process.returncode))
+                self.log.error('=' * 79)
+                self.log.error('Failure for `%s`:\n%s' %
+                               (test_process.args,
+                                stdout.decode('utf-8', errors='replace')))
+                fail_test = True
+            else:
+                self.log.debug('Output for `%s`:\n%s' %
+                               (test_process.args,
+                                stdout.decode('utf-8', errors='replace')))
+
+        if fail_test:
+            raise signals.TestFailure(
+                'One or more unit tests failed. See the logs.')
+
+
+def main():
+    ActsUnitTest({'log': logging.getLogger()}).test_units()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/acts/tests/meta/__init__.py b/acts/tests/meta/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/acts/tests/meta/__init__.py
diff --git a/tools/create_virtualenv.sh b/tools/create_virtualenv.sh
new file mode 100755
index 0000000..3746ba2
--- /dev/null
+++ b/tools/create_virtualenv.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+
+python3 -m pip install virtualenv
+
+if [ $? -ne 0 ]; then
+  echo "Virtualenv must be installed to run the upload tests. Run: " >&2
+  echo "    sudo python3 -m pip install virtualenv" >&2
+  exit 1
+fi
+
+virtualenv='/tmp/acts_preupload_virtualenv'
+
+python3 -m virtualenv -p python3 $virtualenv
+cp -r acts/framework $virtualenv/
+cd $virtualenv/framework
+$virtualenv/bin/python3 setup.py develop
+cd -