Support policy layer and drivers for Fuchsia WLAN

This changes adds support to all Fuchsia WLAN tests
to use the policy layer by default. It also maintains
the ability to use the drivers by specifying the
association_mechanism in the FuchsiaDevice block
of the ACTS config.

This change also moves utility functions into the objects that they
impact, to reduce the number of code flows. Fuchsia WLAN policy
functions were added to a seperate object, that is then made an attribute
of FuchsiaDevice.

A new configure_wlan flow was added to ensure that the new, complex
wlan configurations required for the policy layer are only invoked
when specifically called, and that they do not interfere with non-wlan
tests.

Bug: None
Test: Ran all affected tests with both policy layer and drivers (where applicable)
Change-Id: I2befd59b5137ee368fe1586009696345044912f4
diff --git a/acts_tests/acts_contrib/test_utils/abstract_devices/utils_lib/wlan_policy_utils.py b/acts_tests/acts_contrib/test_utils/abstract_devices/utils_lib/wlan_policy_utils.py
deleted file mode 100644
index ef89d95..0000000
--- a/acts_tests/acts_contrib/test_utils/abstract_devices/utils_lib/wlan_policy_utils.py
+++ /dev/null
@@ -1,143 +0,0 @@
-#!/usr/bin/env python3
-#
-#   Copyright 2020 - 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.
-
-SAVED_NETWORKS = "saved_networks"
-CLIENT_STATE = "client_connections_state"
-CONNECTIONS_ENABLED = "ConnectionsEnabled"
-CONNECTIONS_DISABLED = "ConnectionsDisabled"
-
-
-def setup_policy_tests(fuchsia_devices):
-    """ Preserves networks already saved on devices before removing them to
-        setup up for a clean test environment. Records the state of client
-        connections before tests. Initializes the client controller
-        and enables connections.
-    Args:
-        fuchsia_devices: the devices under test
-    Returns:
-        A dict of the data to restore after tests indexed by device. The data
-        for each device is a dict of the saved data, ie saved networks and
-        state of client connections.
-    """
-    preserved_data_by_device = {}
-    for fd in fuchsia_devices:
-        data = {}
-        # Collect and delete networks saved on the device.
-        fd.wlan_policy_lib.wlanCreateClientController()
-        result_get = fd.wlan_policy_lib.wlanGetSavedNetworks()
-        if result_get.get("result") != None:
-            data[SAVED_NETWORKS] = result_get['result']
-        fd.wlan_policy_lib.wlanRemoveAllNetworks()
-
-        # Get the currect client connection state (connections enabled or disabled)
-        # and enable connections by default.
-        fd.wlan_policy_lib.wlanSetNewListener()
-        result_update = fd.wlan_policy_lib.wlanGetUpdate()
-        if result_update.get("result") != None and result_update.get(
-                "result").get("state") != None:
-            data[CLIENT_STATE] = result_update.get("result").get("state")
-        else:
-            fd.log.warn("Failed to get update; test will not start or "
-                        "stop client connections at the end of the test.")
-        fd.wlan_policy_lib.wlanStartClientConnections()
-
-        preserved_data_by_device[fd] = data
-    return preserved_data_by_device
-
-
-def restore_state(fuchsia_devices, preserved_data):
-    """ Restore the state of the test device to what it was before tests began.
-        Remove any remaining saved networks, and restore the saved networks and
-        client connections state recorded by setup_policy_tests
-    Args:
-        fuchsia_devices: The fuchsia devices under test
-        preserved data: Dict of data indexed by fuchsia device, as returned
-                        by setup_policy_tests
-    """
-    for fd in fuchsia_devices:
-        data = preserved_data[fd]
-        fd.wlan_policy_lib.wlanRemoveAllNetworks()
-        for network in data[SAVED_NETWORKS]:
-            save_network(fd, network["ssid"], network["security_type"],
-                         network["credential_value"])
-        for starting_state in data[CLIENT_STATE]:
-            if starting_state == CONNECTIONS_ENABLED:
-                fd.wlan_policy_lib.wlanStartClientConnections()
-            elif starting_state == CONNECTIONS_DISABLED:
-                fd.wlan_policy_lib.wlanStopClientConnections()
-
-
-def save_network(fd, ssid, security_type, password=""):
-    """ Saves a network as specified on the given device and verify that the operation succeeded.
-        Returns true if there was no error, and false otherwise
-    Args:
-        fd: The Fuchsia device to save the network on
-        ssid: The SSID or name of the network to save.
-        security_type: The security type to save the network as, ie "none",
-                    "wep", "wpa", "wpa2", or "wpa3"
-        password: The password to save for the network. Empty string represents
-                no password, and PSK should be provided as 64 character hex string.
-    """
-    result_save = fd.wlan_policy_lib.wlanSaveNetwork(ssid, security_type,
-                                                     password)
-    if result_save.get("error") != None:
-        fd.log.info("Failed to save network %s with error: %s" %
-                    (ssid, result_save["error"]))
-        return False
-    else:
-        return True
-
-
-def start_connections(fd):
-    """ Starts client connections on the specified device and verifies that it
-        succeeds, and raises a test failure if not.
-    Returns:
-        True if there are no errors, False if there are errors.
-    """
-    resultStart = fd.wlan_policy_lib.wlanStartClientConnections()
-    if resultStart.get("error") != None:
-        fd.log.error(
-            "Error occurred when starting client connections in test setup: %s"
-            % resultStart.get("error"))
-        return False
-    else:
-        return True
-
-
-def stop_connections(fd):
-    """ Stops client connections on the device and verify that there are no
-        errors are returned, and raises a test failure if there are.
-    Returns:
-        True if there are noe errors, False otherwise.
-    """
-    result_stop = fd.wlan_policy_lib.wlanStopClientConnections()
-    if result_stop.get("error") != None:
-        fd.log.error("Error occurred stopping client connections: %s" %
-                     result_stop.get("error"))
-        return False
-    else:
-        return True
-
-
-def reboot_device(fd):
-    """ Reboot the device and reinitialize the device after.
-    Args:
-        fd: The device to reboot.
-    """
-    fd.reboot()
-    fd.wlan_policy_lib.wlanCreateClientController()
-    fd.wlan_policy_lib.wlanStartClientConnections()
-    fd.wlan_policy_lib.wlanSetNewListener()
diff --git a/acts_tests/acts_contrib/test_utils/abstract_devices/utils_lib/wlan_utils.py b/acts_tests/acts_contrib/test_utils/abstract_devices/utils_lib/wlan_utils.py
deleted file mode 100644
index 9c403be..0000000
--- a/acts_tests/acts_contrib/test_utils/abstract_devices/utils_lib/wlan_utils.py
+++ /dev/null
@@ -1,225 +0,0 @@
-#!/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
-
-from acts import asserts
-from acts.controllers.ap_lib import hostapd_ap_preset
-
-
-def validate_setup_ap_and_associate(*args, **kwargs):
-    """Validates if setup_ap_and_associate was a success or not
-
-       Args: Args match setup_ap_and_associate
-    """
-    asserts.assert_true(setup_ap_and_associate(*args, **kwargs),
-                        'Failed to associate.')
-    asserts.explicit_pass('Successfully associated.')
-
-
-def setup_ap_and_associate(access_point,
-                           client,
-                           profile_name,
-                           channel,
-                           ssid,
-                           mode=None,
-                           preamble=None,
-                           beacon_interval=None,
-                           dtim_period=None,
-                           frag_threshold=None,
-                           rts_threshold=None,
-                           force_wmm=None,
-                           hidden=False,
-                           security=None,
-                           pmf_support=None,
-                           additional_ap_parameters=None,
-                           password=None,
-                           check_connectivity=False,
-                           n_capabilities=None,
-                           ac_capabilities=None,
-                           vht_bandwidth=None,
-                           setup_bridge=False,
-                           target_security=None,
-                           association_mechanism=None):
-    """Sets up the AP and associates a client.
-
-    Args:
-        access_point: An ACTS access_point controller
-        client: A WlanDevice.
-        profile_name: The profile name of one of the hostapd ap presets.
-        channel: What channel to set the AP to.
-        preamble: Whether to set short or long preamble (True or False)
-        beacon_interval: The beacon interval (int)
-        dtim_period: Length of dtim period (int)
-        frag_threshold: Fragmentation threshold (int)
-        rts_threshold: RTS threshold (int)
-        force_wmm: Enable WMM or not (True or False)
-        hidden: Advertise the SSID or not (True or False)
-        security: What security to enable.
-        pmf_support: int, whether pmf is not disabled, enabled, or required
-        additional_ap_parameters: Additional parameters to send the AP.
-        password: Password to connect to WLAN if necessary.
-        check_connectivity: Whether to check for internet connectivity.
-        target_security: The security to try to associate to if using policy
-                         to associate.
-        association_mechanism: The way we will connect, through the core or
-                               policy layer of WLAN on the device.
-    """
-    setup_ap(access_point, profile_name, channel, ssid, mode, preamble,
-             beacon_interval, dtim_period, frag_threshold, rts_threshold,
-             force_wmm, hidden, security, pmf_support,
-             additional_ap_parameters, password, check_connectivity,
-             n_capabilities, ac_capabilities, vht_bandwidth, setup_bridge)
-
-    if not security:
-        target_security = "none"
-
-    if security and security.wpa3:
-        return associate(client,
-                         ssid,
-                         password,
-                         target_security=target_security,
-                         key_mgmt='SAE',
-                         check_connectivity=check_connectivity,
-                         hidden=hidden,
-                         association_mechanism=association_mechanism)
-    else:
-        return associate(client,
-                         ssid,
-                         password=password,
-                         target_security=target_security,
-                         check_connectivity=check_connectivity,
-                         hidden=hidden,
-                         association_mechanism=association_mechanism)
-
-
-def setup_ap(access_point,
-             profile_name,
-             channel,
-             ssid,
-             mode=None,
-             preamble=None,
-             beacon_interval=None,
-             dtim_period=None,
-             frag_threshold=None,
-             rts_threshold=None,
-             force_wmm=None,
-             hidden=False,
-             security=None,
-             pmf_support=None,
-             additional_ap_parameters=None,
-             password=None,
-             check_connectivity=False,
-             n_capabilities=None,
-             ac_capabilities=None,
-             vht_bandwidth=None,
-             setup_bridge=False):
-    """Sets up the AP.
-
-    Args:
-        access_point: An ACTS access_point controller
-        profile_name: The profile name of one of the hostapd ap presets.
-        channel: What channel to set the AP to.
-        preamble: Whether to set short or long preamble (True or False)
-        beacon_interval: The beacon interval (int)
-        dtim_period: Length of dtim period (int)
-        frag_threshold: Fragmentation threshold (int)
-        rts_threshold: RTS threshold (int)
-        force_wmm: Enable WMM or not (True or False)
-        hidden: Advertise the SSID or not (True or False)
-        security: What security to enable.
-        pmf_support: int, whether pmf is not disabled, enabled, or required
-        password: Password to connect to WLAN if necessary.
-        additional_ap_parameters: Additional parameters to send the AP.
-        password: Password to connect to WLAN if necessary.
-        check_connectivity: Whether to check for internet connectivity.
-    """
-    ap = hostapd_ap_preset.create_ap_preset(profile_name=profile_name,
-                                            iface_wlan_2g=access_point.wlan_2g,
-                                            iface_wlan_5g=access_point.wlan_5g,
-                                            channel=channel,
-                                            ssid=ssid,
-                                            mode=mode,
-                                            short_preamble=preamble,
-                                            beacon_interval=beacon_interval,
-                                            dtim_period=dtim_period,
-                                            frag_threshold=frag_threshold,
-                                            rts_threshold=rts_threshold,
-                                            force_wmm=force_wmm,
-                                            hidden=hidden,
-                                            bss_settings=[],
-                                            security=security,
-                                            pmf_support=pmf_support,
-                                            n_capabilities=n_capabilities,
-                                            ac_capabilities=ac_capabilities,
-                                            vht_bandwidth=vht_bandwidth)
-    access_point.start_ap(hostapd_config=ap,
-                          setup_bridge=setup_bridge,
-                          additional_parameters=additional_ap_parameters)
-
-
-def associate(client,
-              ssid,
-              password=None,
-              key_mgmt=None,
-              check_connectivity=True,
-              hidden=False,
-              security=None,
-              association_mechanism=None,
-              target_security=None):
-    """Associates a client to a WLAN network.
-
-    Args:
-        client: A WlanDevice
-        ssid: SSID of the ap we are looking for.
-        password: The password for the WLAN, if applicable.
-        key_mgmt: The hostapd wpa_key_mgmt value.
-        check_connectivity: Whether to check internet connectivity.
-        hidden: If the WLAN is hidden or not.
-    """
-    return client.associate(ssid,
-                            password,
-                            key_mgmt=key_mgmt,
-                            check_connectivity=check_connectivity,
-                            hidden=hidden,
-                            association_mechanism=association_mechanism,
-                            target_security=target_security)
-
-
-def status(client):
-    """Requests the state of WLAN network.
-
-    Args:
-        None
-    """
-    status = ''
-    status_response = client.status()
-
-    if status_response.get('error') is None:
-        # No error, so get the result
-        status = status_response['result']
-
-    logging.debug('status: %s' % status)
-    return status
-
-
-def disconnect(client):
-    """Disconnect client from its WLAN network.
-
-    Args:
-        client: A WlanDevice
-    """
-    client.disconnect()
diff --git a/acts_tests/acts_contrib/test_utils/abstract_devices/wlan_device.py b/acts_tests/acts_contrib/test_utils/abstract_devices/wlan_device.py
index f1f1b72..094f125 100644
--- a/acts_tests/acts_contrib/test_utils/abstract_devices/wlan_device.py
+++ b/acts_tests/acts_contrib/test_utils/abstract_devices/wlan_device.py
@@ -18,7 +18,6 @@
 import logging
 
 import acts_contrib.test_utils.wifi.wifi_test_utils as awutils
-import acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils as fwutils
 from acts.utils import get_interface_ip_addresses
 from acts.utils import adb_shell_ping
 
@@ -100,7 +99,6 @@
                   target_pwd=None,
                   check_connectivity=True,
                   hidden=False,
-                  association_mechanism=None,
                   target_security=None):
         """Base generic WLAN interface.  Only called if not overriden by
         another supported device.
@@ -108,7 +106,7 @@
         raise NotImplementedError("{} must be defined.".format(
             inspect.currentframe().f_code.co_name))
 
-    def disconnect(self, association_mechanism=None):
+    def disconnect(self):
         """Base generic WLAN interface.  Only called if not overridden by
         another supported device.
         """
@@ -208,7 +206,6 @@
                   key_mgmt=None,
                   check_connectivity=True,
                   hidden=False,
-                  association_mechanism=None,
                   target_security=None):
         """Function to associate an Android WLAN device.
 
@@ -238,7 +235,7 @@
             self.device.log.info('Failed to associated (%s)' % e)
             return False
 
-    def disconnect(self, association_mechanism=None):
+    def disconnect(self):
         awutils.turn_location_off_and_scan_toggle_off(self.device)
 
     def get_wlan_interface_id_list(self):
@@ -296,6 +293,7 @@
     def __init__(self, fuchsia_device):
         super().__init__(fuchsia_device)
         self.identifier = fuchsia_device.ip
+        self.device.configure_wlan()
 
     def wifi_toggle_state(self, state):
         """Stub for Fuchsia implementation."""
@@ -323,7 +321,6 @@
                   key_mgmt=None,
                   check_connectivity=True,
                   hidden=False,
-                  association_mechanism=None,
                   target_security=None):
         """Function to associate a Fuchsia WLAN device.
 
@@ -333,42 +330,29 @@
             key_mgmt: the hostapd wpa_key_mgmt, if specified.
             check_connectivity: Whether to check for internet connectivity.
             hidden: Whether the network is hidden.
+            target_security: string, target security for network, used to
+                save the network in policy connects (see wlan_policy_lib)
         Returns:
             True if successfully connected to WLAN, False if not.
         """
-        if association_mechanism == 'policy':
-            return self.device.policy_save_and_connect(target_ssid,
-                                                       target_security,
-                                                       password=target_pwd)
-        elif not association_mechanism or association_mechanism == 'drivers':
+        if self.device.association_mechanism == 'drivers':
             connection_response = self.device.wlan_lib.wlanConnectToNetwork(
                 target_ssid, target_pwd=target_pwd)
             return self.device.check_connect_response(connection_response)
         else:
-            self.log.error(
-                "Association mechanism %s is not recognized. Acceptable values are 'drivers' and 'policy'"
-                % association_mechanism)
-            return False
+            return self.device.wlan_policy_controller.save_and_connect(
+                target_ssid, target_security, password=target_pwd)
 
-    def disconnect(self, association_mechanism=None):
+    def disconnect(self):
         """Function to disconnect from a Fuchsia WLAN device.
            Asserts if disconnect was not successful.
         """
