diff --git a/tests/cts/net/src/android/net/wifi/rtt/cts/TestBase.java b/tests/cts/net/src/android/net/wifi/rtt/cts/TestBase.java
index b235d96..adbe0f6 100644
--- a/tests/cts/net/src/android/net/wifi/rtt/cts/TestBase.java
+++ b/tests/cts/net/src/android/net/wifi/rtt/cts/TestBase.java
@@ -21,7 +21,9 @@
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.location.LocationManager;
+import android.net.NetworkInfo;
 import android.net.wifi.ScanResult;
+import android.net.wifi.SupplicantState;
 import android.net.wifi.WifiManager;
 import android.net.wifi.rtt.RangingResult;
 import android.net.wifi.rtt.RangingResultCallback;
@@ -43,9 +45,8 @@
 public class TestBase extends AndroidTestCase {
     protected static final String TAG = "WifiRttCtsTests";
 
-    // The SSID of the test AP which supports IEEE 802.11mc
-    // TODO b/74518964: finalize correct method to refer to an AP in the test lab
-    static final String SSID_OF_TEST_AP = "standalone_rtt";
+    // wait for Wi-Fi to enable and/or connect
+    private static final int WAIT_FOR_WIFI_ENABLE_SECS = 10;
 
     // wait for Wi-Fi RTT to become available
     private static final int WAIT_FOR_RTT_CHANGE_SECS = 10;
@@ -58,6 +59,10 @@
     private LocationManager mLocationManager;
     private WifiManager.WifiLock mWifiLock;
 
+    protected IntentFilter mRttIntent;
+    protected IntentFilter mWifiStateIntent;
+    protected IntentFilter mWifiConnectedIntent;
+
     private final HandlerThread mHandlerThread = new HandlerThread("SingleDeviceTest");
     protected final Executor mExecutor;
     {
@@ -93,22 +98,43 @@
                 Context.WIFI_RTT_RANGING_SERVICE);
         assertNotNull("Wi-Fi RTT Manager", mWifiRttManager);
 
+        mRttIntent = new IntentFilter();
+        mRttIntent.addAction(WifiRttManager.ACTION_WIFI_RTT_STATE_CHANGED);
+
+        mWifiStateIntent = new IntentFilter();
+        mWifiStateIntent.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
+
+        mWifiConnectedIntent = new IntentFilter();
+        mWifiConnectedIntent.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
+
         mWifiManager = (WifiManager) getContext().getSystemService(Context.WIFI_SERVICE);
         assertNotNull("Wi-Fi Manager", mWifiManager);
         mWifiLock = mWifiManager.createWifiLock(TAG);
         mWifiLock.acquire();
+        assertTrue("Location scans must be enabled", mWifiManager.isScanAlwaysAvailable());
         if (!mWifiManager.isWifiEnabled()) {
             mWifiManager.setWifiEnabled(true);
+            WifiEnableBroadcastReceiver receiver = new WifiEnableBroadcastReceiver(true);
+            mContext.registerReceiver(receiver, mWifiStateIntent);
+            receiver.waitForDesiredState();
+            mContext.unregisterReceiver(receiver);
         }
 
-        IntentFilter intentFilter = new IntentFilter();
-        intentFilter.addAction(WifiRttManager.ACTION_WIFI_RTT_STATE_CHANGED);
-        WifiRttBroadcastReceiver receiver = new WifiRttBroadcastReceiver();
-        mContext.registerReceiver(receiver, intentFilter);
+        if (!mWifiManager.getConnectionInfo().getSupplicantState().equals(
+                SupplicantState.COMPLETED)) {
+            WifiConnectedBroadcastReceiver receiver = new WifiConnectedBroadcastReceiver();
+            mContext.registerReceiver(receiver, mWifiConnectedIntent);
+            receiver.waitForConnected();
+            mContext.unregisterReceiver(receiver);
+        }
+
         if (!mWifiRttManager.isAvailable()) {
+            WifiRttBroadcastReceiver receiver = new WifiRttBroadcastReceiver();
+            mContext.registerReceiver(receiver, mRttIntent);
             assertTrue("Timeout waiting for Wi-Fi RTT to change status",
                     receiver.waitForStateChange());
             assertTrue("Wi-Fi RTT is not available (should be)", mWifiRttManager.isAvailable());
+            mContext.unregisterReceiver(receiver);
         }
     }
 
