diff --git a/tests/cts/net/src/android/net/cts/IpConfigurationTest.java b/tests/cts/net/src/android/net/cts/IpConfigurationTest.java
index 21be351..c6bc077 100644
--- a/tests/cts/net/src/android/net/cts/IpConfigurationTest.java
+++ b/tests/cts/net/src/android/net/cts/IpConfigurationTest.java
@@ -16,6 +16,8 @@
 
 package android.net.cts;
 
+import static com.android.testutils.ParcelUtilsKt.assertParcelSane;
+
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 
@@ -37,13 +39,6 @@
 
 @RunWith(AndroidJUnit4.class)
 public final class IpConfigurationTest {
-    private static final int TYPE_IPASSIGNMENT_STATIC = 0;
-    private static final int TYPE_IPASSIGNMENT_DHCP   = 1;
-
-    private static final int TYPE_PROXY_SETTINGS_NONE   = 0;
-    private static final int TYPE_PROXY_SETTINGS_STATIC = 1;
-    private static final int TYPE_PROXY_SETTINGS_PAC    = 2;
-
     private static final LinkAddress LINKADDR = new LinkAddress("192.0.2.2/25");
     private static final InetAddress GATEWAY = InetAddressUtils.parseNumericAddress("192.0.2.1");
     private static final InetAddress DNS1 = InetAddressUtils.parseNumericAddress("8.8.8.8");
@@ -76,24 +71,31 @@
         assertIpConfigurationEqual(ipConfig, new IpConfiguration());
         assertIpConfigurationEqual(ipConfig, new IpConfiguration(ipConfig));
 
-        ipConfig = createIpConfiguration(TYPE_IPASSIGNMENT_STATIC,
-                TYPE_PROXY_SETTINGS_PAC);
+        ipConfig.setStaticIpConfiguration(mStaticIpConfig);
+        ipConfig.setHttpProxy(mProxy);
+
+        ipConfig.setIpAssignment(IpConfiguration.IpAssignment.STATIC);
+        ipConfig.setProxySettings(IpConfiguration.ProxySettings.PAC);
         assertIpConfigurationEqual(ipConfig, new IpConfiguration(ipConfig));
 
-        ipConfig = createIpConfiguration(TYPE_IPASSIGNMENT_STATIC,
-                TYPE_PROXY_SETTINGS_STATIC);
+        ipConfig.setIpAssignment(IpConfiguration.IpAssignment.STATIC);
+        ipConfig.setProxySettings(IpConfiguration.ProxySettings.STATIC);
         assertIpConfigurationEqual(ipConfig, new IpConfiguration(ipConfig));
 
-        ipConfig = createIpConfiguration(TYPE_IPASSIGNMENT_DHCP,
-                TYPE_PROXY_SETTINGS_PAC);
+        ipConfig.setIpAssignment(IpConfiguration.IpAssignment.DHCP);
+        ipConfig.setProxySettings(IpConfiguration.ProxySettings.PAC);
         assertIpConfigurationEqual(ipConfig, new IpConfiguration(ipConfig));
 
-        ipConfig = createIpConfiguration(TYPE_IPASSIGNMENT_DHCP,
-                TYPE_PROXY_SETTINGS_STATIC);
+        ipConfig.setIpAssignment(IpConfiguration.IpAssignment.DHCP);
+        ipConfig.setProxySettings(IpConfiguration.ProxySettings.PAC);
         assertIpConfigurationEqual(ipConfig, new IpConfiguration(ipConfig));
 
-        ipConfig = createIpConfiguration(TYPE_IPASSIGNMENT_DHCP,
-                TYPE_PROXY_SETTINGS_NONE);
+        ipConfig.setIpAssignment(IpConfiguration.IpAssignment.DHCP);
+        ipConfig.setProxySettings(IpConfiguration.ProxySettings.STATIC);
+        assertIpConfigurationEqual(ipConfig, new IpConfiguration(ipConfig));
+
+        ipConfig.setIpAssignment(IpConfiguration.IpAssignment.DHCP);
+        ipConfig.setProxySettings(IpConfiguration.ProxySettings.NONE);
         assertIpConfigurationEqual(ipConfig, new IpConfiguration(ipConfig));
     }
 