-        if association_mechanism == 'policy':
-            asserts.assert_true(self.device.remove_all_and_disconnect(),
-                                'Failed to disconnect')
-        elif not association_mechanism or association_mechanism == 'drivers':
+        if self.device.association_mechanism == 'drivers':
             disconnect_response = self.device.wlan_lib.wlanDisconnect()
-            asserts.assert_true(
-                self.device.check_disconnect_response(disconnect_response),
-                'Failed to disconnect.')
+            return self.device.check_disconnect_response(disconnect_response)
         else:
-            self.log.error(
-                "Association mechanism %s is not recognized. Acceptable values are 'drivers' and 'policy'"
-                % association_mechanism)
-            raise ValueError(
-                'Invalid association_mechanism "%s". Valid options are "policy" or "drivers".'
-                % association_mechanism)
+            return self.device.wlan_policy_controller.remove_all_networks_and_wait_for_no_connections(
+            )
 
     def status(self):
         return self.device.wlan_lib.wlanStatus()
@@ -467,16 +451,20 @@
         self.device.reboot(reboot_type='hard', testbed_pdus=pdus)
 
     def save_network(self, target_ssid, security_type=None, target_pwd=None):
+        if self.device.association_mechanism == 'drivers':
+            raise EnvironmentError(
+                'Cannot save network using the drivers. Saved networks are a '
+                'policy layer concept.')
         if security_type and security_type not in FUCHSIA_VALID_SECURITY_TYPES:
             raise TypeError('Invalid security type: %s' % security_type)
-        response = self.device.wlan_policy_lib.wlanSaveNetwork(
-            target_ssid, security_type, target_pwd=target_pwd)
-        if response.get('error'):
-            raise EnvironmentError('Failed to save network %s. Err: %s' %
-                                   (target_ssid, response.get('error')))
+        if not self.device.wlan_policy_controller.save_network(
+                target_ssid, security_type, password=target_pwd):
+            raise EnvironmentError('Failed to save network: %s' % target_ssid)
 
     def clear_saved_networks(self):
-        response = self.device.wlan_policy_lib.wlanRemoveAllNetworks()
-        if response.get('error'):
-            raise EnvironmentError('Failed to clear saved networks: %s' %
-                                   response.get('error'))
+        if self.device.association_mechanism == 'drivers':
+            raise EnvironmentError(
+                'Cannot clear saved network using the drivers. Saved networks '
+                'are a policy layer concept.')
+        if not self.device.wlan_policy_controller.remove_all_networks():
+            raise EnvironmentError('Failed to clear saved networks')
diff --git a/acts_tests/tests/google/fuchsia/wlan/BeaconLossTest.py b/acts_tests/tests/google/fuchsia/wlan/BeaconLossTest.py
index e71a844..aaef98f 100644
--- a/acts_tests/tests/google/fuchsia/wlan/BeaconLossTest.py
+++ b/acts_tests/tests/google/fuchsia/wlan/BeaconLossTest.py
@@ -30,10 +30,9 @@
 from acts import signals
 from acts import utils
 from acts.base_test import BaseTestClass
+from acts.controllers.access_point import setup_ap
 from acts.controllers.ap_lib import hostapd_constants
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils import disconnect
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils import setup_ap
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils import associate
+
 from acts_contrib.test_utils.abstract_devices.wlan_device import create_wlan_device
 from acts_contrib.test_utils.abstract_devices.wlan_device_lib.AbstractDeviceWlanDeviceBaseTest import AbstractDeviceWlanDeviceBaseTest
 from acts.utils import rand_ascii_str
diff --git a/acts_tests/tests/google/fuchsia/wlan/ChannelSweepTest.py b/acts_tests/tests/google/fuchsia/wlan/ChannelSweepTest.py
index 57ecbb0..552cfa9 100644
--- a/acts_tests/tests/google/fuchsia/wlan/ChannelSweepTest.py
+++ b/acts_tests/tests/google/fuchsia/wlan/ChannelSweepTest.py
@@ -29,11 +29,11 @@
 from acts import asserts
 from acts import context
 from acts import utils
+from acts.controllers.access_point import setup_ap
 from acts.controllers.ap_lib import hostapd_config
 from acts.controllers.ap_lib import hostapd_constants
 from acts.controllers.ap_lib.hostapd_security import Security
 from acts.controllers.iperf_server import IPerfResult
-from acts_contrib.test_utils.abstract_devices.utils_lib import wlan_utils
 from acts_contrib.test_utils.abstract_devices.wlan_device import create_wlan_device
 from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
 
@@ -236,16 +236,16 @@
             raise ValueError('Invalid Bandwidth: %s' % channel_bandwidth)
         ssid = utils.rand_ascii_str(hostapd_constants.AP_SSID_LENGTH_2G)
         try:
-            wlan_utils.setup_ap(access_point=self.access_point,
-                                profile_name='whirlwind',
-                                channel=channel,
-                                security=security_profile,
-                                n_capabilities=n_capabilities,
-                                ac_capabilities=None,
-                                force_wmm=True,
-                                ssid=ssid,
-                                vht_bandwidth=vht_bandwidth,
-                                setup_bridge=True)
+            setup_ap(access_point=self.access_point,
+                     profile_name='whirlwind',
+                     channel=channel,
+                     security=security_profile,
+                     n_capabilities=n_capabilities,
+                     ac_capabilities=None,
+                     force_wmm=True,
+                     ssid=ssid,
+                     vht_bandwidth=vht_bandwidth,
+                     setup_bridge=True)
         except Exception as err:
             raise ConnectionError(
                 'Failed to setup ap on channel: %s, channel bandwidth: %smhz. '
@@ -597,9 +597,7 @@
             password = None
             security_profile = None
         ssid = self.setup_ap(channel, channel_bandwidth, security_profile)
-        associated = wlan_utils.associate(client=self.dut,
-                                          ssid=ssid,
-                                          password=password)
+        associated = self.dut.associate(ssid, target_pwd=password)
         if not associated:
             self.log_to_file_and_throughput_data(channel, channel_bandwidth,
                                                  None, None)
@@ -717,7 +715,7 @@
             (ssid, channel, channel_bandwidth, 'Device should associate'
              if should_associate else 'Device should NOT associate.'))
 
-        associated = wlan_utils.associate(client=self.dut, ssid=ssid)
+        associated = self.dut.associate(ssid)
         if associated == should_associate:
             asserts.explicit_pass(
                 'Device complied with %s regulatory requirement for channel %s '
diff --git a/acts_tests/tests/google/fuchsia/wlan/ConnectionStressTest.py b/acts_tests/tests/google/fuchsia/wlan/ConnectionStressTest.py
index aca7e83..1bde027 100644
--- a/acts_tests/tests/google/fuchsia/wlan/ConnectionStressTest.py
+++ b/acts_tests/tests/google/fuchsia/wlan/ConnectionStressTest.py
@@ -24,11 +24,9 @@
 import time
 
 from acts import signals
+from acts.controllers.access_point import setup_ap
 from acts.controllers.ap_lib import hostapd_constants
 from acts.controllers.ap_lib import hostapd_security
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils import setup_ap
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils import associate
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils import disconnect
 from acts_contrib.test_utils.abstract_devices.wlan_device import create_wlan_device
 from acts_contrib.test_utils.abstract_devices.wlan_device_lib.AbstractDeviceWlanDeviceBaseTest import AbstractDeviceWlanDeviceBaseTest
 from acts_contrib.test_utils.fuchsia import utils
@@ -99,7 +97,7 @@
             if not ssid:
                 ssid = self.ssid
             if negative_test:
-                if not associate(self.dut, ssid=ssid, password=password):
+                if not self.dut.associate(ssid, target_pwd=password):
                     self.log.info(
                         'Attempt %d. Did not associate as expected.' % x)
                 else:
@@ -108,13 +106,13 @@
                     failed = True
             else:
                 # Connect
-                if associate(self.dut, ssid=ssid, password=password):
+                if self.dut.associate(ssid, target_pwd=password):
                     self.log.info('Attempt %d. Successfully associated' % x)
                 else:
                     self.log.error('Attempt %d. Failed to associate.' % x)
                     failed = True
                 # Disconnect
-                disconnect(self.dut)
+                self.dut.disconnect()
 
             # Wait a second before trying again
             time.sleep(1)
diff --git a/acts_tests/tests/google/fuchsia/wlan/DownloadStressTest.py b/acts_tests/tests/google/fuchsia/wlan/DownloadStressTest.py
index 5fa4fbb..df83af3 100644
--- a/acts_tests/tests/google/fuchsia/wlan/DownloadStressTest.py
+++ b/acts_tests/tests/google/fuchsia/wlan/DownloadStressTest.py
@@ -23,8 +23,8 @@
 
 from acts.base_test import BaseTestClass
 from acts import signals
+from acts.controllers.access_point import setup_ap
 from acts.controllers.ap_lib import hostapd_constants
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils import setup_ap_and_associate
 from acts_contrib.test_utils.abstract_devices.wlan_device import create_wlan_device
 from acts_contrib.test_utils.fuchsia import utils
 from acts_contrib.test_utils.tel.tel_test_utils import setup_droid_properties
@@ -62,12 +62,11 @@
             self.user_params.get("download_stress_test_iterations",
                                  self.num_of_iterations))
 
-        setup_ap_and_associate(
-            access_point=self.ap,
-            client=self.wlan_device,
-            profile_name='whirlwind',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.ap,
+                 profile_name='whirlwind',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid)
+        self.wlan_device.associate(self.ssid)
 
     def teardown_test(self):
         self.download_threads_result.clear()
@@ -135,8 +134,8 @@
         for index in range(0, len(self.download_threads_result)):
             if not self.download_threads_result[index]:
                 self.log.info("Download failed for %d" % index)
-                raise signals.TestFailure(
-                    'Thread %d failed to download' % index)
+                raise signals.TestFailure('Thread %d failed to download' %
+                                          index)
                 return False
 
         return True
@@ -153,9 +152,8 @@
 
                 for i in range(self.num_of_small_downloads):
                     # Start small file download
-                    t = threading.Thread(
-                        target=self.download_thread,
-                        args=(self.download_small_url, ))
+                    t = threading.Thread(target=self.download_thread,
+                                         args=(self.download_small_url, ))
                     download_threads.append(t)
                     t.start()
                     # Wait for thread to exit before starting the next iteration
@@ -178,8 +176,8 @@
             for index in range(0, len(self.download_threads_result)):
                 if not self.download_threads_result[index]:
                     self.log.info("Download failed for %d" % index)
-                    raise signals.TestFailure(
-                        'Thread %d failed to download' % index)
+                    raise signals.TestFailure('Thread %d failed to download' %
+                                              index)
                     return False
 
             # Clear results before looping again
diff --git a/acts_tests/tests/google/fuchsia/wlan/PingStressTest.py b/acts_tests/tests/google/fuchsia/wlan/PingStressTest.py
index fb40426..8c31e65 100644
--- a/acts_tests/tests/google/fuchsia/wlan/PingStressTest.py
+++ b/acts_tests/tests/google/fuchsia/wlan/PingStressTest.py
@@ -24,8 +24,8 @@
 import uuid
 
 from acts import signals
+from acts.controllers.access_point import setup_ap
 from acts.controllers.ap_lib import hostapd_constants
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils import setup_ap_and_associate
 from acts_contrib.test_utils.abstract_devices.wlan_device import create_wlan_device
 from acts_contrib.test_utils.tel.tel_test_utils import setup_droid_properties
 from acts_contrib.test_utils.fuchsia import utils
@@ -50,12 +50,12 @@
         self.fd = self.fuchsia_devices[0]
         self.wlan_device = create_wlan_device(self.fd)
         self.ap = self.access_points[0]
-        setup_ap_and_associate(access_point=self.ap,
-                               client=self.wlan_device,
-                               profile_name='whirlwind',
-                               channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-                               ssid=self.ssid,
-                               setup_bridge=True)
+        setup_ap(access_point=self.ap,
+                 profile_name='whirlwind',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid,
+                 setup_bridge=True)
+        self.wlan_device.associate(self.ssid)
 
     def teardown_class(self):
         self.wlan_device.disconnect()
diff --git a/acts_tests/tests/google/fuchsia/wlan/SoftApTest.py b/acts_tests/tests/google/fuchsia/wlan/SoftApTest.py
index c364481..2ca53e6 100644
--- a/acts_tests/tests/google/fuchsia/wlan/SoftApTest.py
+++ b/acts_tests/tests/google/fuchsia/wlan/SoftApTest.py
@@ -24,11 +24,10 @@
 from acts.base_test import BaseTestClass
 from acts.controllers import iperf_server
 from acts.controllers import iperf_client
+from acts.controllers.access_point import setup_ap
 from acts.controllers.ap_lib import hostapd_constants
 from acts.controllers.ap_lib import hostapd_security
-from acts_contrib.test_utils.abstract_devices.utils_lib import wlan_utils
 from acts_contrib.test_utils.abstract_devices.wlan_device import create_wlan_device
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils import setup_ap
 
 ANDROID_DEFAULT_WLAN_INTERFACE = 'wlan0'
 CONNECTIVITY_MODE_LOCAL = 'local_only'
@@ -292,11 +291,9 @@
 
         check_connectivity = settings[
             'connectivity_mode'] == CONNECTIVITY_MODE_UNRESTRICTED
-        associated = wlan_utils.associate(
-            w_device,
-            settings['ssid'],
-            password=settings.get('password'),
-            check_connectivity=check_connectivity)
+        associated = w_device.associate(settings['ssid'],
+                                        target_pwd=settings.get('password'),
+                                        check_connectivity=check_connectivity)
 
         if not associated:
             self.log.error('Failed to connect to SoftAp.')
@@ -660,8 +657,8 @@
             with utils.SuppressLogOutput():
                 try:
                     return not self.client_is_connected_to_soft_ap(
-                    client,
-                    wait_for_addr_timeout=DEFAULT_NO_ADDR_EXPECTED_TIMEOUT)
+                        client,
+                        wait_for_addr_timeout=DEFAULT_NO_ADDR_EXPECTED_TIMEOUT)
                 # Allow a failed to find ap interface error
                 except LookupError as err:
                     self.log.debug('Hit expected LookupError: %s' % err)
@@ -680,8 +677,8 @@
             with utils.SuppressLogOutput():
                 try:
                     return not self.dut_is_connected_as_client(
-                    channel,
-                    wait_for_addr_timeout=DEFAULT_NO_ADDR_EXPECTED_TIMEOUT)
+                        channel,
+                        wait_for_addr_timeout=DEFAULT_NO_ADDR_EXPECTED_TIMEOUT)
                 # Allow a failed to find client interface error
                 except LookupError as err:
                     self.log.debug('Hit expected LookupError: %s' % err)
diff --git a/acts_tests/tests/google/fuchsia/wlan/VapeInteropTest.py b/acts_tests/tests/google/fuchsia/wlan/VapeInteropTest.py
index dd6374d..3cc7a74 100644
--- a/acts_tests/tests/google/fuchsia/wlan/VapeInteropTest.py
+++ b/acts_tests/tests/google/fuchsia/wlan/VapeInteropTest.py
@@ -14,13 +14,14 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
+from acts import asserts
 from acts import utils
+from acts.controllers.access_point import setup_ap
 from acts.controllers.ap_lib import hostapd_ap_preset
 from acts.controllers.ap_lib import hostapd_constants
 from acts.controllers.ap_lib.hostapd_security import Security
 from acts_contrib.test_utils.abstract_devices.wlan_device import create_wlan_device
 from acts_contrib.test_utils.abstract_devices.wlan_device_lib.AbstractDeviceWlanDeviceBaseTest import AbstractDeviceWlanDeviceBaseTest
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils import validate_setup_ap_and_associate
 from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
 
 