@@ -122,33 +148,77 @@
         super.tearDown();
     }
 
-    class WifiRttBroadcastReceiver extends BroadcastReceiver {
+    private class SyncBroadcastReceiver extends BroadcastReceiver {
         private CountDownLatch mBlocker = new CountDownLatch(1);
+        private String mAction;
+        private int mTimeout;
+
+        SyncBroadcastReceiver(String action, int timeout) {
+            mAction = action;
+            mTimeout = timeout;
+        }
 
         @Override
         public void onReceive(Context context, Intent intent) {
-            if (WifiRttManager.ACTION_WIFI_RTT_STATE_CHANGED.equals(intent.getAction())) {
+            if (mAction.equals(intent.getAction())) {
                 mBlocker.countDown();
             }
         }
 
         boolean waitForStateChange() throws InterruptedException {
-            return mBlocker.await(WAIT_FOR_RTT_CHANGE_SECS, TimeUnit.SECONDS);
+            return mBlocker.await(mTimeout, TimeUnit.SECONDS);
+        }
+    };
+
+    class WifiEnableBroadcastReceiver extends BroadcastReceiver {
+        private CountDownLatch mBlocker = new CountDownLatch(1);
+        private boolean mDesiredState;
+
+        WifiEnableBroadcastReceiver(boolean desiredState) {
+            mDesiredState = desiredState;
+        }
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(intent.getAction())) {
+                if (mWifiManager.isWifiEnabled() == mDesiredState) {
+                    mBlocker.countDown();
+                }
+            }
+        }
+
+        boolean waitForDesiredState() throws InterruptedException {
+            return mBlocker.await(WAIT_FOR_WIFI_ENABLE_SECS, TimeUnit.SECONDS);
         }
     }
 