@@ -106,46 +108,16 @@
         assertNull(config.getHttpProxy());
     }
 
-    private IpConfiguration createIpConfiguration(int ipAssignmentType,
-            int proxySettingType) {
-
-        final IpConfiguration ipConfig = new IpConfiguration();
-
-        switch (ipAssignmentType) {
-            case TYPE_IPASSIGNMENT_STATIC:
-                ipConfig.setIpAssignment(IpConfiguration.IpAssignment.STATIC);
-                break;
-            case TYPE_IPASSIGNMENT_DHCP:
-                ipConfig.setIpAssignment(IpConfiguration.IpAssignment.DHCP);
-                break;
-            default:
-                throw new IllegalArgumentException("Unknown ip assignment type.");
-        }
-
-        switch (proxySettingType) {
-            case TYPE_PROXY_SETTINGS_NONE:
-                ipConfig.setProxySettings(IpConfiguration.ProxySettings.NONE);
-                break;
-            case TYPE_PROXY_SETTINGS_STATIC:
-                ipConfig.setProxySettings(IpConfiguration.ProxySettings.STATIC);
-                break;
-            case TYPE_PROXY_SETTINGS_PAC:
-                ipConfig.setProxySettings(IpConfiguration.ProxySettings.PAC);
-                break;
-            default:
-                throw new IllegalArgumentException("Unknown proxy setting type.");
-        }
-
-        ipConfig.setStaticIpConfiguration(mStaticIpConfig);
-        ipConfig.setHttpProxy(mProxy);
-
-        return ipConfig;
-    }
-
     private void assertIpConfigurationEqual(IpConfiguration source, IpConfiguration target) {
         assertEquals(source.getIpAssignment(), target.getIpAssignment());
         assertEquals(source.getProxySettings(), target.getProxySettings());
         assertEquals(source.getHttpProxy(), target.getHttpProxy());
         assertEquals(source.getStaticIpConfiguration(), target.getStaticIpConfiguration());
     }
+
+    @Test
+    public void testParcel() {
+        final IpConfiguration config = new IpConfiguration();
+        assertParcelSane(config, 4);
+    }
 }