@@ -80,559 +81,652 @@
         self.access_point.stop_all_aps()
 
     def test_associate_actiontec_pk5000_24ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='actiontec_pk5000',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='actiontec_pk5000',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_actiontec_pk5000_24ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='actiontec_pk5000',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='actiontec_pk5000',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_actiontec_mi424wr_24ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='actiontec_mi424wr',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='actiontec_mi424wr',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_actiontec_mi424wr_24ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='actiontec_mi424wr',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='actiontec_mi424wr',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_asus_rtac66u_24ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtac66u',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtac66u',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_asus_rtac66u_24ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtac66u',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtac66u',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_asus_rtac66u_5ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtac66u',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtac66u',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_asus_rtac66u_5ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtac66u',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtac66u',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_asus_rtac86u_24ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtac86u',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtac86u',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_asus_rtac86u_24ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtac86u',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtac86u',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_asus_rtac86u_5ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtac86u',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtac86u',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_asus_rtac86u_5ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtac86u',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtac86u',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_asus_rtac5300_24ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtac5300',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtac5300',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_asus_rtac5300_24ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtac5300',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtac5300',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_asus_rtac5300_5ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtac5300',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtac5300',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_asus_rtac5300_5ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtac5300',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtac5300',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_asus_rtn56u_24ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtn56u',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtn56u',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_asus_rtn56u_24ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtn56u',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtn56u',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_asus_rtn56u_5ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtn56u',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtn56u',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_asus_rtn56u_5ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtn56u',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtn56u',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_asus_rtn66u_24ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtn66u',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtn66u',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_asus_rtn66u_24ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtn66u',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtn66u',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_asus_rtn66u_5ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtn66u',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtn66u',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_asus_rtn66u_5ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='asus_rtn66u',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='asus_rtn66u',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_belkin_f9k1001v5_24ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='belkin_f9k1001v5',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='belkin_f9k1001v5',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_belkin_f9k1001v5_24ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='belkin_f9k1001v5',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='belkin_f9k1001v5',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_linksys_ea4500_24ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='linksys_ea4500',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='linksys_ea4500',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_linksys_ea4500_24ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='linksys_ea4500',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='linksys_ea4500',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_linksys_ea4500_5ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='linksys_ea4500',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='linksys_ea4500',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_linksys_ea4500_5ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='linksys_ea4500',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='linksys_ea4500',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_linksys_ea9500_24ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='linksys_ea9500',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='linksys_ea9500',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_linksys_ea9500_24ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='linksys_ea9500',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='linksys_ea9500',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_linksys_ea9500_5ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='linksys_ea9500',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='linksys_ea9500',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_linksys_ea9500_5ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='linksys_ea9500',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='linksys_ea9500',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_linksys_wrt1900acv2_24ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='linksys_wrt1900acv2',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='linksys_wrt1900acv2',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_linksys_wrt1900acv2_24ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='linksys_wrt1900acv2',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='linksys_wrt1900acv2',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_linksys_wrt1900acv2_5ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='linksys_wrt1900acv2',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='linksys_wrt1900acv2',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_linksys_wrt1900acv2_5ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='linksys_wrt1900acv2',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='linksys_wrt1900acv2',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_netgear_r7000_24ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='netgear_r7000',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='netgear_r7000',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_netgear_r7000_24ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='netgear_r7000',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='netgear_r7000',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_netgear_r7000_5ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='netgear_r7000',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='netgear_r7000',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_netgear_r7000_5ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='netgear_r7000',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='netgear_r7000',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_netgear_wndr3400_24ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='netgear_wndr3400',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='netgear_wndr3400',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_netgear_wndr3400_24ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='netgear_wndr3400',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='netgear_wndr3400',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_netgear_wndr3400_5ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='netgear_wndr3400',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='netgear_wndr3400',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_netgear_wndr3400_5ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='netgear_wndr3400',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='netgear_wndr3400',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_securifi_almond_24ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='securifi_almond',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='securifi_almond',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_securifi_almond_24ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='securifi_almond',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='securifi_almond',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_tplink_archerc5_24ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='tplink_archerc5',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='tplink_archerc5',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_tplink_archerc5_24ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='tplink_archerc5',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='tplink_archerc5',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_tplink_archerc5_5ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='tplink_archerc5',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='tplink_archerc5',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_tplink_archerc5_5ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='tplink_archerc5',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='tplink_archerc5',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_tplink_archerc7_24ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='tplink_archerc7',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='tplink_archerc7',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_tplink_archerc7_24ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='tplink_archerc7',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='tplink_archerc7',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_tplink_archerc7_5ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='tplink_archerc7',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='tplink_archerc7',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_tplink_archerc7_5ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='tplink_archerc7',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='tplink_archerc7',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_tplink_c1200_24ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='tplink_c1200',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='tplink_c1200',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_tplink_c1200_24ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='tplink_c1200',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='tplink_c1200',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_tplink_c1200_5ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='tplink_c1200',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='tplink_c1200',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_tplink_c1200_5ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='tplink_c1200',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='tplink_c1200',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
 
     def test_associate_tplink_tlwr940n_24ghz_open(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='tplink_tlwr940n',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid)
+        setup_ap(access_point=self.access_point,
+                 profile_name='tplink_tlwr940n',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid)
+        asserts.assert_true(self.dut.associate(self.ssid),
+                            'Failed to connect.')
 
     def test_associate_tplink_tlwr940n_24ghz_wpa2(self):
-        validate_setup_ap_and_associate(
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='tplink_tlwr940n',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.ssid,
-            security=self.security_profile_wpa2,
-            password=self.password)
\ No newline at end of file
+        setup_ap(access_point=self.access_point,
+                 profile_name='tplink_tlwr940n',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.ssid,
+                 security=self.security_profile_wpa2,
+                 password=self.password)
+        asserts.assert_true(
+            self.dut.associate(self.ssid,
+                               target_pwd=self.password,
+                               target_security=hostapd_constants.WPA2_STRING),
+            'Failed to connect.')
diff --git a/acts_tests/tests/google/fuchsia/wlan/WlanPhyCompliance11ACTest.py b/acts_tests/tests/google/fuchsia/wlan/WlanPhyCompliance11ACTest.py
index 72dcfe6..70b1684 100644
--- a/acts_tests/tests/google/fuchsia/wlan/WlanPhyCompliance11ACTest.py
+++ b/acts_tests/tests/google/fuchsia/wlan/WlanPhyCompliance11ACTest.py
@@ -17,13 +17,14 @@
 import itertools
 import re
 
+from acts import asserts
 from acts import utils
+from acts.controllers.access_point import setup_ap
 from acts.controllers.ap_lib.hostapd_security import Security
 from acts.controllers.ap_lib import hostapd_constants
 from acts.controllers.ap_lib import hostapd_config
 from acts_contrib.test_utils.abstract_devices.wlan_device import create_wlan_device
 from acts_contrib.test_utils.abstract_devices.wlan_device_lib.AbstractDeviceWlanDeviceBaseTest import AbstractDeviceWlanDeviceBaseTest
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils import validate_setup_ap_and_associate
 from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
 from acts.utils import rand_ascii_str
 
@@ -171,26 +172,33 @@
                 bandwidth, security, n_capabilities, and ac_capabilities
 
         """
+        ssid = rand_ascii_str(20)
         security = ap_settings['security']
         chbw = ap_settings['chbw']
         password = None
+        target_security = None
         if security:
             password = security.password
+            target_security = security.security_mode
         n_capabilities = ap_settings['n_capabilities']
         ac_capabilities = ap_settings['ac_capabilities']
 
-        validate_setup_ap_and_associate(access_point=self.access_point,
-                                        client=self.dut,
-                                        profile_name='whirlwind',
-                                        mode=hostapd_constants.MODE_11AC_MIXED,
-                                        channel=36,
-                                        n_capabilities=n_capabilities,
-                                        ac_capabilities=ac_capabilities,
-                                        force_wmm=True,
-                                        ssid=utils.rand_ascii_str(20),
-                                        security=security,
-                                        vht_bandwidth=chbw,
-                                        password=password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind',
+                 mode=hostapd_constants.MODE_11AC_MIXED,
+                 channel=36,
+                 n_capabilities=n_capabilities,
+                 ac_capabilities=ac_capabilities,
+                 force_wmm=True,
+                 ssid=ssid,
+                 security=security,
+                 vht_bandwidth=chbw,
+                 password=password)
+        asserts.assert_true(
+            self.dut.associate(ssid,
+                               target_pwd=password,
+                               target_security=target_security),
+            'Failed to associate.')
 
     # 864 test cases
     def test_11ac_capabilities_20mhz_open(self):
diff --git a/acts_tests/tests/google/fuchsia/wlan/WlanPhyCompliance11NTest.py b/acts_tests/tests/google/fuchsia/wlan/WlanPhyCompliance11NTest.py
index f538242..754e17e 100644
--- a/acts_tests/tests/google/fuchsia/wlan/WlanPhyCompliance11NTest.py
+++ b/acts_tests/tests/google/fuchsia/wlan/WlanPhyCompliance11NTest.py
@@ -17,13 +17,13 @@
 import itertools
 import re
 
+from acts import asserts
 from acts import utils
-from acts.controllers.ap_lib.hostapd_security import Security
+from acts.controllers.access_point import setup_ap
 from acts.controllers.ap_lib import hostapd_constants
 from acts.controllers.ap_lib import hostapd_config
 from acts_contrib.test_utils.abstract_devices.wlan_device import create_wlan_device
 from acts_contrib.test_utils.abstract_devices.wlan_device_lib.AbstractDeviceWlanDeviceBaseTest import AbstractDeviceWlanDeviceBaseTest
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils import validate_setup_ap_and_associate
 from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
 from acts.utils import rand_ascii_str
 
@@ -133,8 +133,10 @@
         Args:
                ap_settings: A dictionary of hostapd constant n_capabilities.
         """
+        ssid = utils.rand_ascii_str(20)
         security_profile = None
         password = None
+        target_security = None
         temp_n_capabilities = list(ap_settings['n_capabilities'])
         n_capabilities = []
         for n_capability in temp_n_capabilities:
@@ -150,7 +152,7 @@
                 raise ValueError('Invalid frequence: %s' %
                                  ap_settings['frequency'])
 
-        if ap_settings['chbw'] == 'HT40-':
+        elif ap_settings['chbw'] == 'HT40-':
             if ap_settings['frequency'] == '2.4GHz':
                 channel = 11
             elif ap_settings['frequency'] == '5GHz':
@@ -159,6 +161,10 @@
                 raise ValueError('Invalid frequency: %s' %
                                  ap_settings['frequency'])
 
+        else:
+            raise ValueError('Invalid channel bandwidth: %s' %
+                             ap_settings['chbw'])
+
         if ap_settings['chbw'] == 'HT40-' or ap_settings['chbw'] == 'HT40+':
             if hostapd_config.ht40_plus_allowed(channel):
                 extended_channel = hostapd_constants.N_CAPABILITY_HT40_PLUS
@@ -174,18 +180,23 @@
                                         wpa_cipher='CCMP',
                                         wpa2_cipher='CCMP')
             password = security_profile.password
+            target_security = hostapd_constants.WPA2_STRING
 
-        validate_setup_ap_and_associate(access_point=self.access_point,
-                                        client=self.dut,
-                                        profile_name='whirlwind',
-                                        mode=hostapd_constants.MODE_11N_MIXED,
-                                        channel=channel,
-                                        n_capabilities=n_capabilities,
-                                        ac_capabilities=[],
-                                        force_wmm=True,
-                                        ssid=utils.rand_ascii_str(20),
-                                        security=security_profile,
-                                        password=password)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind',
+                 mode=hostapd_constants.MODE_11N_MIXED,
+                 channel=channel,
+                 n_capabilities=n_capabilities,
+                 ac_capabilities=[],
+                 force_wmm=True,
+                 ssid=ssid,
+                 security=security_profile,
+                 password=password)
+        asserts.assert_true(
+            self.dut.associate(ssid,
+                               target_pwd=password,
+                               target_security=target_security),
+            'Failed to connect.')
 
     def test_11n_capabilities_24_HT20(self):
         test_list = []
diff --git a/acts_tests/tests/google/fuchsia/wlan/WlanPhyComplianceABGTest.py b/acts_tests/tests/google/fuchsia/wlan/WlanPhyComplianceABGTest.py
index df9931b..b3efacc 100644
--- a/acts_tests/tests/google/fuchsia/wlan/WlanPhyComplianceABGTest.py
+++ b/acts_tests/tests/google/fuchsia/wlan/WlanPhyComplianceABGTest.py
@@ -14,14 +14,14 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
+from acts import asserts
 from acts import utils
 
+from acts.controllers.access_point import setup_ap
 from acts.controllers.ap_lib import hostapd_ap_preset
 from acts.controllers.ap_lib import hostapd_constants
 from acts_contrib.test_utils.abstract_devices.wlan_device import create_wlan_device
 from acts_contrib.test_utils.abstract_devices.wlan_device_lib.AbstractDeviceWlanDeviceBaseTest import AbstractDeviceWlanDeviceBaseTest
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils import validate_setup_ap_and_associate
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_policy_utils import setup_policy_tests, restore_state
 from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
 
 
@@ -105,16 +105,6 @@
         self.utf8_ssid_2g_korean = 'ㅘㅙㅚㅛㅜㅝㅞㅟㅠ'
         self.utf8_password_2g_korean = 'ㅜㅝㅞㅟㅠㅘㅙㅚㅛ'
 
-        # These tests will either be performed by connecting through the policy
-        # layer or directly below at a core/driver layer.
-        self.association_mechanism = 'drivers'
-        if 'association_mechanism' in self.user_params:
-            if self.user_params['association_mechanism'] == 'policy':
-                self.association_mechanism = 'policy'
-                # Preserve networks already saved on device before removing
-                self.preexisting_state = setup_policy_tests(
-                    self.fuchsia_devices)
-
         self.access_point.stop_all_aps()
 
     def setup_test(self):
@@ -134,792 +124,728 @@
         self.dut.reset_wifi()
         self.access_point.stop_all_aps()
 