-    class WifiScansBroadcastReceiver extends BroadcastReceiver {
+    class WifiConnectedBroadcastReceiver extends BroadcastReceiver {
         private CountDownLatch mBlocker = new CountDownLatch(1);
 
         @Override
         public void onReceive(Context context, Intent intent) {
-            if (WifiManager.SCAN_RESULTS_AVAILABLE_ACTION.equals(intent.getAction())) {
-                mBlocker.countDown();
+            if (WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(intent.getAction())) {
+                NetworkInfo ni = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
+                if (ni.getState() == NetworkInfo.State.CONNECTED) {
+                    mBlocker.countDown();
+                }
             }
         }
 
-        boolean waitForStateChange() throws InterruptedException {
-            return mBlocker.await(WAIT_FOR_SCAN_RESULTS_SECS, TimeUnit.SECONDS);
+        boolean waitForConnected() throws InterruptedException {
+            return mBlocker.await(WAIT_FOR_WIFI_ENABLE_SECS, TimeUnit.SECONDS);
+        }
+    }
+
+    class WifiRttBroadcastReceiver extends SyncBroadcastReceiver {
+        WifiRttBroadcastReceiver() {
+            super(WifiRttManager.ACTION_WIFI_RTT_STATE_CHANGED, WAIT_FOR_RTT_CHANGE_SECS);
+        }
+    }
+
+    class WifiScansBroadcastReceiver extends SyncBroadcastReceiver {
+        WifiScansBroadcastReceiver() {
+            super(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION, WAIT_FOR_SCAN_RESULTS_SECS);
         }
     }
 
@@ -217,10 +287,10 @@
      *
      * Returns null if test AP is not found in the specified number of scans.
      *
-     * @param ssid The SSID of the test AP
+     * @param bssid The BSSID of the test AP
      * @param maxScanRetries Maximum number of scans retries (in addition to first scan).
      */
-    protected ScanResult scanForTestAp(String ssid, int maxScanRetries)
+    protected ScanResult scanForTestAp(String bssid, int maxScanRetries)
             throws InterruptedException {
         int scanCount = 0;
         while (scanCount <= maxScanRetries) {
@@ -228,7 +298,7 @@
                 if (!scanResult.is80211mcResponder()) {
                     continue;
                 }
-                if (!ssid.equals(scanResult.SSID)) {
+                if (!bssid.equals(scanResult.BSSID)) {
                     continue;
                 }
 
diff --git a/tests/cts/net/src/android/net/wifi/rtt/cts/WifiRttTest.java b/tests/cts/net/src/android/net/wifi/rtt/cts/WifiRttTest.java
index 0e6b306..983aa5e 100644
--- a/tests/cts/net/src/android/net/wifi/rtt/cts/WifiRttTest.java
+++ b/tests/cts/net/src/android/net/wifi/rtt/cts/WifiRttTest.java
@@ -16,11 +16,9 @@
 
 package android.net.wifi.rtt.cts;
 
-import android.content.IntentFilter;
 import android.net.wifi.ScanResult;
 import android.net.wifi.rtt.RangingRequest;
 import android.net.wifi.rtt.RangingResult;
-import android.net.wifi.rtt.WifiRttManager;
 
 import com.android.compatibility.common.util.DeviceReportLog;
 import com.android.compatibility.common.util.ResultType;
@@ -62,10 +60,18 @@
             return;
         }
 
+        // Find the associated AP: get BSSID and disable Wi-Fi
+        String bssid = mWifiManager.getConnectionInfo().getBSSID();
+        assertNotNull("Null BSSID - must be associated!", bssid);
+        assertTrue("Cannot disable Wi-Fi (to disassociate)", mWifiManager.setWifiEnabled(false));
+        WifiEnableBroadcastReceiver receiver = new WifiEnableBroadcastReceiver(false);
+        mContext.registerReceiver(receiver, mWifiStateIntent);
+        receiver.waitForDesiredState();
+        mContext.unregisterReceiver(receiver);
+
         // Scan for IEEE 802.11mc supporting APs
-        ScanResult testAp = scanForTestAp(SSID_OF_TEST_AP,
-                MAX_NUM_SCAN_RETRIES_SEARCHING_FOR_IEEE80211MC_AP);
-        assertTrue("Cannot find test AP", testAp != null);
+        ScanResult testAp = scanForTestAp(bssid, MAX_NUM_SCAN_RETRIES_SEARCHING_FOR_IEEE80211MC_AP);
+        assertTrue("Cannot find test AP: bssid=" + bssid, testAp != null);
 
         // Perform RTT operations
         RangingRequest request = new RangingRequest.Builder().addAccessPoint(testAp).build();
@@ -150,26 +156,25 @@
             return;
         }
 
-        IntentFilter intentFilter = new IntentFilter();
-        intentFilter.addAction(WifiRttManager.ACTION_WIFI_RTT_STATE_CHANGED);
-
         // 1. Disable Wi-Fi
         WifiRttBroadcastReceiver receiver1 = new WifiRttBroadcastReceiver();
-        mContext.registerReceiver(receiver1, intentFilter);
+        mContext.registerReceiver(receiver1, mRttIntent);
         mWifiManager.setWifiEnabled(false);
 
         assertTrue("Timeout waiting for Wi-Fi RTT to change status",
                 receiver1.waitForStateChange());
         assertFalse("Wi-Fi RTT is available (should not be)", mWifiRttManager.isAvailable());
+        mContext.unregisterReceiver(receiver1);
 
         // 2. Enable Wi-Fi
         WifiRttBroadcastReceiver receiver2 = new WifiRttBroadcastReceiver();
-        mContext.registerReceiver(receiver2, intentFilter);
+        mContext.registerReceiver(receiver2, mRttIntent);
         mWifiManager.setWifiEnabled(true);
 
         assertTrue("Timeout waiting for Wi-Fi RTT to change status",
                 receiver2.waitForStateChange());
         assertTrue("Wi-Fi RTT is not available (should be)", mWifiRttManager.isAvailable());
+        mContext.unregisterReceiver(receiver2);
     }
 
     /**