diff --git a/tests/cts/net/src/android/net/cts/NetworkInfoTest.java b/tests/cts/net/src/android/net/cts/NetworkInfoTest.java
deleted file mode 100644
index 4a7b4e7..0000000
--- a/tests/cts/net/src/android/net/cts/NetworkInfoTest.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (C) 2009 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.
- */
-
-package android.net.cts;
-
-
-import android.content.Context;
-import android.net.ConnectivityManager;
-import android.net.NetworkInfo;
-import android.net.NetworkInfo.DetailedState;
-import android.net.NetworkInfo.State;
-import android.test.AndroidTestCase;
-
-public class NetworkInfoTest extends AndroidTestCase {
-
-    public static final int TYPE_MOBILE = ConnectivityManager.TYPE_MOBILE;
-    public static final int TYPE_WIFI = ConnectivityManager.TYPE_WIFI;
-    public static final String MOBILE_TYPE_NAME = "mobile";
-    public static final String WIFI_TYPE_NAME = "WIFI";
-
-    public void testAccessNetworkInfoProperties() {
-        ConnectivityManager cm = (ConnectivityManager) getContext().getSystemService(
-                Context.CONNECTIVITY_SERVICE);
-        NetworkInfo[] ni = cm.getAllNetworkInfo();
-        assertTrue(ni.length >= 1);
-
-        for (NetworkInfo netInfo: ni) {
-            switch (netInfo.getType()) {
-                case TYPE_MOBILE:
-                    assertNetworkInfo(netInfo, MOBILE_TYPE_NAME);
-                    break;
-                case TYPE_WIFI:
-                    assertNetworkInfo(netInfo, WIFI_TYPE_NAME);
-                    break;
-                 // TODO: Add BLUETOOTH_TETHER testing
-                 default:
-                     break;
-            }
-        }
-    }
-
-    private void assertNetworkInfo(NetworkInfo netInfo, String expectedTypeName) {
-        assertEquals(expectedTypeName.compareToIgnoreCase(netInfo.getTypeName()), 0);
-        if(netInfo.isConnectedOrConnecting()) {
-            assertTrue(netInfo.isAvailable());
-            if (State.CONNECTED == netInfo.getState()) {
-                assertTrue(netInfo.isConnected());
-            }
-            assertTrue(State.CONNECTING == netInfo.getState()
-                    || State.CONNECTED == netInfo.getState());
-            assertTrue(DetailedState.SCANNING == netInfo.getDetailedState()
-                    || DetailedState.CONNECTING == netInfo.getDetailedState()
-                    || DetailedState.AUTHENTICATING == netInfo.getDetailedState()
-                    || DetailedState.CONNECTED == netInfo.getDetailedState());
-        }
-        assertNotNull(netInfo.toString());
-    }
-}
diff --git a/tests/cts/net/src/android/net/cts/NetworkInfoTest.kt b/tests/cts/net/src/android/net/cts/NetworkInfoTest.kt
new file mode 100644
index 0000000..fa15e8f
--- /dev/null
+++ b/tests/cts/net/src/android/net/cts/NetworkInfoTest.kt
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 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.
+ */
+
+package android.net.cts
+
+import android.os.Build
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.NetworkInfo
+import android.net.NetworkInfo.DetailedState
+import android.net.NetworkInfo.State
+import android.telephony.TelephonyManager
+import androidx.test.filters.SmallTest
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.runner.AndroidJUnit4
+import com.android.testutils.DevSdkIgnoreRule
+import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.Rule
+import org.junit.runner.RunWith
+import org.junit.Test
+
+const val TYPE_MOBILE = ConnectivityManager.TYPE_MOBILE
+const val TYPE_WIFI = ConnectivityManager.TYPE_WIFI
+const val MOBILE_TYPE_NAME = "mobile"
+const val WIFI_TYPE_NAME = "WIFI"
+const val LTE_SUBTYPE_NAME = "LTE"
+
+@SmallTest
+@RunWith(AndroidJUnit4::class)
+class NetworkInfoTest {
+    @Rule @JvmField
+    val ignoreRule = DevSdkIgnoreRule()
+
+    @Test
+    fun testAccessNetworkInfoProperties() {
+        val cm = InstrumentationRegistry.getInstrumentation().context
+                .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+        val ni = cm.getAllNetworkInfo()
+        assertTrue(ni.isNotEmpty())
+
+        for (netInfo in ni) {
+            when (netInfo.getType()) {
+                TYPE_MOBILE -> assertNetworkInfo(netInfo, MOBILE_TYPE_NAME)
+                TYPE_WIFI -> assertNetworkInfo(netInfo, WIFI_TYPE_NAME)
+                // TODO: Add BLUETOOTH_TETHER testing
+            }
+        }
+    }
+
+    private fun assertNetworkInfo(netInfo: NetworkInfo, expectedTypeName: String) {
+        assertTrue(expectedTypeName.equals(netInfo.getTypeName(), ignoreCase = true))
+        assertNotNull(netInfo.toString())
+
+        if (!netInfo.isConnectedOrConnecting()) return
+
+        assertTrue(netInfo.isAvailable())
+        if (State.CONNECTED == netInfo.getState()) {
+            assertTrue(netInfo.isConnected())
+        }
+        assertTrue(State.CONNECTING == netInfo.getState() ||
+                State.CONNECTED == netInfo.getState())
+        assertTrue(DetailedState.SCANNING == netInfo.getDetailedState() ||
+                DetailedState.CONNECTING == netInfo.getDetailedState() ||
+                DetailedState.AUTHENTICATING == netInfo.getDetailedState() ||
+                DetailedState.CONNECTED == netInfo.getDetailedState())
+    }
+
+    @Test @IgnoreUpTo(Build.VERSION_CODES.Q)
+    fun testConstructor() {
+        val networkInfo = NetworkInfo(TYPE_MOBILE, TelephonyManager.NETWORK_TYPE_LTE,
+                MOBILE_TYPE_NAME, LTE_SUBTYPE_NAME)
+
+        assertEquals(TYPE_MOBILE, networkInfo.type)
+        assertEquals(TelephonyManager.NETWORK_TYPE_LTE, networkInfo.subtype)
+        assertEquals(MOBILE_TYPE_NAME, networkInfo.typeName)
+        assertEquals(LTE_SUBTYPE_NAME, networkInfo.subtypeName)
+        assertEquals(DetailedState.IDLE, networkInfo.detailedState)
+        assertEquals(State.UNKNOWN, networkInfo.state)
+        assertNull(networkInfo.reason)
+        assertNull(networkInfo.extraInfo)
+
+        try {
+            NetworkInfo(ConnectivityManager.MAX_NETWORK_TYPE + 1,
+                    TelephonyManager.NETWORK_TYPE_LTE, MOBILE_TYPE_NAME, LTE_SUBTYPE_NAME)
+            fail("Unexpected behavior. Network type is invalid.")
+        } catch (e: IllegalArgumentException) {
+            // Expected behavior.
+        }
+    }
+
+    @Test
+    fun testSetDetailedState() {
+        val networkInfo = NetworkInfo(TYPE_MOBILE, TelephonyManager.NETWORK_TYPE_LTE,
+                MOBILE_TYPE_NAME, LTE_SUBTYPE_NAME)
+        val reason = "TestNetworkInfo"
+        val extraReason = "setDetailedState test"
+
+        networkInfo.setDetailedState(DetailedState.CONNECTED, reason, extraReason)
+        assertEquals(DetailedState.CONNECTED, networkInfo.detailedState)
+        assertEquals(State.CONNECTED, networkInfo.state)
+        assertEquals(reason, networkInfo.reason)
+        assertEquals(extraReason, networkInfo.extraInfo)
+    }
+}
diff --git a/tests/cts/net/src/android/net/cts/RssiCurveTest.java b/tests/cts/net/src/android/net/cts/RssiCurveTest.java
new file mode 100644
index 0000000..d651b71
--- /dev/null
+++ b/tests/cts/net/src/android/net/cts/RssiCurveTest.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 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.
+ */
+
+package android.net.cts;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.net.RssiCurve;
+
+import androidx.test.runner.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** CTS tests for {@link RssiCurve}. */
+@RunWith(AndroidJUnit4.class)
+public class RssiCurveTest {
+
+    @Test
+    public void lookupScore_constantCurve() {
+        // One bucket from rssi=-100 to 100 with score 10.
+        RssiCurve curve = new RssiCurve(-100, 200, new byte[] { 10 });
+        assertThat(curve.lookupScore(-200)).isEqualTo(10);
+        assertThat(curve.lookupScore(-100)).isEqualTo(10);
+        assertThat(curve.lookupScore(0)).isEqualTo(10);
+        assertThat(curve.lookupScore(100)).isEqualTo(10);
+        assertThat(curve.lookupScore(200)).isEqualTo(10);
+    }
+
+    @Test
+    public void lookupScore_changingCurve() {
+        // One bucket from -100 to 0 with score -10, and one bucket from 0 to 100 with score 10.
+        RssiCurve curve = new RssiCurve(-100, 100, new byte[] { -10, 10 });
+        assertThat(curve.lookupScore(-200)).isEqualTo(-10);
+        assertThat(curve.lookupScore(-100)).isEqualTo(-10);
+        assertThat(curve.lookupScore(-50)).isEqualTo(-10);
+        assertThat(curve.lookupScore(0)).isEqualTo(10);
+        assertThat(curve.lookupScore(50)).isEqualTo(10);
+        assertThat(curve.lookupScore(100)).isEqualTo(10);
+        assertThat(curve.lookupScore(200)).isEqualTo(10);
+    }
+
+    @Test
+    public void lookupScore_linearCurve() {
+        // Curve starting at -110, with 15 buckets of width 10 whose scores increases by 10 with
+        // each bucket. The current active network gets a boost of 15 to its RSSI.
+        RssiCurve curve = new RssiCurve(
+                -110,
+                10,
+                new byte[] { -20, -10, 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120 },
+                15);
+
+        assertThat(curve.lookupScore(-120)).isEqualTo(-20);
+        assertThat(curve.lookupScore(-120, false)).isEqualTo(-20);
+        assertThat(curve.lookupScore(-120, true)).isEqualTo(-20);
+
+        assertThat(curve.lookupScore(-111)).isEqualTo(-20);
+        assertThat(curve.lookupScore(-111, false)).isEqualTo(-20);
+        assertThat(curve.lookupScore(-111, true)).isEqualTo(-10);
+
+        assertThat(curve.lookupScore(-110)).isEqualTo(-20);
+        assertThat(curve.lookupScore(-110, false)).isEqualTo(-20);
+        assertThat(curve.lookupScore(-110, true)).isEqualTo(-10);
+
+        assertThat(curve.lookupScore(-105)).isEqualTo(-20);
+        assertThat(curve.lookupScore(-105, false)).isEqualTo(-20);
+        assertThat(curve.lookupScore(-105, true)).isEqualTo(0);
+
+        assertThat(curve.lookupScore(-100)).isEqualTo(-10);
+        assertThat(curve.lookupScore(-100, false)).isEqualTo(-10);
+        assertThat(curve.lookupScore(-100, true)).isEqualTo(0);
+
+        assertThat(curve.lookupScore(-50)).isEqualTo(40);
+        assertThat(curve.lookupScore(-50, false)).isEqualTo(40);
+        assertThat(curve.lookupScore(-50, true)).isEqualTo(50);
+
+        assertThat(curve.lookupScore(0)).isEqualTo(90);
+        assertThat(curve.lookupScore(0, false)).isEqualTo(90);
+        assertThat(curve.lookupScore(0, true)).isEqualTo(100);
+
+        assertThat(curve.lookupScore(30)).isEqualTo(120);
+        assertThat(curve.lookupScore(30, false)).isEqualTo(120);
+        assertThat(curve.lookupScore(30, true)).isEqualTo(120);
+
+        assertThat(curve.lookupScore(40)).isEqualTo(120);
+        assertThat(curve.lookupScore(40, false)).isEqualTo(120);
+        assertThat(curve.lookupScore(40, true)).isEqualTo(120);
+    }
+}
diff --git a/tests/cts/net/src/android/net/rtp/cts/AudioGroupTest.java b/tests/cts/net/src/android/net/rtp/cts/AudioGroupTest.java
index fee8621..fc78e96 100644
--- a/tests/cts/net/src/android/net/rtp/cts/AudioGroupTest.java
+++ b/tests/cts/net/src/android/net/rtp/cts/AudioGroupTest.java
@@ -21,9 +21,12 @@
 import android.net.rtp.AudioGroup;
 import android.net.rtp.AudioStream;
 import android.net.rtp.RtpStream;