-    def teardown_class(self):
-        if self.association_mechanism == 'policy':
-            restore_state(self.fuchsia_devices, self.preexisting_state)
-
     def on_fail(self, test_name, begin_time):
         super().on_fail(test_name, begin_time)
         self.access_point.stop_all_aps()
 
     def test_associate_11b_only_long_preamble(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            preamble=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 preamble=False)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_short_preamble(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            preamble=True)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 preamble=True)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_minimal_beacon_interval(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            beacon_interval=15)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 beacon_interval=15)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_maximum_beacon_interval(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            beacon_interval=1024)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 beacon_interval=1024)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_frag_threshold_430(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            frag_threshold=430)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 frag_threshold=430)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_rts_threshold_256(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            rts_threshold=256)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 rts_threshold=256)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_rts_256_frag_430(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            rts_threshold=256,
-            frag_threshold=430)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 rts_threshold=256,
+                 frag_threshold=430)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_high_dtim_low_beacon_interval(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            dtim_period=3,
-            beacon_interval=100)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 dtim_period=3,
+                 beacon_interval=100)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_low_dtim_high_beacon_interval(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            dtim_period=1,
-            beacon_interval=300)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 dtim_period=1,
+                 beacon_interval=300)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_with_WMM_with_default_values(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
+        setup_ap(
             access_point=self.access_point,
-            client=self.dut,
             profile_name='whirlwind_11ab_legacy',
             channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
             ssid=self.open_network_2g['SSID'],
             force_wmm=True,
             additional_ap_parameters=hostapd_constants.WMM_11B_DEFAULT_PARAMS)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_with_WMM_with_non_default_values(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
+        setup_ap(
             access_point=self.access_point,
-            client=self.dut,
             profile_name='whirlwind_11ab_legacy',
             channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
             ssid=self.open_network_2g['SSID'],
             force_wmm=True,
             additional_ap_parameters=hostapd_constants.WMM_NON_DEFAULT_PARAMS)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_with_WMM_ACM_on_BK(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_11B_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BK)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_with_WMM_ACM_on_BE(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_11B_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BE)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_with_WMM_ACM_on_VI(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_11B_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_VI)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_with_WMM_ACM_on_VO(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_11B_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_VO)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_with_WMM_ACM_on_BK_BE_VI(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_11B_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BK, hostapd_constants.WMM_ACM_BE,
             hostapd_constants.WMM_ACM_VI)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_with_WMM_ACM_on_BK_BE_VO(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_11B_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BK, hostapd_constants.WMM_ACM_BE,
             hostapd_constants.WMM_ACM_VO)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_with_WMM_ACM_on_BK_VI_VO(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_11B_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BK, hostapd_constants.WMM_ACM_VI,
             hostapd_constants.WMM_ACM_VO)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_with_WMM_ACM_on_BE_VI_VO(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_11B_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BE, hostapd_constants.WMM_ACM_VI,
             hostapd_constants.WMM_ACM_VO)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_with_country_code(self):
         country_info = utils.merge_dicts(
             hostapd_constants.ENABLE_IEEE80211D,
             hostapd_constants.COUNTRY_STRING['ALL'],
             hostapd_constants.COUNTRY_CODE['UNITED_STATES'])
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            additional_ap_parameters=country_info)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 additional_ap_parameters=country_info)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_with_non_country_code(self):
         country_info = utils.merge_dicts(
             hostapd_constants.ENABLE_IEEE80211D,
             hostapd_constants.COUNTRY_STRING['ALL'],
             hostapd_constants.COUNTRY_CODE['NON_COUNTRY'])
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            additional_ap_parameters=country_info)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 additional_ap_parameters=country_info)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_with_hidden_ssid(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            hidden=True)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 hidden=True)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_with_vendor_ie_in_beacon_correct_length(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['correct_length_beacon'])
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['correct_length_beacon'])
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_with_vendor_ie_in_beacon_zero_length(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['zero_length_beacon_without_data'])
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['zero_length_beacon_without_data'])
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_with_vendor_ie_in_assoc_correct_length(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['correct_length_association_response'])
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['correct_length_association_response'])
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11b_only_with_vendor_ie_in_assoc_zero_length(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.VENDOR_IE[
-                'zero_length_association_'
-                'response_without_data'])
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.VENDOR_IE[
+                     'zero_length_association_'
+                     'response_without_data'])
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_long_preamble(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            preamble=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 preamble=False)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_short_preamble(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            preamble=True)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 preamble=True)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_minimal_beacon_interval(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            beacon_interval=15)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 beacon_interval=15)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_maximum_beacon_interval(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            beacon_interval=1024)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 beacon_interval=1024)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_frag_threshold_430(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            frag_threshold=430)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 frag_threshold=430)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_rts_threshold_256(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            rts_threshold=256)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 rts_threshold=256)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_rts_256_frag_430(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            rts_threshold=256,
-            frag_threshold=430)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 rts_threshold=256,
+                 frag_threshold=430)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_high_dtim_low_beacon_interval(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            dtim_period=3,
-            beacon_interval=100)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 dtim_period=3,
+                 beacon_interval=100)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_low_dtim_high_beacon_interval(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            dtim_period=1,
-            beacon_interval=300)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 dtim_period=1,
+                 beacon_interval=300)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_with_WMM_with_default_values(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=hostapd_constants.
-            WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=hostapd_constants.
+                 WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_with_WMM_with_non_default_values(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
+        setup_ap(
             access_point=self.access_point,
-            client=self.dut,
             profile_name='whirlwind_11ab_legacy',
             channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
             ssid=self.open_network_5g['SSID'],
             force_wmm=True,
             additional_ap_parameters=hostapd_constants.WMM_NON_DEFAULT_PARAMS)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_with_WMM_ACM_on_BK(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BK)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_with_WMM_ACM_on_BE(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BE)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_with_WMM_ACM_on_VI(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_VI)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_with_WMM_ACM_on_VO(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_VO)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_with_WMM_ACM_on_BK_BE_VI(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BK, hostapd_constants.WMM_ACM_BE,
             hostapd_constants.WMM_ACM_VI)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_with_WMM_ACM_on_BK_BE_VO(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BK, hostapd_constants.WMM_ACM_BE,
             hostapd_constants.WMM_ACM_VO)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_with_WMM_ACM_on_BK_VI_VO(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BK, hostapd_constants.WMM_ACM_VI,
             hostapd_constants.WMM_ACM_VO)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_with_WMM_ACM_on_BE_VI_VO(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BE, hostapd_constants.WMM_ACM_VI,
             hostapd_constants.WMM_ACM_VO)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_with_country_code(self):
         country_info = utils.merge_dicts(
             hostapd_constants.ENABLE_IEEE80211D,
             hostapd_constants.COUNTRY_STRING['ALL'],
             hostapd_constants.COUNTRY_CODE['UNITED_STATES'])
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            additional_ap_parameters=country_info)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 additional_ap_parameters=country_info)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_with_non_country_code(self):
         country_info = utils.merge_dicts(
             hostapd_constants.ENABLE_IEEE80211D,
             hostapd_constants.COUNTRY_STRING['ALL'],
             hostapd_constants.COUNTRY_CODE['NON_COUNTRY'])
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            additional_ap_parameters=country_info)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 additional_ap_parameters=country_info)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_with_hidden_ssid(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            hidden=True)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 hidden=True)
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_with_vendor_ie_in_beacon_correct_length(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['correct_length_beacon'])
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['correct_length_beacon'])
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_with_vendor_ie_in_beacon_zero_length(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['zero_length_beacon_without_data'])
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['zero_length_beacon_without_data'])
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_with_vendor_ie_in_assoc_correct_length(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['correct_length_association_response'])
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['correct_length_association_response'])
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11a_only_with_vendor_ie_in_assoc_zero_length(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_5g['SSID'],
-            additional_ap_parameters=hostapd_constants.VENDOR_IE[
-                'zero_length_association_'
-                'response_without_data'])
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_5g['SSID'],
+                 additional_ap_parameters=hostapd_constants.VENDOR_IE[
+                     'zero_length_association_'
+                     'response_without_data'])
+        asserts.assert_true(self.dut.associate(self.open_network_5g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_long_preamble(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
                                        hostapd_constants.OFDM_ONLY_BASIC_RATES)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            preamble=False,
-            additional_ap_parameters=data_rates)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 preamble=False,
+                 additional_ap_parameters=data_rates)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_short_preamble(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
                                        hostapd_constants.OFDM_ONLY_BASIC_RATES)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            preamble=True,
-            additional_ap_parameters=data_rates)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 preamble=True,
+                 additional_ap_parameters=data_rates)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_minimal_beacon_interval(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
                                        hostapd_constants.OFDM_ONLY_BASIC_RATES)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            beacon_interval=15,
-            additional_ap_parameters=data_rates)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 beacon_interval=15,
+                 additional_ap_parameters=data_rates)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_maximum_beacon_interval(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
                                        hostapd_constants.OFDM_ONLY_BASIC_RATES)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            beacon_interval=1024,
-            additional_ap_parameters=data_rates)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 beacon_interval=1024,
+                 additional_ap_parameters=data_rates)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_frag_threshold_430(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
                                        hostapd_constants.OFDM_ONLY_BASIC_RATES)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            frag_threshold=430,
-            additional_ap_parameters=data_rates)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 frag_threshold=430,
+                 additional_ap_parameters=data_rates)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_rts_threshold_256(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
                                        hostapd_constants.OFDM_ONLY_BASIC_RATES)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            rts_threshold=256,
-            additional_ap_parameters=data_rates)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 rts_threshold=256,
+                 additional_ap_parameters=data_rates)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_rts_256_frag_430(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
                                        hostapd_constants.OFDM_ONLY_BASIC_RATES)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            rts_threshold=256,
-            frag_threshold=430,
-            additional_ap_parameters=data_rates)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 rts_threshold=256,
+                 frag_threshold=430,
+                 additional_ap_parameters=data_rates)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_high_dtim_low_beacon_interval(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
                                        hostapd_constants.OFDM_ONLY_BASIC_RATES)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            dtim_period=3,
-            beacon_interval=100,
-            additional_ap_parameters=data_rates)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 dtim_period=3,
+                 beacon_interval=100,
+                 additional_ap_parameters=data_rates)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_low_dtim_high_beacon_interval(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
                                        hostapd_constants.OFDM_ONLY_BASIC_RATES)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            dtim_period=1,
-            beacon_interval=300,
-            additional_ap_parameters=data_rates)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 dtim_period=1,
+                 beacon_interval=300,
+                 additional_ap_parameters=data_rates)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_with_WMM_with_default_values(self):
         data_rates = utils.merge_dicts(
             hostapd_constants.OFDM_DATA_RATES,
             hostapd_constants.OFDM_ONLY_BASIC_RATES,
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=data_rates)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=data_rates)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_with_WMM_with_non_default_values(self):
         data_rates = utils.merge_dicts(
             hostapd_constants.OFDM_DATA_RATES,
             hostapd_constants.OFDM_ONLY_BASIC_RATES,
             hostapd_constants.WMM_NON_DEFAULT_PARAMS)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=data_rates)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=data_rates)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_with_WMM_ACM_on_BK(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
@@ -927,15 +853,14 @@
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BK, data_rates)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_with_WMM_ACM_on_BE(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
@@ -943,15 +868,14 @@
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BE, data_rates)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_with_WMM_ACM_on_VI(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
@@ -959,15 +883,14 @@
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_VI, data_rates)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_with_WMM_ACM_on_VO(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
@@ -975,15 +898,14 @@
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_VO, data_rates)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_with_WMM_ACM_on_BK_BE_VI(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
@@ -992,15 +914,14 @@
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BK, hostapd_constants.WMM_ACM_BE,
             hostapd_constants.WMM_ACM_VI, data_rates)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_with_WMM_ACM_on_BK_BE_VO(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
@@ -1009,15 +930,14 @@
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BK, hostapd_constants.WMM_ACM_BE,
             hostapd_constants.WMM_ACM_VO, data_rates)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_with_WMM_ACM_on_BK_VI_VO(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
@@ -1026,15 +946,14 @@
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BK, hostapd_constants.WMM_ACM_VI,
             hostapd_constants.WMM_ACM_VO, data_rates)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_with_WMM_ACM_on_BE_VI_VO(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
@@ -1043,15 +962,14 @@
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BE, hostapd_constants.WMM_ACM_VI,
             hostapd_constants.WMM_ACM_VO, data_rates)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_with_country_code(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
@@ -1060,14 +978,13 @@
             hostapd_constants.ENABLE_IEEE80211D,
             hostapd_constants.COUNTRY_STRING['ALL'],
             hostapd_constants.COUNTRY_CODE['UNITED_STATES'], data_rates)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            additional_ap_parameters=country_info)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 additional_ap_parameters=country_info)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_with_non_country_code(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
@@ -1076,69 +993,64 @@
             hostapd_constants.ENABLE_IEEE80211D,
             hostapd_constants.COUNTRY_STRING['ALL'],
             hostapd_constants.COUNTRY_CODE['NON_COUNTRY'], data_rates)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            additional_ap_parameters=country_info)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 additional_ap_parameters=country_info)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_with_hidden_ssid(self):
         data_rates = utils.merge_dicts(hostapd_constants.OFDM_DATA_RATES,
                                        hostapd_constants.OFDM_ONLY_BASIC_RATES)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            hidden=True,
-            additional_ap_parameters=data_rates)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 hidden=True,
+                 additional_ap_parameters=data_rates)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_with_vendor_ie_in_beacon_correct_length(self):
         data_rates = utils.merge_dicts(
             hostapd_constants.OFDM_DATA_RATES,
             hostapd_constants.OFDM_ONLY_BASIC_RATES,
             hostapd_constants.VENDOR_IE['correct_length_beacon'])
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            additional_ap_parameters=data_rates)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 additional_ap_parameters=data_rates)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_with_vendor_ie_in_beacon_zero_length(self):
         data_rates = utils.merge_dicts(
             hostapd_constants.OFDM_DATA_RATES,
             hostapd_constants.OFDM_ONLY_BASIC_RATES,
             hostapd_constants.VENDOR_IE['zero_length_beacon_without_data'])
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            additional_ap_parameters=data_rates)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 additional_ap_parameters=data_rates)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_with_vendor_ie_in_assoc_correct_length(self):
         data_rates = utils.merge_dicts(
             hostapd_constants.OFDM_DATA_RATES,
             hostapd_constants.OFDM_ONLY_BASIC_RATES,
             hostapd_constants.VENDOR_IE['correct_length_association_response'])
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            additional_ap_parameters=data_rates)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 additional_ap_parameters=data_rates)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_with_vendor_ie_in_assoc_zero_length(self):
         data_rates = utils.merge_dicts(
@@ -1147,320 +1059,295 @@
             hostapd_constants.VENDOR_IE['correct_length_association_response'],
             hostapd_constants.VENDOR_IE['zero_length_association_'
                                         'response_without_data'])
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            additional_ap_parameters=data_rates)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 additional_ap_parameters=data_rates)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_only_long_preamble(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            preamble=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 preamble=False)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_short_preamble(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            preamble=True)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 preamble=True)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_minimal_beacon_interval(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            beacon_interval=15)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 beacon_interval=15)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_maximum_beacon_interval(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            beacon_interval=1024)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 beacon_interval=1024)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_frag_threshold_430(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            frag_threshold=430)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 frag_threshold=430)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_rts_threshold_256(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            rts_threshold=256)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 rts_threshold=256)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_rts_256_frag_430(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            rts_threshold=256,
-            frag_threshold=430)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 rts_threshold=256,
+                 frag_threshold=430)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_high_dtim_low_beacon_interval(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            dtim_period=3,
-            beacon_interval=100)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 dtim_period=3,
+                 beacon_interval=100)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_low_dtim_high_beacon_interval(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            dtim_period=1,
-            beacon_interval=300)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 dtim_period=1,
+                 beacon_interval=300)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_with_WMM_with_default_values(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=hostapd_constants.
-            WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=hostapd_constants.
+                 WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_with_WMM_with_non_default_values(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
+        setup_ap(
             access_point=self.access_point,
-            client=self.dut,
             profile_name='whirlwind_11ag_legacy',
             channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
             ssid=self.open_network_2g['SSID'],
             force_wmm=True,
             additional_ap_parameters=hostapd_constants.WMM_NON_DEFAULT_PARAMS)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_with_WMM_ACM_on_BK(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BK)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_with_WMM_ACM_on_BE(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BE)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_with_WMM_ACM_on_VI(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_VI)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_with_WMM_ACM_on_VO(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_VO)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_with_WMM_ACM_on_BK_BE_VI(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BK, hostapd_constants.WMM_ACM_BE,
             hostapd_constants.WMM_ACM_VI)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_with_WMM_ACM_on_BK_BE_VO(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BK, hostapd_constants.WMM_ACM_BE,
             hostapd_constants.WMM_ACM_VO)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_with_WMM_ACM_on_BK_VI_VO(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BK, hostapd_constants.WMM_ACM_VI,
             hostapd_constants.WMM_ACM_VO)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_with_WMM_ACM_on_BE_VI_VO(self):
         wmm_acm_bits_enabled = utils.merge_dicts(
             hostapd_constants.WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
             hostapd_constants.WMM_ACM_BE, hostapd_constants.WMM_ACM_VI,
             hostapd_constants.WMM_ACM_VO)
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=wmm_acm_bits_enabled)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=wmm_acm_bits_enabled)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_with_country_code(self):
         country_info = utils.merge_dicts(
             hostapd_constants.ENABLE_IEEE80211D,
             hostapd_constants.COUNTRY_STRING['ALL'],
             hostapd_constants.COUNTRY_CODE['UNITED_STATES'])
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            additional_ap_parameters=country_info)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 additional_ap_parameters=country_info)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_with_non_country_code(self):
         country_info = utils.merge_dicts(
             hostapd_constants.ENABLE_IEEE80211D,
             hostapd_constants.COUNTRY_STRING['ALL'],
             hostapd_constants.COUNTRY_CODE['NON_COUNTRY'])
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            additional_ap_parameters=country_info)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 additional_ap_parameters=country_info)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_only_with_hidden_ssid(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            hidden=True)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 hidden=True)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_with_vendor_ie_in_beacon_correct_length(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['correct_length_beacon'])
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['correct_length_beacon'])
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11bg_with_vendor_ie_in_beacon_zero_length(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['zero_length_beacon_without_data'])
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['zero_length_beacon_without_data'])
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_with_vendor_ie_in_assoc_correct_length(self):
         data_rates = utils.merge_dicts(
             hostapd_constants.OFDM_DATA_RATES,
             hostapd_constants.OFDM_ONLY_BASIC_RATES,
             hostapd_constants.VENDOR_IE['correct_length_association_response'])
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            additional_ap_parameters=data_rates)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 additional_ap_parameters=data_rates)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_associate_11g_only_with_vendor_ie_in_assoc_zero_length(self):
         data_rates = utils.merge_dicts(
@@ -1469,155 +1356,143 @@
             hostapd_constants.VENDOR_IE['correct_length_association_response'],
             hostapd_constants.VENDOR_IE['zero_length_association_'
                                         'response_without_data'])
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ag_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_2g['SSID'],
-            additional_ap_parameters=data_rates)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ag_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_2g['SSID'],
+                 additional_ap_parameters=data_rates)
+        asserts.assert_true(self.dut.associate(self.open_network_2g['SSID']),
+                            'Failed to associate.')
 
     def test_minimum_ssid_length_2g_11n_20mhz(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_min_len_2g['SSID'])
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_min_len_2g['SSID'])
+        asserts.assert_true(
+            self.dut.associate(self.open_network_min_len_2g['SSID']),
+            'Failed to associate.')
 
     def test_minimum_ssid_length_5g_11ac_80mhz(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_min_len_5g['SSID'])
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_min_len_5g['SSID'])
+        asserts.assert_true(
+            self.dut.associate(self.open_network_min_len_5g['SSID']),
+            'Failed to associate.')
 
     def test_maximum_ssid_length_2g_11n_20mhz(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.open_network_max_len_2g['SSID'])
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.open_network_max_len_2g['SSID'])
+        asserts.assert_true(
+            self.dut.associate(self.open_network_max_len_2g['SSID']),
+            'Failed to associate.')
 
     def test_maximum_ssid_length_5g_11ac_80mhz(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.open_network_max_len_5g['SSID'])
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.open_network_max_len_5g['SSID'])
+        asserts.assert_true(
+            self.dut.associate(self.open_network_max_len_5g['SSID']),
+            'Failed to associate.')
 
     def test_ssid_with_UTF8_characters_2g_11n_20mhz(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.utf8_ssid_2g)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.utf8_ssid_2g)