+import android.os.Build;
 import android.platform.test.annotations.AppModeFull;
 import android.test.AndroidTestCase;
 
+import androidx.core.os.BuildCompat;
+
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;
@@ -62,7 +65,10 @@
         mSocketB.connect(mStreamB.getLocalAddress(), mStreamB.getLocalPort());
         mStreamB.associate(mSocketB.getLocalAddress(), mSocketB.getLocalPort());
 
-        mGroup = new AudioGroup(mContext);
+        // BuildCompat.isAtLeastR is documented to return false on release SDKs (including R)
+        mGroup = Build.VERSION.SDK_INT > Build.VERSION_CODES.Q || BuildCompat.isAtLeastR()
+                ? new AudioGroup(mContext)
+                : new AudioGroup(); // Constructor with context argument was introduced in R
     }
 
     @Override
diff --git a/tests/cts/net/src/android/net/wifi/cts/ConnectedNetworkScorerTest.java b/tests/cts/net/src/android/net/wifi/cts/ConnectedNetworkScorerTest.java
index ce5bb81..9624dd7 100644
--- a/tests/cts/net/src/android/net/wifi/cts/ConnectedNetworkScorerTest.java
+++ b/tests/cts/net/src/android/net/wifi/cts/ConnectedNetworkScorerTest.java
@@ -174,6 +174,7 @@
             assertThat(statsEntry.getTotalHotspot2ScanTimeMillis()).isAtLeast(0L);
             assertThat(statsEntry.getTotalCcaBusyFreqTimeMillis()).isAtLeast(0L);
             assertThat(statsEntry.getTotalRadioOnTimeMillis()).isGreaterThan(0L);
+            assertThat(statsEntry.getTotalRadioOnFreqTimeMillis()).isGreaterThan(0L);
             assertThat(statsEntry.getTotalBeaconRx()).isGreaterThan(0L);
             assertThat(statsEntry.getProbeStatusSinceLastUpdate())
                     .isAnyOf(PROBE_STATUS_SUCCESS,
diff --git a/tests/cts/net/src/android/net/wifi/cts/WifiManagerTest.java b/tests/cts/net/src/android/net/wifi/cts/WifiManagerTest.java
index 98846fa..0cf984c 100644
--- a/tests/cts/net/src/android/net/wifi/cts/WifiManagerTest.java
+++ b/tests/cts/net/src/android/net/wifi/cts/WifiManagerTest.java
@@ -1403,13 +1403,13 @@
         mWifiManager.setSoftApConfiguration(targetConfig);
         // Bssid set dodesn't support for tethered hotspot
         SoftApConfiguration currentConfig = mWifiManager.getSoftApConfiguration();
-        assertNull(currentConfig.getBssid());
         compareSoftApConfiguration(targetConfig, currentConfig);
     }
 
     private void compareSoftApConfiguration(SoftApConfiguration currentConfig,
         SoftApConfiguration testSoftApConfig) {
         assertEquals(currentConfig.getSsid(), testSoftApConfig.getSsid());
+        assertEquals(currentConfig.getBssid(), testSoftApConfig.getBssid());
         assertEquals(currentConfig.getSecurityType(), testSoftApConfig.getSecurityType());
         assertEquals(currentConfig.getPassphrase(), testSoftApConfig.getPassphrase());
         assertEquals(currentConfig.isHiddenSsid(), testSoftApConfig.isHiddenSsid());
diff --git a/tests/cts/net/src/android/net/wifi/cts/WifiNetworkSpecifierTest.java b/tests/cts/net/src/android/net/wifi/cts/WifiNetworkSpecifierTest.java
index 83018fa..eb6d684 100644
--- a/tests/cts/net/src/android/net/wifi/cts/WifiNetworkSpecifierTest.java
+++ b/tests/cts/net/src/android/net/wifi/cts/WifiNetworkSpecifierTest.java
@@ -363,13 +363,17 @@
         testConnectionFlowWithSpecifier(specifier, true);
     }
 