+        asserts.assert_true(self.dut.associate(self.utf8_ssid_2g),
+                            'Failed to associate.')
 
     def test_ssid_with_UTF8_characters_5g_11ac_80mhz(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.utf8_ssid_5g)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.utf8_ssid_5g)
+        asserts.assert_true(self.dut.associate(self.utf8_ssid_5g),
+                            'Failed to associate.')
 
     def test_ssid_with_UTF8_characters_french_2g_11n_20mhz(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.utf8_ssid_2g_french)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.utf8_ssid_2g_french)
+        asserts.assert_true(self.dut.associate(self.utf8_ssid_2g_french),
+                            'Failed to associate.')
 
     def test_ssid_with_UTF8_characters_german_2g_11n_20mhz(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.utf8_ssid_2g_german)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.utf8_ssid_2g_german)
+        asserts.assert_true(self.dut.associate(self.utf8_ssid_2g_german),
+                            'Failed to associate.')
 
     def test_ssid_with_UTF8_characters_dutch_2g_11n_20mhz(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.utf8_ssid_2g_dutch)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.utf8_ssid_2g_dutch)
+        asserts.assert_true(self.dut.associate(self.utf8_ssid_2g_dutch),
+                            'Failed to associate.')
 
     def test_ssid_with_UTF8_characters_swedish_2g_11n_20mhz(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.utf8_ssid_2g_swedish)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.utf8_ssid_2g_swedish)
+        asserts.assert_true(self.dut.associate(self.utf8_ssid_2g_swedish),
+                            'Failed to associate.')
 
     def test_ssid_with_UTF8_characters_norwegian_2g_11n_20mhz(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.utf8_ssid_2g_norwegian)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.utf8_ssid_2g_norwegian)
+        asserts.assert_true(self.dut.associate(self.utf8_ssid_2g_norwegian),
+                            'Failed to associate.')
 
     def test_ssid_with_UTF8_characters_danish_2g_11n_20mhz(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.utf8_ssid_2g_danish)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.utf8_ssid_2g_danish)
+        asserts.assert_true(self.dut.associate(self.utf8_ssid_2g_danish),
+                            'Failed to associate.')
 
     def test_ssid_with_UTF8_characters_japanese_2g_11n_20mhz(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.utf8_ssid_2g_japanese)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.utf8_ssid_2g_japanese)
+        asserts.assert_true(self.dut.associate(self.utf8_ssid_2g_japanese),
+                            'Failed to associate.')
 
     def test_ssid_with_UTF8_characters_spanish_2g_11n_20mhz(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.utf8_ssid_2g_spanish)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.utf8_ssid_2g_spanish)
+        asserts.assert_true(self.dut.associate(self.utf8_ssid_2g_spanish),
+                            'Failed to associate.')
 
     def test_ssid_with_UTF8_characters_italian_2g_11n_20mhz(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.utf8_ssid_2g_italian)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.utf8_ssid_2g_italian)
+        asserts.assert_true(self.dut.associate(self.utf8_ssid_2g_italian),
+                            'Failed to associate.')
 
     def test_ssid_with_UTF8_characters_korean_2g_11n_20mhz(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name='whirlwind_11ab_legacy',
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.utf8_ssid_2g_korean)
+        setup_ap(access_point=self.access_point,
+                 profile_name='whirlwind_11ab_legacy',
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.utf8_ssid_2g_korean)
+
+        asserts.assert_true(self.dut.associate(self.utf8_ssid_2g_korean),
+                            'Failed to associate.')
diff --git a/acts_tests/tests/google/fuchsia/wlan/WlanRebootTest.py b/acts_tests/tests/google/fuchsia/wlan/WlanRebootTest.py
index e11e3fc..79c47e1 100644
--- a/acts_tests/tests/google/fuchsia/wlan/WlanRebootTest.py
+++ b/acts_tests/tests/google/fuchsia/wlan/WlanRebootTest.py
@@ -26,12 +26,12 @@
 from acts.controllers import iperf_client
 from acts.controllers import iperf_server
 from acts.controllers import pdu
+from acts.controllers.access_point import setup_ap
 from acts.controllers.ap_lib import hostapd_constants
 from acts.controllers.ap_lib.radvd import Radvd
 from acts.controllers.ap_lib import radvd_constants
 from acts.controllers.ap_lib.radvd_config import RadvdConfig
 from acts_contrib.test_utils.abstract_devices.wlan_device import create_wlan_device
-from acts_contrib.test_utils.abstract_devices.utils_lib import wlan_utils
 from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
 
 # Constants, for readibility
@@ -149,10 +149,6 @@
         for ad in self.android_devices:
             ad.droid.wakeLockAcquireBright()
             ad.droid.wakeUpNow()
-        for fd in self.fuchsia_devices:
-            fd.wlan_policy_lib.wlanCreateClientController()
-            fd.wlan_policy_lib.wlanStartClientConnections()
-        self.dut.clear_saved_networks()
         self.dut.disconnect()
         self.router_adv_daemon = None
         self.ssid = utils.rand_ascii_str(hostapd_constants.AP_SSID_LENGTH_2G)
@@ -162,9 +158,6 @@
         if self.router_adv_daemon:
             self.router_adv_daemon.stop()
             self.router_adv_daemon = None
-        self.dut.clear_saved_networks()
-        for fd in self.fuchsia_devices:
-            fd.wlan_policy_lib.wlanStopClientConnections()
         self.dut.disconnect()
         for ad in self.android_devices:
             ad.droid.wakeLockRelease()
@@ -187,15 +180,15 @@
         """
         # TODO(fxb/63719): Add varying AP parameters
         if band == BAND_2G:
-            wlan_utils.setup_ap(access_point=self.access_point,
-                                profile_name='whirlwind',
-                                channel=11,
-                                ssid=ssid)
+            setup_ap(access_point=self.access_point,
+                     profile_name='whirlwind',
+                     channel=11,
+                     ssid=ssid)
         elif band == BAND_5G:
-            wlan_utils.setup_ap(access_point=self.access_point,
-                                profile_name='whirlwind',
-                                channel=36,
-                                ssid=ssid)
+            setup_ap(access_point=self.access_point,
+                     profile_name='whirlwind',
+                     channel=36,
+                     ssid=ssid)
 
         if not ipv4:
             self.access_point.stop_dhcp()
@@ -216,37 +209,6 @@
 
         self.log.info('Network (SSID: %s) is up.' % ssid)
 
-    def save_and_connect(self, ssid):
-        """Associates the dut with the network running on the AP and saves
-        network to device.
-
-        Args:
-            ssid: string, ssid to connect DUT to
-
-        Raises:
-            EnvironmentError, if saving network fails
-            ConnectionError, if device fails to connect to network
-        """
-        self.dut.save_network(self.ssid)
-        self.dut.associate(self.ssid)
-
-    def setup_save_and_connect_to_network(self,
-                                          ssid,
-                                          band,
-                                          ipv4=True,
-                                          ipv6=False):
-        """Setup ap with passed params, saves network, and connects the dut with
-        the network running on the AP and saves network.
-
-        Args:
-            ssid: string, ssid to setup and connect to
-            band: string ('2g' or '5g') of band to setup.
-            ipv4: True if using ipv4 (dhcp), else False.
-            ipv6: True if using ipv6 (radvd), else False.
-        """
-        self.setup_ap(ssid, band, ipv4, ipv6)
-        self.save_and_connect(ssid)
-
     def wait_until_dut_gets_ipv4_addr(self, interface):
         """Checks if device has an ipv4 private address. Sleeps 1 second between
         retries.
@@ -444,8 +406,6 @@
         self.dut.wifi_toggle_state(True)
         for ad in self.android_devices:
             ad.droid.wakeUpNow()
-        for fd in self.fuchsia_devices:
-            fd.wlan_policy_lib.wlanCreateClientController()
 
     def wait_for_dut_network_connection(self, ssid):
         """Checks if device is connected to given network. Sleeps 1 second
@@ -586,11 +546,9 @@
         if band != BAND_2G and band != BAND_5G:
             raise ValueError('Invalid band: %s' % band)
 
-        self.setup_save_and_connect_to_network(self.ssid,
-                                               band,
-                                               ipv4=ipv4,
-                                               ipv6=ipv6)
-        self.wait_for_dut_network_connection(self.ssid)
+        self.setup_ap(self.ssid, band, ipv4, ipv6)
+        if not self.dut.associate(self.ssid):
+            raise EnvironmentError('Initial network connection failed.')
 
         dut_test_interface = self.iperf_client_on_dut.test_interface
         if ipv4:
diff --git a/acts_tests/tests/google/fuchsia/wlan/WlanRvrTest.py b/acts_tests/tests/google/fuchsia/wlan/WlanRvrTest.py
index 4eb07fc..a48817f 100644
--- a/acts_tests/tests/google/fuchsia/wlan/WlanRvrTest.py
+++ b/acts_tests/tests/google/fuchsia/wlan/WlanRvrTest.py
@@ -17,6 +17,7 @@
 
 from acts import asserts
 from acts import context
+from acts.controllers.access_point import setup_ap
 from acts.controllers.ap_lib import hostapd_constants
 from acts.controllers.ap_lib.radvd import Radvd
 from acts.controllers.ap_lib import radvd_constants
@@ -24,8 +25,6 @@
 from acts.controllers.ap_lib.hostapd_security import Security
 from acts.controllers.attenuator import get_attenuators_for_device
 from acts.controllers.iperf_server import IPerfResult
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils import associate
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils import setup_ap
 from acts_contrib.test_utils.abstract_devices.wlan_device import create_wlan_device
 from acts_contrib.test_utils.abstract_devices.wlan_device_lib.AbstractDeviceWlanDeviceBaseTest import AbstractDeviceWlanDeviceBaseTest
 from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
@@ -276,10 +275,9 @@
             associate_counter = 0
             associate_max_attempts = 3
             while associate_counter < associate_max_attempts:
-                if associate(self.dut,
-                             ssid,
-                             password,
-                             check_connectivity=False):
+                if self.dut.associate(ssid,
+                                      target_pwd=password,
+                                      check_connectivity=False):
                     break
                 else:
                     associate_counter += 1
@@ -432,10 +430,9 @@
                 if not associated:
                     self.log.info('Trying to associate at relative '
                                   'attenuation of %s db' % step)
-                    if associate(self.dut,
-                                 ssid,
-                                 password,
-                                 check_connectivity=False):
+                    if self.dut.associate(ssid,
+                                          target_pwd=password,
+                                          check_connectivity=False):
                         associated = True
                         self.log.info('Successfully associated.')
                     else:
diff --git a/acts_tests/tests/google/fuchsia/wlan/WlanScanTest.py b/acts_tests/tests/google/fuchsia/wlan/WlanScanTest.py
index eca08cb..e9f085f 100644
--- a/acts_tests/tests/google/fuchsia/wlan/WlanScanTest.py
+++ b/acts_tests/tests/google/fuchsia/wlan/WlanScanTest.py
@@ -47,6 +47,8 @@
         super().setup_class()
 
         self.start_access_point = False
+        for fd in self.fuchsia_devices:
+            fd.configure_wlan()
         if "AccessPoint" in self.user_params:
             # This section sets up the config that could be sent to the AP if
             # the AP is needed. The reasoning is since ACTS already connects
@@ -171,8 +173,8 @@
         else:
             # the response indicates an error - log and raise failure
             raise signals.TestFailure("Aborting test - Connect call failed "
-                                      "with error: %s"
-                                      % connection_response.get("error"))
+                                      "with error: %s" %
+                                      connection_response.get("error"))
 
     def scan_while_connected(self, wlan_network_params, fd):
         """ Connects to as specified network and initiates a scan
@@ -188,8 +190,7 @@
             target_pwd = wlan_network_params['password']
 
         connection_response = fd.wlan_lib.wlanConnectToNetwork(
-            target_ssid,
-            target_pwd)
+            target_ssid, target_pwd)
         self.check_connect_response(connection_response)
         self.basic_scan_request(fd)
 
@@ -210,8 +211,7 @@
         else:
             # the response indicates an error - log and raise failure
             raise signals.TestFailure("Aborting test - scan failed with "
-                                      "error: %s"
-                                      % scan_response.get("error"))
+                                      "error: %s" % scan_response.get("error"))
 
         self.log.info("scan contained %d results", len(scan_results))
 
@@ -220,13 +220,13 @@
 
         if len(scan_results) > 0:
             raise signals.TestPass(details="",
-                                   extras={"Scan time":"%d" % total_time_ms})
+                                   extras={"Scan time": "%d" % total_time_ms})
         else:
             raise signals.TestFailure("Scan failed or did not "
                                       "find any networks")
 
-
     """Tests"""
+
     def test_basic_scan_request(self):
         """Verify a general scan trigger returns at least one result"""
         for fd in self.fuchsia_devices:
@@ -247,4 +247,3 @@
     def test_scan_while_connected_wpa2_network_5g(self):
         for fd in self.fuchsia_devices:
             self.scan_while_connected(self.wpa2_network_5g, fd)
-
diff --git a/acts_tests/tests/google/fuchsia/wlan/WlanSecurityComplianceABGTest.py b/acts_tests/tests/google/fuchsia/wlan/WlanSecurityComplianceABGTest.py
index b0aa12f..f3e47b5 100644
--- a/acts_tests/tests/google/fuchsia/wlan/WlanSecurityComplianceABGTest.py
+++ b/acts_tests/tests/google/fuchsia/wlan/WlanSecurityComplianceABGTest.py
@@ -15,14 +15,14 @@
 #   limitations under the License.
 import re
 
+from acts import asserts
 from functools import wraps
 
+from acts.controllers.access_point import setup_ap
 from acts.controllers.ap_lib import hostapd_constants
 from acts.controllers.ap_lib.hostapd_security import Security
 from acts_contrib.test_utils.abstract_devices.wlan_device import create_wlan_device
 from acts_contrib.test_utils.abstract_devices.wlan_device_lib.AbstractDeviceWlanDeviceBaseTest import AbstractDeviceWlanDeviceBaseTest
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils import validate_setup_ap_and_associate
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_policy_utils import setup_policy_tests, restore_state
 from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
 from acts.utils import rand_ascii_str
 from acts.utils import rand_hex_str
@@ -178,15 +178,6 @@
         self.security_profile = None
         self.client_password = None
 
-        # These tests will either be performed by connecting through the policy
-        # layer or directly below at a core/driver layer.
-        self.association_mechanism = 'drivers'
-        if 'association_mechanism' in self.user_params:
-            if self.user_params['association_mechanism'] == 'policy':
-                self.association_mechanism = 'policy'
-                # Preserve state of device before tests and set up device.
-                self.preexisting_state = setup_policy_tests(
-                    self.fuchsia_devices)
         self.access_point.stop_all_aps()
 
     def setup_test(self):
@@ -202,741 +193,835 @@
                 ad.droid.wakeLockRelease()
                 ad.droid.goToSleepNow()
         self.dut.turn_location_off_and_scan_toggle_off()
-        self.dut.disconnect(association_mechanism=self.association_mechanism)
+        self.dut.disconnect()
         self.dut.reset_wifi()
         self.access_point.stop_all_aps()
 