+    private static String removeDoubleQuotes(String string) {
+        return WifiInfo.sanitizeSsid(string);
+    }
+
     private WifiNetworkSpecifier.Builder createSpecifierBuilderWithCredentialFromSavedNetwork() {
         WifiNetworkSpecifier.Builder specifierBuilder = new WifiNetworkSpecifier.Builder();
         if (mTestNetwork.preSharedKey != null) {
             if (mTestNetwork.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_PSK)) {
-                specifierBuilder.setWpa2Passphrase(mTestNetwork.preSharedKey);
+                specifierBuilder.setWpa2Passphrase(removeDoubleQuotes(mTestNetwork.preSharedKey));
             } else if (mTestNetwork.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.SAE)) {
-                specifierBuilder.setWpa3Passphrase(mTestNetwork.preSharedKey);
+                specifierBuilder.setWpa3Passphrase(removeDoubleQuotes(mTestNetwork.preSharedKey));
             } else {
                 fail("Unsupported security type found in saved networks");
             }
@@ -391,7 +395,7 @@
             return;
         }
         WifiNetworkSpecifier specifier = createSpecifierBuilderWithCredentialFromSavedNetwork()
-                .setSsid(WifiInfo.sanitizeSsid(mTestNetwork.SSID))
+                .setSsid(removeDoubleQuotes(mTestNetwork.SSID))
                 .build();
         testSuccessfulConnectionWithSpecifier(specifier);
     }
@@ -406,7 +410,7 @@
         }
         // Creates a ssid pattern by dropping the last char in the saved network & pass that
         // as a prefix match pattern in the request.
-        String ssidUnquoted = WifiInfo.sanitizeSsid(mTestNetwork.SSID);
+        String ssidUnquoted = removeDoubleQuotes(mTestNetwork.SSID);
         assertThat(ssidUnquoted.length()).isAtLeast(2);
         String ssidPrefix = ssidUnquoted.substring(0, ssidUnquoted.length() - 1);
         // Note: The match may return more than 1 network in this case since we use a prefix match,
@@ -460,7 +464,7 @@
         List<ScanResult> scanResults = mWifiManager.getScanResults();
         if (scanResults == null || scanResults.isEmpty()) fail("No scan results available");
         for (ScanResult scanResult : scanResults) {
-            if (TextUtils.equals(scanResult.SSID, WifiInfo.sanitizeSsid(mTestNetwork.SSID))) {
+            if (TextUtils.equals(scanResult.SSID, removeDoubleQuotes(mTestNetwork.SSID))) {
                 return scanResult;
             }
         }
@@ -511,7 +515,7 @@
             return;
         }
         WifiNetworkSpecifier specifier = createSpecifierBuilderWithCredentialFromSavedNetwork()
-                .setSsid(WifiInfo.sanitizeSsid(mTestNetwork.SSID))
+                .setSsid(removeDoubleQuotes(mTestNetwork.SSID))
                 .build();
         testUserRejectionWithSpecifier(specifier);
     }
@@ -526,11 +530,11 @@
             return;
         }
         WifiNetworkSpecifier specifier1 = new WifiNetworkSpecifier.Builder()
-                .setSsid(WifiInfo.sanitizeSsid(mTestNetwork.SSID))
+                .setSsid(removeDoubleQuotes(mTestNetwork.SSID))
                 .setWpa2EnterpriseConfig(new WifiEnterpriseConfig())
                 .build();
         WifiNetworkSpecifier specifier2 = new WifiNetworkSpecifier.Builder()
-                .setSsid(WifiInfo.sanitizeSsid(mTestNetwork.SSID))
+                .setSsid(removeDoubleQuotes(mTestNetwork.SSID))
                 .setWpa2EnterpriseConfig(new WifiEnterpriseConfig())
                 .build();
         assertThat(specifier1.satisfiedBy(specifier2)).isTrue();
@@ -546,11 +550,11 @@
             return;
         }
         WifiNetworkSpecifier specifier1 = new WifiNetworkSpecifier.Builder()
-                .setSsid(WifiInfo.sanitizeSsid(mTestNetwork.SSID))
+                .setSsid(removeDoubleQuotes(mTestNetwork.SSID))
                 .setWpa3EnterpriseConfig(new WifiEnterpriseConfig())
                 .build();
         WifiNetworkSpecifier specifier2 = new WifiNetworkSpecifier.Builder()
-                .setSsid(WifiInfo.sanitizeSsid(mTestNetwork.SSID))
+                .setSsid(removeDoubleQuotes(mTestNetwork.SSID))
                 .setWpa3EnterpriseConfig(new WifiEnterpriseConfig())
                 .build();
         assertThat(specifier1.satisfiedBy(specifier2)).isTrue();
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 49aa47e..9cbaf39 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
@@ -72,10 +72,9 @@
 
         // Scan for IEEE 802.11mc supporting APs
         ScanResult testAp = scanForTestAp(NUM_SCANS_SEARCHING_FOR_IEEE80211MC_AP);