-    def teardown_class(self):
-        if self.association_mechanism == 'policy':
-            restore_state(self.fuchsia_devices, self.preexisting_state)
-
     def on_fail(self, test_name, begin_time):
         super().on_fail(test_name, begin_time)
         self.access_point.stop_all_aps()
 
     @create_security_profile
     def test_associate_11a_sec_open_wep_5_chars_ptk_none(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False,
-            additional_ap_parameters=hostapd_constants.WEP_AUTH['open'])
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False,
+                 additional_ap_parameters=hostapd_constants.WEP_AUTH['open'])
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_sec_open_wep_13_chars_ptk_none(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False,
-            additional_ap_parameters=hostapd_constants.WEP_AUTH['open'])
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False,
+                 additional_ap_parameters=hostapd_constants.WEP_AUTH['open'])
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_sec_open_wep_10_hex_ptk_none(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False,
-            additional_ap_parameters=hostapd_constants.WEP_AUTH['open'])
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False,
+                 additional_ap_parameters=hostapd_constants.WEP_AUTH['open'])
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_sec_open_wep_26_hex_ptk_none(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False,
-            additional_ap_parameters=hostapd_constants.WEP_AUTH['open'])
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False,
+                 additional_ap_parameters=hostapd_constants.WEP_AUTH['open'])
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_sec_shared_wep_5_chars_ptk_none(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False,
-            additional_ap_parameters=hostapd_constants.WEP_AUTH['shared'])
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False,
+                 additional_ap_parameters=hostapd_constants.WEP_AUTH['shared'])
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_sec_shared_wep_13_chars_ptk_none(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False,
-            additional_ap_parameters=hostapd_constants.WEP_AUTH['shared'])
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False,
+                 additional_ap_parameters=hostapd_constants.WEP_AUTH['shared'])
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_sec_shared_wep_10_hex_ptk_none(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False,
-            additional_ap_parameters=hostapd_constants.WEP_AUTH['shared'])
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False,
+                 additional_ap_parameters=hostapd_constants.WEP_AUTH['shared'])
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_sec_shared_wep_26_hex_ptk_none(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False,
-            additional_ap_parameters=hostapd_constants.WEP_AUTH['shared'])
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False,
+                 additional_ap_parameters=hostapd_constants.WEP_AUTH['shared'])
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_sec_wpa_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_sec_wpa_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_sec_wpa_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_password_sec_wpa_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_password_sec_wpa_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_password_sec_wpa_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_psk_sec_wpa_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_psk_sec_wpa_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_psk_sec_wpa_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_frag_430_sec_wpa_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_frag_430_sec_wpa_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_frag_430_sec_wpa_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_rts_256_sec_wpa_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_rts_256_sec_wpa_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_rts_256_sec_wpa_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_rts_256_frag_430_sec_wpa_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_high_dtim_low_beacon_int_sec_wpa_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            dtim_period=hostapd_constants.HIGH_DTIM,
-            beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 dtim_period=hostapd_constants.HIGH_DTIM,
+                 beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_low_dtim_high_beacon_int_sec_wpa_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            dtim_period=hostapd_constants.LOW_DTIM,
-            beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 dtim_period=hostapd_constants.LOW_DTIM,
+                 beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_with_WMM_with_default_values_sec_wpa_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=hostapd_constants.
-            WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=hostapd_constants.
+                 WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_with_vendor_ie_in_beacon_correct_length_sec_wpa_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['correct_length_beacon'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['correct_length_beacon'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_with_vendor_ie_in_beacon_zero_length_sec_wpa_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['zero_length_beacon_without_data'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['zero_length_beacon_without_data'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_with_vendor_ie_in_beacon_similar_to_wpa_ie_sec_wpa_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['simliar_to_wpa'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['simliar_to_wpa'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_sec_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_sec_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_password_sec_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_password_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_password_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_psk_sec_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_psk_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_psk_sec_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_frag_430_sec_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_frag_430_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_frag_430_sec_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_rts_256_sec_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_rts_256_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_rts_256_sec_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_rts_256_frag_430_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_high_dtim_low_beacon_int_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            dtim_period=hostapd_constants.HIGH_DTIM,
-            beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 dtim_period=hostapd_constants.HIGH_DTIM,
+                 beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_low_dtim_high_beacon_int_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            dtim_period=hostapd_constants.LOW_DTIM,
-            beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 dtim_period=hostapd_constants.LOW_DTIM,
+                 beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_with_WMM_with_default_values_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
+        setup_ap(
             access_point=self.access_point,
-            client=self.dut,
             profile_name=AP_11ABG_PROFILE_NAME,
             channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
             ssid=self.secure_network_5g['SSID'],
@@ -945,345 +1030,394 @@
             security=self.security_profile,
             password=self.client_password)
 
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
+
     @create_security_profile
     def test_associate_11a_with_vendor_ie_in_beacon_correct_length_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['correct_length_beacon'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['correct_length_beacon'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_with_vendor_ie_in_beacon_zero_length_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['zero_length_beacon_without_data'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['zero_length_beacon_without_data'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_with_vendor_ie_in_beacon_similar_to_wpa_ie_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['simliar_to_wpa'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['simliar_to_wpa'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_sec_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_sec_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_max_length_password_sec_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_max_length_password_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_max_length_password_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_max_length_psk_sec_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_max_length_psk_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_max_length_psk_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_frag_430_sec_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_frag_430_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_frag_430_sec_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_rts_256_sec_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_rts_256_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_rts_256_sec_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_rts_256_frag_430_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_high_dtim_low_beacon_int_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            dtim_period=hostapd_constants.HIGH_DTIM,
-            beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 dtim_period=hostapd_constants.HIGH_DTIM,
+                 beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_low_dtim_high_beacon_int_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            dtim_period=hostapd_constants.LOW_DTIM,
-            beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 dtim_period=hostapd_constants.LOW_DTIM,
+                 beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_with_WMM_with_default_values_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
+        setup_ap(
             access_point=self.access_point,
-            client=self.dut,
             profile_name=AP_11ABG_PROFILE_NAME,
             channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
             ssid=self.secure_network_5g['SSID'],
@@ -1293,330 +1427,379 @@
             pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
             password=self.client_password)
 
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
+
     @create_security_profile
     def test_associate_11a_pmf_with_vendor_ie_in_beacon_correct_length_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['correct_length_beacon'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['correct_length_beacon'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_with_vendor_ie_in_beacon_zero_length_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['zero_length_beacon_without_data'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['zero_length_beacon_without_data'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_pmf_with_vendor_ie_in_beacon_similar_to_wpa_ie_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['simliar_to_wpa'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['simliar_to_wpa'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_sec_wpa_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_sec_wpa_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_password_sec_wpa_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_password_sec_wpa_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_password_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_psk_sec_wpa_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_psk_sec_wpa_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_psk_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_frag_430_sec_wpa_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_frag_430_sec_wpa_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_frag_430_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_rts_256_sec_wpa_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_rts_256_sec_wpa_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_rts_256_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_rts_256_frag_430_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_high_dtim_low_beacon_int_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            dtim_period=hostapd_constants.HIGH_DTIM,
-            beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 dtim_period=hostapd_constants.HIGH_DTIM,
+                 beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_low_dtim_high_beacon_int_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            dtim_period=hostapd_constants.LOW_DTIM,
-            beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 dtim_period=hostapd_constants.LOW_DTIM,
+                 beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_with_WMM_with_default_values_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
+        setup_ap(
             access_point=self.access_point,
-            client=self.dut,
             profile_name=AP_11ABG_PROFILE_NAME,
             channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
             ssid=self.secure_network_5g['SSID'],
@@ -1625,675 +1808,774 @@
             security=self.security_profile,
             password=self.client_password)
 
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
+
     @create_security_profile
     def test_associate_11a_with_vendor_ie_in_beacon_correct_length_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['correct_length_beacon'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['correct_length_beacon'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_with_vendor_ie_in_beacon_zero_length_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['zero_length_beacon_without_data'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['zero_length_beacon_without_data'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_with_vendor_ie_in_beacon_similar_to_wpa_ie_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['simliar_to_wpa'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['simliar_to_wpa'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_sec_wpa3_sae_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_sec_wpa3_sae_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_password_sec_wpa3_sae_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_max_length_password_sec_wpa3_sae_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_frag_430_sec_wpa3_sae_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_frag_430_sec_wpa3_sae_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_rts_256_sec_wpa3_sae_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_rts_256_sec_wpa3_sae_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_rts_256_frag_430_sec_wpa3_sae_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_high_dtim_low_beacon_int_sec_wpa3_sae_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            dtim_period=hostapd_constants.HIGH_DTIM,
-            beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 dtim_period=hostapd_constants.HIGH_DTIM,
+                 beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_low_dtim_high_beacon_int_sec_wpa3_sae_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            dtim_period=hostapd_constants.LOW_DTIM,
-            beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 dtim_period=hostapd_constants.LOW_DTIM,
+                 beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_with_WMM_with_default_values_sec_wpa3_sae_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=hostapd_constants.
-            WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=hostapd_constants.
+                 WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_with_vendor_ie_in_beacon_correct_length_sec_wpa3_sae_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['correct_length_beacon'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['correct_length_beacon'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_with_vendor_ie_in_beacon_zero_length_sec_wpa3_sae_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['zero_length_beacon_without_data'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['zero_length_beacon_without_data'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11a_with_vendor_ie_in_beacon_similar_to_wpa_ie_sec_wpa3_sae_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
-            ssid=self.secure_network_5g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['simliar_to_wpa'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_5G,
+                 ssid=self.secure_network_5g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['simliar_to_wpa'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_5g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_sec_open_wep_5_chars_ptk_none(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False,
-            additional_ap_parameters=hostapd_constants.WEP_AUTH['open'])
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False,
+                 additional_ap_parameters=hostapd_constants.WEP_AUTH['open'])
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_sec_open_wep_13_chars_ptk_none(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False,
-            additional_ap_parameters=hostapd_constants.WEP_AUTH['open'])
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False,
+                 additional_ap_parameters=hostapd_constants.WEP_AUTH['open'])
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_sec_open_wep_10_hex_ptk_none(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False,
-            additional_ap_parameters=hostapd_constants.WEP_AUTH['open'])
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False,
+                 additional_ap_parameters=hostapd_constants.WEP_AUTH['open'])
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_sec_open_wep_26_hex_ptk_none(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False,
-            additional_ap_parameters=hostapd_constants.WEP_AUTH['open'])
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False,
+                 additional_ap_parameters=hostapd_constants.WEP_AUTH['open'])
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_sec_shared_wep_5_chars_ptk_none(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False,
-            additional_ap_parameters=hostapd_constants.WEP_AUTH['shared'])
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False,
+                 additional_ap_parameters=hostapd_constants.WEP_AUTH['shared'])
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_sec_shared_wep_13_chars_ptk_none(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False,
-            additional_ap_parameters=hostapd_constants.WEP_AUTH['shared'])
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False,
+                 additional_ap_parameters=hostapd_constants.WEP_AUTH['shared'])
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_sec_shared_wep_10_hex_ptk_none(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False,
-            additional_ap_parameters=hostapd_constants.WEP_AUTH['shared'])
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False,
+                 additional_ap_parameters=hostapd_constants.WEP_AUTH['shared'])
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_sec_shared_wep_26_hex_ptk_none(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False,
-            additional_ap_parameters=hostapd_constants.WEP_AUTH['shared'])
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False,
+                 additional_ap_parameters=hostapd_constants.WEP_AUTH['shared'])
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_sec_wpa_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_sec_wpa_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_sec_wpa_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_password_sec_wpa_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_password_sec_wpa_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_password_sec_wpa_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_psk_sec_wpa_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_psk_sec_wpa_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_psk_sec_wpa_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_frag_430_sec_wpa_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_frag_430_sec_wpa_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_frag_430_sec_wpa_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_rts_256_sec_wpa_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_rts_256_sec_wpa_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_rts_256_sec_wpa_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_rts_256_frag_430_sec_wpa_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_high_dtim_low_beacon_int_sec_wpa_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            dtim_period=hostapd_constants.HIGH_DTIM,
-            beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 dtim_period=hostapd_constants.HIGH_DTIM,
+                 beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_low_dtim_high_beacon_int_sec_wpa_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            dtim_period=hostapd_constants.LOW_DTIM,
-            beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 dtim_period=hostapd_constants.LOW_DTIM,
+                 beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_with_WMM_with_default_values_sec_wpa_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
+        setup_ap(
             access_point=self.access_point,
-            client=self.dut,
             profile_name=AP_11ABG_PROFILE_NAME,
             channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
             ssid=self.secure_network_2g['SSID'],
@@ -2302,326 +2584,375 @@
             security=self.security_profile,
             password=self.client_password)
 
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
+
     @create_security_profile
     def test_associate_11bg_with_vendor_ie_in_beacon_correct_length_sec_wpa_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['correct_length_beacon'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['correct_length_beacon'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_with_vendor_ie_in_beacon_zero_length_sec_wpa_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['zero_length_beacon_without_data'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['zero_length_beacon_without_data'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_with_vendor_ie_in_beacon_similar_to_wpa_ie_sec_wpa_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['simliar_to_wpa'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['simliar_to_wpa'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_sec_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_sec_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_password_sec_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_password_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_password_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_psk_sec_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_psk_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_psk_sec_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_frag_430_sec_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_frag_430_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_frag_430_sec_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_rts_256_sec_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_rts_256_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_rts_256_sec_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_rts_256_frag_430_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_high_dtim_low_beacon_int_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            dtim_period=hostapd_constants.HIGH_DTIM,
-            beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 dtim_period=hostapd_constants.HIGH_DTIM,
+                 beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_low_dtim_high_beacon_int_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            dtim_period=hostapd_constants.HIGH_DTIM,
-            beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 dtim_period=hostapd_constants.HIGH_DTIM,
+                 beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_with_WMM_with_default_values_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
+        setup_ap(
             access_point=self.access_point,
-            client=self.dut,
             profile_name=AP_11ABG_PROFILE_NAME,
             channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
             ssid=self.secure_network_2g['SSID'],
@@ -2630,347 +2961,396 @@
             security=self.security_profile,
             password=self.client_password)
 
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
+
     @create_security_profile
     def test_associate_11bg_with_vendor_ie_in_beacon_correct_length_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['correct_length_beacon'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['correct_length_beacon'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_with_vendor_ie_in_beacon_zero_length_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['zero_length_beacon_without_data'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['zero_length_beacon_without_data'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_with_vendor_ie_in_beacon_similar_to_wpa_ie_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['simliar_to_wpa'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['simliar_to_wpa'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_sec_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_sec_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_max_length_password_sec_wpa2_psk_ptk_tkip(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_max_length_password_sec_wpa2_psk_ptk_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_max_length_password_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_max_length_psk_sec_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_max_length_psk_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_max_length_psk_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_frag_430_sec_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_frag_430_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_frag_430_sec_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_rts_256_sec_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_rts_256_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_rts_256_sec_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_rts_256_frag_430_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_high_dtim_low_beacon_int_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            dtim_period=hostapd_constants.HIGH_DTIM,
-            beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 dtim_period=hostapd_constants.HIGH_DTIM,
+                 beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_low_dtim_high_beacon_int_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            dtim_period=hostapd_constants.HIGH_DTIM,
-            beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 dtim_period=hostapd_constants.HIGH_DTIM,
+                 beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_with_WMM_with_default_values_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
+        setup_ap(
             access_point=self.access_point,
-            client=self.dut,
             profile_name=AP_11ABG_PROFILE_NAME,
             channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
             ssid=self.secure_network_2g['SSID'],
@@ -2980,561 +3360,644 @@
             pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
             password=self.client_password)
 
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
+
     @create_security_profile
     def test_associate_11bg_pmf_with_vendor_ie_in_beacon_correct_length_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['correct_length_beacon'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['correct_length_beacon'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_with_vendor_ie_in_beacon_zero_length_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['zero_length_beacon_without_data'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['zero_length_beacon_without_data'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_pmf_with_vendor_ie_in_beacon_similar_to_wpa_ie_sec_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['simliar_to_wpa'],
-            security=self.security_profile,
-            pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['simliar_to_wpa'],
+                 security=self.security_profile,
+                 pmf_support=hostapd_constants.PMF_SUPPORT_REQUIRED,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_sec_wpa_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_sec_wpa_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_password_sec_wpa_wpa2_psk_ptk_tkip(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_password_sec_wpa_wpa2_psk_ptk_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_password_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_psk_sec_wpa_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_psk_sec_wpa_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_psk_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_frag_430_sec_wpa_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_frag_430_sec_wpa_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_frag_430_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_rts_256_sec_wpa_wpa2_psk_ptk_tkip(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_rts_256_sec_wpa_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_rts_256_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_rts_256_frag_430_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_high_dtim_low_beacon_int_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            dtim_period=hostapd_constants.HIGH_DTIM,
-            beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 dtim_period=hostapd_constants.HIGH_DTIM,
+                 beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_low_dtim_high_beacon_int_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            dtim_period=hostapd_constants.LOW_DTIM,
-            beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 dtim_period=hostapd_constants.LOW_DTIM,
+                 beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_with_WMM_with_default_values_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            force_wmm=True,
-            additional_ap_parameters=hostapd_constants.
-            WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 force_wmm=True,
+                 additional_ap_parameters=hostapd_constants.
+                 WMM_PHYS_11A_11G_11N_11AC_DEFAULT_PARAMS,
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_with_vendor_ie_in_beacon_correct_length_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['correct_length_beacon'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['correct_length_beacon'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_with_vendor_ie_in_beacon_zero_length_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['zero_length_beacon_without_data'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['zero_length_beacon_without_data'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_with_vendor_ie_in_beacon_similar_to_wpa_ie_sec_wpa_wpa2_psk_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['simliar_to_wpa'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['simliar_to_wpa'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_sec_wpa3_sae_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_sec_wpa3_sae_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_password_sec_wpa3_sae_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_max_length_password_sec_wpa3_sae_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_frag_430_sec_wpa3_sae_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_frag_430_sec_wpa3_sae_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_rts_256_sec_wpa3_sae_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_rts_256_sec_wpa3_sae_ptk_tkip_or_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_rts_256_frag_430_sec_wpa3_sae_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            rts_threshold=256,
-            frag_threshold=430,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 rts_threshold=256,
+                 frag_threshold=430,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_high_dtim_low_beacon_int_sec_wpa3_sae_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            dtim_period=hostapd_constants.HIGH_DTIM,
-            beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 dtim_period=hostapd_constants.HIGH_DTIM,
+                 beacon_interval=hostapd_constants.LOW_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_low_dtim_high_beacon_int_sec_wpa3_sae_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            dtim_period=hostapd_constants.LOW_DTIM,
-            beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 dtim_period=hostapd_constants.LOW_DTIM,
+                 beacon_interval=hostapd_constants.HIGH_BEACON_INTERVAL,
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_with_WMM_with_default_values_sec_wpa3_sae_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
+        setup_ap(
             access_point=self.access_point,
-            client=self.dut,
             profile_name=AP_11ABG_PROFILE_NAME,
             channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
             ssid=self.secure_network_2g['SSID'],
@@ -3543,202 +4006,239 @@
             security=self.security_profile,
             password=self.client_password)
 
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
+
     @create_security_profile
     def test_associate_11bg_with_vendor_ie_in_beacon_correct_length_sec_wpa3_sae_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['correct_length_beacon'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['correct_length_beacon'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_with_vendor_ie_in_beacon_zero_length_sec_wpa3_sae_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['zero_length_beacon_without_data'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['zero_length_beacon_without_data'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_11bg_with_vendor_ie_in_beacon_similar_to_wpa_ie_sec_wpa3_sae_ptk_tkip_or_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            additional_ap_parameters=hostapd_constants.
-            VENDOR_IE['simliar_to_wpa'],
-            security=self.security_profile,
-            password=self.client_password)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 additional_ap_parameters=hostapd_constants.
+                 VENDOR_IE['simliar_to_wpa'],
+                 security=self.security_profile,
+                 password=self.client_password)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_utf8_password_11bg_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_utf8_french_password_11bg_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_utf8_german_password_11bg_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_utf8_dutch_password_11bg_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_utf8_swedish_password_11bg_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_utf8_norwegian_password_11bg_sec_wpa2_psk_ptk_ccmp(
             self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_utf8_danish_password_11bg_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_utf8_japanese_password_11bg_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_utf8_spanish_password_11bg_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_utf8_italian_password_11bg_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
 
     @create_security_profile
     def test_associate_utf8_korean_password_11bg_sec_wpa2_psk_ptk_ccmp(self):
-        validate_setup_ap_and_associate(
-            association_mechanism=self.association_mechanism,
-            access_point=self.access_point,
-            client=self.dut,
-            profile_name=AP_11ABG_PROFILE_NAME,
-            channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
-            ssid=self.secure_network_2g['SSID'],
-            security=self.security_profile,
-            target_security=self.target_security,
-            password=self.client_password,
-            force_wmm=False)
+        setup_ap(access_point=self.access_point,
+                 profile_name=AP_11ABG_PROFILE_NAME,
+                 channel=hostapd_constants.AP_DEFAULT_CHANNEL_2G,
+                 ssid=self.secure_network_2g['SSID'],
+                 security=self.security_profile,
+                 password=self.client_password,
+                 force_wmm=False)
+
+        asserts.assert_true(
+            self.dut.associate(self.secure_network_2g['SSID'],
+                               target_security=self.target_security,
+                               target_pwd=self.client_password),
+            'Failed to associate.')
diff --git a/acts_tests/tests/google/fuchsia/wlan/WlanStatusTest.py b/acts_tests/tests/google/fuchsia/wlan/WlanStatusTest.py
index 84a8805..0228940 100644
--- a/acts_tests/tests/google/fuchsia/wlan/WlanStatusTest.py
+++ b/acts_tests/tests/google/fuchsia/wlan/WlanStatusTest.py
@@ -30,7 +30,8 @@
     def setup_class(self):
         super().setup_class()
         for fd in self.fuchsia_devices:
-            fd.wlan_policy_lib.wlanCreateClientController()
+            fd.configure_wlan(association_mechanism='policy',
+                              preserve_saved_networks=True)
 
     def on_fail(self, test_name, begin_time):
         for fd in self.fuchsia_devices:
@@ -43,7 +44,8 @@
             try:
                 if fd.device.hard_reboot_on_fail:
                     fd.hard_power_cycle(self.pdu_devices)
-                    fd.wlan_policy_lib.wlanCreateClientController()
+                    fd.configure_wlan(association_mechanism='policy',
+                                      preserve_saved_networks=True)
             except AttributeError:
                 pass
 
@@ -54,7 +56,7 @@
         an error when queried for status.
         """
         for fd in self.fuchsia_devices:
-            fd.wlan_policy_lib.wlanStopClientConnections()
+            fd.deconfigure_wlan()
 
             status = fd.wlan_lib.wlanStatus()
             self.log.debug(status)
@@ -72,7 +74,8 @@
         status.
         """
         for fd in self.fuchsia_devices:
-            fd.wlan_policy_lib.wlanStartClientConnections()
+            fd.configure_wlan(association_mechanism='policy',
+                              preserve_saved_networks=True)
 
             status = fd.wlan_lib.wlanStatus()
             self.log.debug(status)
diff --git a/acts_tests/tests/google/fuchsia/wlan_policy/HiddenNetworksTest.py b/acts_tests/tests/google/fuchsia/wlan_policy/HiddenNetworksTest.py
index ad911ca..98d8a19 100644
--- a/acts_tests/tests/google/fuchsia/wlan_policy/HiddenNetworksTest.py
+++ b/acts_tests/tests/google/fuchsia/wlan_policy/HiddenNetworksTest.py
@@ -14,10 +14,9 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 from acts import signals
+from acts.controllers.access_point import setup_ap
 from acts.controllers.ap_lib import hostapd_constants
 from acts.controllers.ap_lib import hostapd_security
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils import setup_ap
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_policy_utils import reboot_device, restore_state, save_network, setup_policy_tests
 from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
 from acts.utils import rand_ascii_str
 import time
@@ -26,8 +25,8 @@
 # tests because the device should probabilistically perform active scans for
 # hidden networks. Multiple scans are necessary to verify a very low chance of
 # random failure.
-TIME_WAIT_FOR_CONNECT = 45
-TIME_ATTEMPT_SCANS = 60
+TIME_WAIT_FOR_CONNECT = 90
+TIME_ATTEMPT_SCANS = 90
 
 CONNECTIONS_ENABLED = "ConnectionsEnabled"
 CONNECTIONS_DISABLED = "ConnectionsDisabled"
@@ -63,42 +62,18 @@
 
         if len(self.fuchsia_devices) < 1:
             raise EnvironmentError("No Fuchsia devices found.")
-        # Save the existing saved networks before we remove them for tests
-        # And remember whether client connections have started
-        self.preexisting_state = setup_policy_tests(self.fuchsia_devices)
+        for fd in self.fuchsia_devices:
+            fd.configure_wlan(association_mechanism='policy',
+                              preserve_saved_networks=True)
 
     def setup_test(self):
         for fd in self.fuchsia_devices:
-            # Set new update listener so that the next test can always get the
-            # most recent udpdate immediately.
-            new_listener_result = fd.wlan_policy_lib.wlanSetNewListener()
-            if new_listener_result["error"] != None:
-                self.log.warn(
-                    "Error occurred initializing a new update listener for the facade, may"
-                    "cause errors in updates for tests: %s" %
-                    new_listener_result["error"])
-
-            resultRemove = fd.wlan_policy_lib.wlanRemoveAllNetworks()
-            if resultRemove["error"] != None:
-                self.log.error(
-                    "Error occurred when deleting all saved networks in test setup: %s"
-                    % resultRemove["error"])
+            if not fd.wlan_policy_controller.remove_all_networks():
                 raise EnvironmentError(
                     "Failed to remove all networks in setup")
 
-            resultStart = fd.wlan_policy_lib.wlanStartClientConnections()
-            if resultStart["error"] != None:
-                self.log.error(
-                    "Error occurred when starting client connections in test setup: %s"
-                    % resultStart["error"])
-                raise EnvironmentError(
-                    "Failed to start client connections in setup")
-
     def teardown_class(self):
         self.access_point.stop_all_aps()
-        for fd in self.fuchsia_devices:
-            # Put back the networks that were saved before tests began.
-            restore_state(self.fuchsia_devices, self.preexisting_state)
 
     def test_scan_hidden_networks(self):
         # Scan a few times and check that we see the hidden networks in the
@@ -108,11 +83,13 @@
             # A hidden network must be saved to be found in scan results.
             # Stop client connections to not trigger a connect when saving,
             # which would interfere with requested scans.
-            fd.wlan_policy_lib.wlanStopClientConnections()
-            if not save_network(fd, self.hidden_ssid, self.hidden_security,
-                                self.hidden_password):
+            fd.wlan_policy_controller.stop_client_connections()
+            if not fd.wlan_policy_controller.save_network(
+                    self.hidden_ssid,
+                    self.hidden_security,
+                    password=self.hidden_password):
                 raise EnvironmentError("Failed to save network")
-            fd.wlan_policy_lib.wlanStartClientConnections()
+            fd.wlan_policy_controller.start_client_connections()
             start_time = time.time()
             num_performed_scans = 0
 
@@ -120,10 +97,9 @@
                 num_performed_scans = num_performed_scans + 1
                 scan_result = fd.wlan_policy_lib.wlanScanForNetworks()
                 if scan_result["error"] != None:
-                    self.log.error(
-                        "Failed to scan for networks with error %s" %
-                        scan_result["error"])
-                    raise EnvironmentError("Failed to scan")
+                    self.log.warn("Failed to scan for networks with error %s" %
+                                  scan_result["error"])
+                    continue
                 else:
                     scans = scan_result["result"]
                 if self.hidden_ssid in scans:
@@ -146,18 +122,21 @@
         for fd in self.fuchsia_devices:
             # Test that we will auto connect without anything being triggered by
             # saving a new network.
-            fd.wlan_policy_lib.wlanStopClientConnections()
+            fd.wlan_policy_controller.stop_client_connections()
 
             # Save the network.
-            if not save_network(fd, self.hidden_ssid, self.hidden_security,
-                                self.hidden_password):
+            if not fd.wlan_policy_controller.save_network(
+                    self.hidden_ssid,
+                    self.hidden_security,
+                    password=self.hidden_password):
                 raise EnvironmentError("Failed to save network")
 
             # Reboot the device and check that it auto connects.
-            reboot_device(fd)
-            if not fd.wait_for_connect(self.hidden_ssid,
-                                       self.hidden_security,
-                                       timeout=TIME_WAIT_FOR_CONNECT):
+            fd.reboot()
+            if not fd.wlan_policy_controller.wait_for_connect(
+                    self.hidden_ssid,
+                    self.hidden_security,
+                    timeout=TIME_WAIT_FOR_CONNECT):
                 raise signals.TestFailure("Failed to connect to network")
 
     def test_auto_connect_hidden_on_save(self):
@@ -165,18 +144,21 @@
             anything, the device will connect to the hidden network that was
             just saved. """
         for fd in self.fuchsia_devices:
-            if not fd.wait_for_no_connections():
+            if not fd.wlan_policy_controller.wait_for_no_connections():
                 self.log.info(
                     "Failed to get into a disconnected state to start the test"
                 )
                 raise EnvironmentError("Failed to disconnect all")
 
             # Save the network and make sure that we see the device auto connect to it.
-            if not save_network(fd, self.hidden_ssid, self.hidden_security,
-                                self.hidden_password):
+            if not fd.wlan_policy_controller.save_network(
+                    self.hidden_ssid,
+                    self.hidden_security,
+                    password=self.hidden_password):
                 raise EnvironmentError("Failed to save network")
 
-            if not fd.wait_for_connect(self.hidden_ssid,
-                                       self.hidden_security,
-                                       timeout=TIME_WAIT_FOR_CONNECT):
+            if not fd.wlan_policy_controller.wait_for_connect(
+                    self.hidden_ssid,
+                    self.hidden_security,
+                    timeout=TIME_WAIT_FOR_CONNECT):
                 raise signals.TestFailure("Failed to connect to network")
diff --git a/acts_tests/tests/google/fuchsia/wlan_policy/PolicyScanTest.py b/acts_tests/tests/google/fuchsia/wlan_policy/PolicyScanTest.py
index beb3fc2..f1a0d05 100644
--- a/acts_tests/tests/google/fuchsia/wlan_policy/PolicyScanTest.py
+++ b/acts_tests/tests/google/fuchsia/wlan_policy/PolicyScanTest.py
@@ -36,8 +36,8 @@
         if len(self.fuchsia_devices) < 1:
             raise signals.TestFailure("No fuchsia devices found.")
         for fd in self.fuchsia_devices:
-            # Initialize the Policy client controller for each Fuchsia device
-            fd.wlan_policy_lib.wlanCreateClientController()
+            fd.configure_wlan(association_mechanism='policy',
+                              preserve_saved_networks=True)
         if len(self.access_points) < 1:
             raise signals.TestFailure("No access points found.")
         # Prepare the AP
diff --git a/acts_tests/tests/google/fuchsia/wlan_policy/SavedNetworksTest.py b/acts_tests/tests/google/fuchsia/wlan_policy/SavedNetworksTest.py
index 1a8bc42..8b256c3 100644
--- a/acts_tests/tests/google/fuchsia/wlan_policy/SavedNetworksTest.py
+++ b/acts_tests/tests/google/fuchsia/wlan_policy/SavedNetworksTest.py
@@ -19,12 +19,11 @@
 """
 
 from acts import signals
+from acts.controllers.access_point import setup_ap
 from acts.controllers.ap_lib import hostapd_ap_preset
 from acts.controllers.ap_lib import hostapd_constants
 from acts.controllers.ap_lib import hostapd_security
 from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils import setup_ap
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_policy_utils import reboot_device, restore_state, save_network, setup_policy_tests
 from acts.utils import rand_ascii_str, rand_hex_str, timeout
 import requests
 import time
@@ -61,74 +60,22 @@
         # Keep track of whether we have started an access point in a test
         if len(self.fuchsia_devices) < 1:
             raise EnvironmentError("No Fuchsia devices found.")
-        # Save the existing saved networks before we remove them for tests
-        # And remember whether client connections have started
-        self.preserved_state = setup_policy_tests(self.fuchsia_devices)
-        self.preexisting_client_connections_state = {}
         for fd in self.fuchsia_devices:
-            fd.wlan_policy_lib.wlanSetNewListener()
-            result_update = fd.wlan_policy_lib.wlanGetUpdate()
-            if result_update.get("result") != None and result_update.get(
-                    "result").get("state") != None:
-                self.preexisting_client_connections_state[
-                    fd] = result_update.get("result").get("state")
-            else:
-                self.log.warn(
-                    "Failed to get update; test will not start or "
-                    "stop client connections at the end of the test.")
-            fd.wlan_policy_lib.wlanStartClientConnections()
+            fd.configure_wlan(association_mechanism='policy',
+                              preserve_saved_networks=True)
 
     def setup_test(self):
         for fd in self.fuchsia_devices:
-            # Set new update listener so that the next test can always get the
-            # most recent udpdate immediately.
-            new_listener_result = fd.wlan_policy_lib.wlanSetNewListener()
-            if new_listener_result.get("error") != None:
-                self.log.warn(
-                    "Error occurred initializing a new update listener for the facade, may"
-                    "cause errors in updates for tests: %s" %
-                    new_listener_result["error"])
-
-            resultRemove = fd.wlan_policy_lib.wlanRemoveAllNetworks()
-            if resultRemove.get("error") != None:
-                self.log.error(
-                    "Error occurred when deleting all saved networks in test setup: %s"
-                    % resultRemove["error"])
+            if not fd.wlan_policy_controller.remove_all_networks():
                 raise EnvironmentError(
                     "Failed to remove all networks in setup")
         self.access_points[0].stop_all_aps()
 
     def teardown_class(self):
         for fd in self.fuchsia_devices:
-            # Start/stop client connections based on state before tests began.
-            if fd in self.preexisting_client_connections_state:
-                starting_state = self.preexisting_client_connections_state[fd]
-                if starting_state == CONNECTIONS_ENABLED:
-                    fd.wlan_policy_lib.wlanStartClientConnections()
-                elif starting_state == CONNECTIONS_DISABLED:
-                    fd.wlan_policy_lib.wlanStopClientConnections()
-                else:
-                    self.log.info(
-                        "Unrecognized client connections starting state: %s" %
-                        starting_state)
-            # Remove any networks remaining from tests
-            fd.wlan_policy_lib.wlanRemoveAllNetworks()
-        # Put back the networks that were saved before tests began.
-        restore_state(self.fuchsia_devices, self.preserved_state)
+            fd.wlan_policy_controller.remove_all_networks()
         self.access_points[0].stop_all_aps()
 
-    def get_saved_networks(self, fd):
-        """ Get the saved networks or fail the test if there is an error getting the networks
-        Args:
-            fd: the Fuchsia device to get saved networks from
-        """
-        result_get = fd.wlan_policy_lib.wlanGetSavedNetworks()
-        if result_get.get("error") != None:
-            self.log.info("Failed to get saved networks with error: %s" %
-                          result_get["error"])
-            raise signals.TestFailure('Failed to get saved networks')
-        return result_get["result"]
-
     def save_bad_network(self, fd, ssid, security_type, password=""):
         """ Saves a network as specified on the given device and verify that we
         Args:
@@ -139,9 +86,8 @@
             password: The password to save for the network. Empty string represents
                     no password, and PSK should be provided as 64 character hex string.
         """
-        result_save = fd.wlan_policy_lib.wlanSaveNetwork(
-            ssid, security_type, password)
-        if result_save.get("error") == None:
+        if not fd.wlan_policy_controller.save_network(
+                ssid, security_type, password=password):
             self.log.info(
                 "Attempting to save bad network config %s did not give an error"
                 % ssid)
@@ -181,9 +127,11 @@
                             no duplicates in expected networks.
         """
         actual_networks = list(
-            map(self.lower_case_network, self.get_saved_networks(fd)))
+            map(self.lower_case_network,
+                fd.wlan_policy_controller.get_saved_networks()))
         expected_networks = list(
-            map(self.lower_case_network, self.get_saved_networks(fd)))
+            map(self.lower_case_network,
+                fd.wlan_policy_controller.get_saved_networks()))
 
         if len(actual_networks) != len(expected_networks):
             self.log.info(
@@ -208,37 +156,6 @@
             raise signals.TestFailure("Network is missing credential type")
         {"ssid": network["ssid"], "security_type": network["security_type"]}
 
-    def remove_network(self, fd, ssid, security_type, password=""):
-        """ Remove the given network on the device and check that it was
-            successfully removed.
-        Args:
-            fd: The Fuchsia device to run on.
-            ssid: The name of the network to remove.
-            security_type: The network's security, ie "none", "wep", "wpa", "wpa2",
-                        or "wpa3"
-            password: The password of the network to remove, or "" if none.
-        """
-        # Expected networks are the networks on the device before remove, minus
-        # the removed network.
-        expected_networks = self.get_saved_networks(fd)
-        expected_networks.remove(ssid)
-        expected_networks.sort()
-        result_remove = fd.wlan_policy_lib.wlanRemoveNetwork(
-            ssid, security_type, password)
-        if result_remove.get("error") != None:
-            self.log.info("Failed to remove network with error: %s",
-                          result_remove["error"])
-            raise signals.TestFailure("Failed to remove saved network")
-
-        saved_networks = get_saved_networks(fd)
-        saved_networks.sort()
-        if expected_networks != saved_networks:
-            self.log.info(
-                "Failed to remove network %s. Actual networks: %s, expected"
-                " networks"
-                ": %s" % (ssid, saved_networks, expected_networks))
-            raise signals.TestFailure("Failed to remove network")
-
     def save_and_check_network(self, ssid, security_type, password=""):
         """ Perform a test for saving, getting, and removing a single network on each
             device.
@@ -250,7 +167,8 @@
                     hexadecimal characters and none should be an empty string.
         """
         for fd in self.fuchsia_devices:
-            if not save_network(fd, ssid, security_type, password):
+            if not fd.wlan_policy_controller.save_network(
+                    ssid, security_type, password=password):
                 raise signals.TestFailure("Failed to save network")
             self.check_get_saved_network(fd, ssid, security_type,
                                          self.credentialType(password),
@@ -302,38 +220,6 @@
         return net_id["ssid"] == ssid and net_id["type_"].upper(
         ) == security_type.upper()
 
-    def wait_for_no_connections(self, fd):
-        """ Waits to see that there are no existing connections the device. This is
-            to ensure a good starting point for tests that look for a connection.
-        Args:
-            fd: The fuchsia device to run on.
-        """
-        start_time = time.time()
-        while True:
-            time_left = TIME_WAIT_FOR_DISCONNECT - (time.time() - start_time)
-            if time_left <= 0:
-                raise signals.TestFailure("Time out")
-            try:
-                update = fd.wlan_policy_lib.wlanGetUpdate(timeout=time_left)
-            except requests.exceptions.Timeout:
-                raise signals.TestFailure(
-                    "Timed out getting status update while waiting for all"
-                    " connections to end.")
-            if update.get("error") != None:
-                raise signals.TestFailure("Failed to get status update")
-            # If any network is connected or being connected to, wait for them
-            # to disconnect.
-            has_connection = False
-            for network in update["result"]["networks"]:
-                if network['state'].upper() in [
-                        STATE_CONNECTED.upper(),
-                        STATE_CONNECTING.upper()
-                ]:
-                    has_connection = True
-                    break
-            if not has_connection:
-                break
-
     """Tests"""
 
     def test_open_network_with_password(self):
@@ -380,20 +266,22 @@
         security = WPA2
         password = rand_ascii_str(10)
         for fd in self.fuchsia_devices:
-            if not save_network(fd, ssid, security, password):
+            if not fd.wlan_policy_controller.save_network(
+                    ssid, security, password=password):
                 raise signals.TestFailure("Failed to save network")
             # Reboot the device. The network should be persistently saved
             # before the command is completed.
-            reboot_device(fd)
+            fd.reboot()
             self.check_get_saved_network(fd, ssid, security, PASSWORD,
                                          password)
 
     def test_same_ssid_diff_security(self):
         for fd in self.fuchsia_devices:
-            saved_networks = self.get_saved_networks(fd)
+            saved_networks = fd.wlan_policy_controller.get_saved_networks()
             ssid = rand_ascii_str(19)
             password = rand_ascii_str(12)
-            if not save_network(fd, ssid, WPA2, password):
+            if not fd.wlan_policy_controller.save_network(
+                    ssid, WPA2, password=password):
                 raise signals.TestFailure("Failed to save network")
             saved_networks.append({
                 "ssid": ssid,
@@ -401,7 +289,7 @@
                 "credential_type": PASSWORD,
                 "credential_value": password
             })
-            if not save_network(fd, ssid, SECURITY_NONE):
+            if not fd.wlan_policy_controller.save_network(ssid, SECURITY_NONE):
                 raise signals.TestFailure("Failed to save network")
             saved_networks.append({
                 "ssid": ssid,
@@ -409,10 +297,10 @@
                 "credential_type": CREDENTIAL_TYPE_NONE,
                 "credential_value": CREDENTIAL_VALUE_NONE
             })
-            actual_networks = self.get_saved_networks(fd)
+            actual_networks = fd.wlan_policy_controller.get_saved_networks()
             # Both should be saved and present in network store since the have
             # different security types and therefore different network identifiers.
-            self.check_saved_networks(fd, saved_networks)
+            self.check_saved_networks(fd, actual_networks)
 
     def test_remove_disconnects(self):
         # If we save, connect to, then remove the network while still connected
@@ -425,36 +313,14 @@
         self.start_ap(ssid, security, password)
 
         for fd in self.fuchsia_devices:
-            self.wait_for_no_connections(fd)
+            fd.wlan_policy_controller.wait_for_no_connections()
 
-            result_save = fd.wlan_policy_lib.wlanSaveNetwork(
-                ssid, security, password)
-            if result_save.get("error") != None:
+            if not fd.wlan_policy_controller.save_and_connect:
                 raise signals.TestFailure(
-                    "Error occurred attempting to save network: %s" %
-                    result_save["error"])
-            # If we fail to send connect command, proceed with test anyway
-            # because saving the network should trigger a connect
-            result_connect = fd.wlan_policy_lib.wlanConnect(ssid, security)
-            if result_connect.get("error") != None:
-                self.log.info(
-                    "Error occurred while attempting to send connect call: %s. "
-                    "This test will rely on autoconnect." %
-                    result_connect["error"])
-            if not fd.wait_for_connect(
-                    ssid, security, timeout=TIME_WAIT_FOR_CONNECT):
-                raise signals.TestFailure("Failed to connect to network")
+                    "Failed to saved and connect to network")
 
-            result_remove = fd.wlan_policy_lib.wlanRemoveNetwork(
-                ssid, security, password)
-            if result_remove.get("error") != None:
-                raise signals.TestFailure(
-                    "Error occurred attempting to remove network")
-            if not fd.wait_for_disconnect(ssid,
-                                          security,
-                                          "Disconnected",
-                                          "ConnectionStopped",
-                                          timeout=TIME_WAIT_FOR_DISCONNECT):
+            if not fd.wlan_policy_controller.remove_all_networks_and_wait_for_no_connections(
+            ):
                 raise signals.TestFailure(
                     "Failed to disconnect from removed network")
 
@@ -463,16 +329,15 @@
         ssid = rand_ascii_str(10)
         self.start_ap(ssid, None)
         for fd in self.fuchsia_devices:
-            self.wait_for_no_connections(fd)
+            fd.wlan_policy_controller.wait_for_no_connections()
 
             # Save the network and make sure that we see the device auto connect to it.
             security = SECURITY_NONE
             password = CREDENTIAL_VALUE_NONE
-            result_save = fd.wlan_policy_lib.wlanSaveNetwork(
-                ssid, security, password)
-            if result_save.get("error") != None:
+            if not fd.wlan_policy_controller.save_network(
+                    ssid, security, password=password):
                 raise signals.TestFailure("Failed to save network")
-            if not fd.wait_for_connect(
+            if not fd.wlan_policy_controller.wait_for_connect(
                     ssid, security, timeout=TIME_WAIT_FOR_CONNECT):
                 raise signals.TestFailure("Failed to connect to network")
 
@@ -483,13 +348,12 @@
         password = rand_ascii_str(10)
         self.start_ap(ssid, security, password)
         for fd in self.fuchsia_devices:
-            self.wait_for_no_connections(fd)
+            fd.wlan_policy_controller.wait_for_no_connections()
 
             # Save the network and make sure that we see the device auto connect to it.
-            result_save = fd.wlan_policy_lib.wlanSaveNetwork(
-                ssid, security, password)
-            if result_save.get("error") != None:
+            if not fd.wlan_policy_controller.save_network(
+                    ssid, security, password=password):
                 raise signals.TestFailure("Failed to save network")
-            if not fd.wait_for_connect(
+            if not fd.wlan_policy_controller.wait_for_connect(
                     ssid, security, timeout=TIME_WAIT_FOR_CONNECT):
                 raise signals.TestFailure("Failed to connect to network")
diff --git a/acts_tests/tests/google/fuchsia/wlan_policy/StartStopClientConnectionsTest.py b/acts_tests/tests/google/fuchsia/wlan_policy/StartStopClientConnectionsTest.py
index 5ca70f4..3f585a2 100644
--- a/acts_tests/tests/google/fuchsia/wlan_policy/StartStopClientConnectionsTest.py
+++ b/acts_tests/tests/google/fuchsia/wlan_policy/StartStopClientConnectionsTest.py
@@ -15,10 +15,9 @@
 #   limitations under the License.
 
 from acts import signals
+from acts.controllers.access_point import setup_ap
 from acts.controllers.ap_lib import hostapd_constants
 from acts.controllers.ap_lib import hostapd_security
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_utils import setup_ap
-from acts_contrib.test_utils.abstract_devices.utils_lib.wlan_policy_utils import setup_policy_tests, restore_state, save_network, start_connections, stop_connections
 from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
 from acts.utils import rand_ascii_str
 
@@ -58,32 +57,18 @@
 
         if len(self.fuchsia_devices) < 1:
             raise EnvironmentError("No Fuchsia devices found.")
-        # Save the existing saved networks before we remove them for tests
-        # And remember whether client connections have started
-        self.preexisting_state = setup_policy_tests(self.fuchsia_devices)
+        for fd in self.fuchsia_devices:
+            fd.configure_wlan(association_mechanism='policy',
+                              preserve_saved_networks=True)
 
     def setup_test(self):
         for fd in self.fuchsia_devices:
-            # Set new update listener so that the next test can always get the
-            # most recent udpdate immediately.
-            new_listener_result = fd.wlan_policy_lib.wlanSetNewListener()
-            if new_listener_result.get("error") != None:
-                self.log.warn(
-                    "Error occurred initializing a new update listener for the facade, may"
-                    "cause errors in updates for tests: %s" %
-                    new_listener_result.get("error"))
-
-            resultRemove = fd.wlan_policy_lib.wlanRemoveAllNetworks()
-            if resultRemove.get("error") != None:
+            if not fd.wlan_policy_controller.remove_all_networks():
                 raise EnvironmentError(
-                    "Failed to remove all networks in setup: %s" %
-                    resultRemove.get("error"))
+                    "Failed to remove all networks in setup")
 
     def teardown_class(self):
         self.access_point.stop_all_aps()
-        for fd in self.fuchsia_devices:
-            # Put back the networks that were saved before tests began.
-            restore_state(self.fuchsia_devices, self.preexisting_state)
 
     def connect_and_validate(self, fd, ssid, security_type, expected_response):
         """ Sends a connect request to the device and verifies we get a response
@@ -92,8 +77,8 @@
             connect request, or if we don't get the expected connect response."""
         result_connect = fd.wlan_policy_lib.wlanConnect(ssid, security_type)
         if result_connect.get("error") != None:
-            logging.error("Error occurred requesting a connection: %s" %
-                          result_connect.get("error"))
+            self.log.error("Error occurred requesting a connection: %s" %
+                           result_connect.get("error"))
             raise EnvironmentError("Failed to send connect request")
         response = result_connect.get("result")
         if response != expected_response:
@@ -105,7 +90,7 @@
 
     def test_stop_client_connections_update(self):
         for fd in self.fuchsia_devices:
-            if not stop_connections(fd):
+            if not fd.wlan_policy_controller.stop_client_connections():
                 raise EnvironmentError("Failed to stop client connecions")
 
             # Check that the most recent update says that the device is not
@@ -121,14 +106,14 @@
             if result_update.get("result") != expected_update:
                 self.log.error(
                     "Most recent status update does not indicate client "
-                    "connections have stopped. Expected update: %s\nActual update:"
-                    % (expected_update, result_update))
+                    "connections have stopped. Expected update: %s Actual update: %s"
+                    % (expected_update, result_update.get('result')))
                 raise signals.TestFailure(
                     "Incorrect update after stopping client connections")
 
     def test_start_client_connections_update(self):
         for fd in self.fuchsia_devices:
-            if not start_connections(fd):
+            if not fd.wlan_policy_controller.start_client_connections():
                 raise EnvironmentError("Failed to start client connecions")
 
             # Check that the most recent update says that the device is not
@@ -153,13 +138,13 @@
         # Test that if we turn client connections off, our requests to connect
         # are rejected.
         for fd in self.fuchsia_devices:
-            if not stop_connections(fd):
+            if not fd.wlan_policy_controller.stop_client_connections():
                 raise EnvironmentError("Failed to stop client connecions")
 
             # Save the network, otherwise connecting may fail because the
             # network is not saved instead of client connections being off
-            if not save_network(fd, self.ssid, self.security_type,
-                                self.password):
+            if not fd.wlan_policy_controller.save_network(
+                    self.ssid, self.security_type, password=self.password):
                 raise EnvironmentError("Failed to save network")
             expected_response = "RejectedIncompatibleMode"
             self.connect_and_validate(fd, self.ssid, self.security_type,
@@ -170,24 +155,26 @@
         # and if we turn of client connections the device will disconnect.
         for fd in self.fuchsia_devices:
             # Start client connections and check that we can
-            if not save_network(fd, self.ssid, self.security_type,
-                                self.password):
+            if not fd.wlan_policy_controller.save_network(
+                    self.ssid, self.security_type, password=self.password):
                 raise EnvironmentError("Failed to save network")
-            if not start_connections(fd):
+            if not fd.wlan_policy_controller.start_client_connections():
                 raise EnvironmentError("Failed to start client connections")
 
             expected_response = "Acknowledged"
             self.connect_and_validate(fd, self.ssid, self.security_type,
                                       expected_response)
 
-            if not fd.wait_for_connect(self.ssid, self.security_type):
+            if not fd.wlan_policy_controller.wait_for_connect(
+                    self.ssid, self.security_type):
                 raise signals.TestFailure(
                     "Failed to connect after starting client connections")
 
             # Stop client connections again and check that we disconnect
-            if not stop_connections(fd):
+            if not fd.wlan_policy_controller.stop_client_connections():
                 raise EnvironmentError("Failed to stop client connecions")
-            if not fd.wait_for_disconnect(self.ssid, self.security_type,
-                                          DISCONNECTED, CONNECTION_STOPPED):
+            if not fd.wlan_policy_controller.wait_for_disconnect(
+                    self.ssid, self.security_type, DISCONNECTED,
+                    CONNECTION_STOPPED):
                 raise signals.TestFailure(
                     "Failed to disconnect after client connections stopped")