-        assertTrue(
+        assertNotNull(
                 "Cannot find any test APs which support RTT / IEEE 802.11mc - please verify that "
-                        + "your test setup includes them!",
-                testAp != null);
+                        + "your test setup includes them!", testAp);
 
         // Perform RTT operations
         RangingRequest request = new RangingRequest.Builder().addAccessPoint(testAp).build();
@@ -100,16 +99,15 @@
                     callback.waitForCallback());
 
             List<RangingResult> currentResults = callback.getResults();
-            assertTrue("Wi-Fi RTT results: null results (onRangingFailure) on iteration " + i,
-                    currentResults != null);
-            assertTrue("Wi-Fi RTT results: unexpected # of results (expect 1) on iteration " + i,
-                    currentResults.size() == 1);
+            assertNotNull("Wi-Fi RTT results: null results (onRangingFailure) on iteration " + i,
+                    currentResults);
+            assertEquals("Wi-Fi RTT results: unexpected # of results (expect 1) on iteration " + i,
+                    1, currentResults.size());
             RangingResult result = currentResults.get(0);
-            assertTrue("Wi-Fi RTT results: invalid result (wrong BSSID) entry on iteration " + i,
-                    result.getMacAddress().toString().equals(testAp.BSSID));
-            assertEquals(
-                    "Wi-Fi RTT results: invalid result (non-null PeerHandle) entry on iteration "
-                            + i, null, result.getPeerHandle());
+            assertEquals("Wi-Fi RTT results: invalid result (wrong BSSID) entry on iteration " + i,
+                    result.getMacAddress().toString(), testAp.BSSID);
+            assertNull("Wi-Fi RTT results: invalid result (non-null PeerHandle) entry on iteration "
+                    + i, result.getPeerHandle());
 
             allResults.add(result);
             int status = result.getStatus();
@@ -189,23 +187,24 @@
      * Validate that when a request contains more range operations than allowed (by API) that we
      * get an exception.
      */
-    public void testRequestTooLarge() {
+    public void testRequestTooLarge() throws InterruptedException {
         if (!shouldTestWifiRtt(getContext())) {
             return;
         }
-
-        ScanResult dummy = mock(ScanResult.class);
-        dummy.BSSID = "00:01:02:03:04:05";
+        ScanResult testAp = scanForTestAp(NUM_SCANS_SEARCHING_FOR_IEEE80211MC_AP);
+        assertNotNull(
+                "Cannot find any test APs which support RTT / IEEE 802.11mc - please verify that "
+                        + "your test setup includes them!", testAp);
 
         RangingRequest.Builder builder = new RangingRequest.Builder();
         for (int i = 0; i < RangingRequest.getMaxPeers() - 2; ++i) {
-            builder.addAccessPoint(dummy);
+            builder.addAccessPoint(testAp);
         }
 
         List<ScanResult> scanResults = new ArrayList<>();
-        scanResults.add(dummy);
-        scanResults.add(dummy);
-        scanResults.add(dummy);
+        scanResults.add(testAp);
+        scanResults.add(testAp);
+        scanResults.add(testAp);
 
         builder.addAccessPoints(scanResults);
 
@@ -215,10 +214,8 @@
             return;
         }
 
-        assertTrue(
-                "Did not receive expected IllegalArgumentException when tried to range to too "
-                        + "many peers",
-                false);
+        fail("Did not receive expected IllegalArgumentException when tried to range to too "
+                + "many peers");
     }
 
     /**
@@ -230,10 +227,9 @@
         }
         // Scan for IEEE 802.11mc supporting APs
         ScanResult testAp = scanForTestAp(NUM_SCANS_SEARCHING_FOR_IEEE80211MC_AP);
-        assertTrue(
+        assertNotNull(
                 "Cannot find any test APs which support RTT / IEEE 802.11mc - please verify that "
-                        + "your test setup includes them!",
-                testAp != null);
+                        + "your test setup includes them!", testAp);
 
         // Perform RTT operations
         RangingRequest request = new RangingRequest.Builder().addAccessPoint(testAp).build();