diff --git a/audio/common/2.0/default/HidlUtils.cpp b/audio/common/2.0/default/HidlUtils.cpp
index 241ca90..79cb37c 100644
--- a/audio/common/2.0/default/HidlUtils.cpp
+++ b/audio/common/2.0/default/HidlUtils.cpp
@@ -28,6 +28,7 @@
 using ::android::hardware::audio::common::V2_0::AudioPortType;
 using ::android::hardware::audio::common::V2_0::AudioSource;
 using ::android::hardware::audio::common::V2_0::AudioStreamType;
+using ::android::hardware::audio::common::V2_0::AudioUsage;
 
 namespace android {
 
@@ -103,6 +104,9 @@
     offload->durationMicroseconds = halOffload.duration_us;
     offload->hasVideo = halOffload.has_video;
     offload->isStreaming = halOffload.is_streaming;
+    offload->bitWidth = halOffload.bit_width;
+    offload->bufferSize = halOffload.offload_buffer_size;
+    offload->usage = static_cast<AudioUsage>(halOffload.usage);
 }
 
 void HidlUtils::audioOffloadInfoToHal(
diff --git a/biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp b/biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp
index 5b00675..4f5aaf9 100644
--- a/biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp
+++ b/biometrics/fingerprint/2.1/default/BiometricsFingerprint.cpp
@@ -79,7 +79,7 @@
         case -28: return RequestStatus::SYS_ENOSPC;
         case -110: return RequestStatus::SYS_ETIMEDOUT;
         default:
-            ALOGE("An unknown error returned from fingerprint vendor library");
+            ALOGE("An unknown error returned from fingerprint vendor library: %d", error);
             return RequestStatus::SYS_UNKNOWN;
     }
 }
diff --git a/drm/1.0/vts/functional/drm_hal_vendor_test.cpp b/drm/1.0/vts/functional/drm_hal_vendor_test.cpp
index 44675dc..5945c05 100644
--- a/drm/1.0/vts/functional/drm_hal_vendor_test.cpp
+++ b/drm/1.0/vts/functional/drm_hal_vendor_test.cpp
@@ -33,7 +33,8 @@
 
 #include "drm_hal_vendor_module_api.h"
 #include "vendor_modules.h"
-#include "VtsHalHidlTargetTestBase.h"
+#include <VtsHalHidlTargetCallbackBase.h>
+#include <VtsHalHidlTargetTestBase.h>
 
 using ::android::hardware::drm::V1_0::BufferType;
 using ::android::hardware::drm::V1_0::DestinationBuffer;
@@ -77,6 +78,7 @@
 
 using ContentConfiguration = ::DrmHalVTSVendorModule_V1::ContentConfiguration;
 using Key = ::DrmHalVTSVendorModule_V1::ContentConfiguration::Key;
+using VtsTestBase = ::testing::VtsHalHidlTargetTestBase;
 
 #define ASSERT_OK(ret) ASSERT_TRUE(ret.isOk())
 #define EXPECT_OK(ret) EXPECT_TRUE(ret.isOk())
@@ -105,14 +107,22 @@
               GetParam().c_str());
 
         ASSERT_NE(vendorModule, nullptr);
+
+        // First try the binderized service name provided by the vendor module.
+        // If that fails, which it can on non-binderized devices, try the default
+        // service.
         string name = vendorModule->getServiceName();
-        drmFactory =
-                ::testing::VtsHalHidlTargetTestBase::getService<IDrmFactory>(
-                        name != "default" ? name : "drm");
+        drmFactory = VtsTestBase::getService<IDrmFactory>(name);
+        if (drmFactory == nullptr) {
+            drmFactory = VtsTestBase::getService<IDrmFactory>("drm");
+        }
         ASSERT_NE(drmFactory, nullptr);
-        cryptoFactory =
-                ::testing::VtsHalHidlTargetTestBase::getService<ICryptoFactory>(
-                        name != "default" ? name : "crypto");
+
+        // Dot the same for the crypto factory
+        cryptoFactory = VtsTestBase::getService<ICryptoFactory>(name);
+        if (cryptoFactory == nullptr) {
+            VtsTestBase::getService<ICryptoFactory>("crypto");
+        }
         ASSERT_NE(cryptoFactory, nullptr);
     }
 
@@ -825,71 +835,59 @@
 /**
  *  Event Handling tests
  */
+struct ListenerEventArgs {
+    EventType eventType;
+    SessionId sessionId;
+    hidl_vec<uint8_t> data;
+    int64_t expiryTimeInMS;
+    hidl_vec<KeyStatus> keyStatusList;
+    bool hasNewUsableKey;
+};
 
-class TestDrmPluginListener : public IDrmPluginListener {
+const char *kCallbackEvent = "SendEvent";
+const char *kCallbackExpirationUpdate = "SendExpirationUpdate";
+const char *kCallbackKeysChange = "SendKeysChange";
+
+class TestDrmPluginListener
+    : public ::testing::VtsHalHidlTargetCallbackBase<ListenerEventArgs>,
+      public IDrmPluginListener {
 public:
-    TestDrmPluginListener() {reset();}
+    TestDrmPluginListener() {
+        SetWaitTimeoutDefault(std::chrono::milliseconds(500));
+    }
     virtual ~TestDrmPluginListener() {}
 
     virtual Return<void> sendEvent(EventType eventType, const hidl_vec<uint8_t>& sessionId,
             const hidl_vec<uint8_t>& data) override {
-        eventType_ = eventType;
-        sessionId_ = sessionId;
-        data_ = data;
-        gotEvent_ = true;
+        ListenerEventArgs args;
+        args.eventType = eventType;
+        args.sessionId = sessionId;
+        args.data = data;
+        NotifyFromCallback(kCallbackEvent, args);
         return Void();
     }
 
     virtual Return<void> sendExpirationUpdate(const hidl_vec<uint8_t>& sessionId,
             int64_t expiryTimeInMS) override {
-        sessionId_ = sessionId;
-        expiryTimeInMS_ = expiryTimeInMS;
-        gotExpirationUpdate_ = true;
+        ListenerEventArgs args;
+        args.sessionId = sessionId;
+        args.expiryTimeInMS = expiryTimeInMS;
+        NotifyFromCallback(kCallbackExpirationUpdate, args);
         return Void();
     }
 
     virtual Return<void> sendKeysChange(const hidl_vec<uint8_t>& sessionId,
             const hidl_vec<KeyStatus>& keyStatusList, bool hasNewUsableKey) override {
-        sessionId_ = sessionId;
-        keyStatusList_ = keyStatusList;
-        hasNewUsableKey_ = hasNewUsableKey;
-        gotKeysChange_ = true;
+        ListenerEventArgs args;
+        args.sessionId = sessionId;
+        args.keyStatusList = keyStatusList;
+        args.hasNewUsableKey = hasNewUsableKey;
+        NotifyFromCallback(kCallbackKeysChange, args);
         return Void();
     }
-
-    EventType getEventType() const {return eventType_;}
-    SessionId getSessionId() const {return sessionId_;}
-    vector<uint8_t> getData() const {return data_;}
-    int64_t getExpiryTimeInMS() const {return expiryTimeInMS_;}
-    hidl_vec<KeyStatus> getKeyStatusList() const {return keyStatusList_;}
-    bool hasNewUsableKey() {return hasNewUsableKey_;}
-    bool gotEvent() {return gotEvent_;}
-    bool gotExpirationUpdate() {return gotExpirationUpdate_;}
-    bool gotKeysChange() {return gotKeysChange_;}
-
-    void reset() {
-        gotEvent_ = gotExpirationUpdate_ = gotKeysChange_ = false;
-        eventType_ = EventType::PROVISION_REQUIRED;
-        sessionId_ = SessionId();
-        data_ = hidl_vec<uint8_t>();
-        expiryTimeInMS_ = 0;
-        keyStatusList_ = hidl_vec<KeyStatus>();
-        hasNewUsableKey_ = false;
-    }
-
-private:
-    bool gotEvent_;
-    bool gotExpirationUpdate_;
-    bool gotKeysChange_;
-
-    EventType eventType_;
-    SessionId sessionId_;
-    hidl_vec<uint8_t> data_;
-    int64_t expiryTimeInMS_;
-    hidl_vec<KeyStatus> keyStatusList_;
-    bool hasNewUsableKey_;
 };
 
+
 /**
  * Simulate the plugin sending events. Make sure the listener
  * gets them.
@@ -898,19 +896,20 @@
     sp<TestDrmPluginListener> listener = new TestDrmPluginListener();
     drmPlugin->setListener(listener);
     auto sessionId = openSession();
-    vector<uint8_t> data = {0, 1, 2};
+    hidl_vec<uint8_t> data = {0, 1, 2};
     EventType eventTypes[] = {EventType::PROVISION_REQUIRED,
                               EventType::KEY_NEEDED,
                               EventType::KEY_EXPIRED,
                               EventType::VENDOR_DEFINED,
                               EventType::SESSION_RECLAIMED};
     for (auto eventType : eventTypes) {
-        listener->reset();
         drmPlugin->sendEvent(eventType, sessionId, data);
-        while (!listener->gotEvent()) {usleep(100);}
-        EXPECT_EQ(eventType, listener->getEventType());
-        EXPECT_EQ(sessionId, listener->getSessionId());
-        EXPECT_EQ(data, listener->getData());
+        auto result = listener->WaitForCallback(kCallbackEvent);
+        EXPECT_TRUE(result.no_timeout);
+        EXPECT_TRUE(result.args);
+        EXPECT_EQ(eventType, result.args->eventType);
+        EXPECT_EQ(sessionId, result.args->sessionId);
+        EXPECT_EQ(data, result.args->data);
     }
     closeSession(sessionId);
 }
@@ -924,9 +923,11 @@
     drmPlugin->setListener(listener);
     auto sessionId = openSession();
     drmPlugin->sendExpirationUpdate(sessionId, 100);
-    while (!listener->gotExpirationUpdate()) {usleep(100);}
-    EXPECT_EQ(sessionId, listener->getSessionId());
-    EXPECT_EQ(100, listener->getExpiryTimeInMS());
+    auto result = listener->WaitForCallback(kCallbackExpirationUpdate);
+    EXPECT_TRUE(result.no_timeout);
+    EXPECT_TRUE(result.args);
+    EXPECT_EQ(sessionId, result.args->sessionId);
+    EXPECT_EQ(100, result.args->expiryTimeInMS);
     closeSession(sessionId);
 }
 
@@ -947,10 +948,11 @@
     };
 
     drmPlugin->sendKeysChange(sessionId, keyStatusList, true);
-    while (!listener->gotKeysChange()) {usleep(100);}
-    EXPECT_EQ(sessionId, listener->getSessionId());
-    EXPECT_EQ(keyStatusList, listener->getKeyStatusList());
-    EXPECT_EQ(true, listener->hasNewUsableKey());
+    auto result = listener->WaitForCallback(kCallbackKeysChange);
+    EXPECT_TRUE(result.no_timeout);
+    EXPECT_TRUE(result.args);
+    EXPECT_EQ(sessionId, result.args->sessionId);
+    EXPECT_EQ(keyStatusList, result.args->keyStatusList);
 }
 
 /**
@@ -963,15 +965,14 @@
     drmPlugin->setListener(nullptr);
 
     SessionId sessionId;
-    vector<uint8_t> data;
+    hidl_vec<uint8_t> data;
     hidl_vec<KeyStatus> keyStatusList;
     drmPlugin->sendEvent(EventType::PROVISION_REQUIRED, sessionId, data);
     drmPlugin->sendExpirationUpdate(sessionId, 100);
     drmPlugin->sendKeysChange(sessionId, keyStatusList, true);
-    usleep(1000); // can't wait for the event to be recieved, just wait a long time
-    EXPECT_EQ(false, listener->gotEvent());
-    EXPECT_EQ(false, listener->gotExpirationUpdate());
-    EXPECT_EQ(false, listener->gotKeysChange());
+    auto result = listener->WaitForCallbackAny(
+            {kCallbackEvent, kCallbackExpirationUpdate, kCallbackKeysChange});
+    EXPECT_FALSE(result.no_timeout);
 }
 
 
diff --git a/graphics/common/1.0/types.hal b/graphics/common/1.0/types.hal
index 6d94d76..3bd1ec1 100644
--- a/graphics/common/1.0/types.hal
+++ b/graphics/common/1.0/types.hal
@@ -181,9 +181,17 @@
      *    - GRALLOC_USAGE_SW_*
      *    - GRALLOC_USAGE_RENDERSCRIPT
      *
-     * When used with ANativeWindow, the dataSpace should be
-     * HAL_DATASPACE_ARBITRARY, as raw image sensor buffers require substantial
-     * extra metadata to define.
+     * When used with ANativeWindow, the mapping of the dataSpace field to
+     * buffer contents for RAW16 is as follows:
+     *
+     *  dataSpace value               | Buffer contents
+     * -------------------------------+-----------------------------------------
+     *  HAL_DATASPACE_ARBITRARY       | Raw image sensor data, layout is as
+     *                                | defined above.
+     *  HAL_DATASPACE_DEPTH           | Unprocessed implementation-dependent raw
+     *                                | depth measurements, opaque with 16 bit
+     *                                | samples.
+     *  Other                         | Unsupported
      */
     RAW16 = 0x20,
 
diff --git a/wifi/1.0/vts/functional/wifi_ap_iface_hidl_test.cpp b/wifi/1.0/vts/functional/wifi_ap_iface_hidl_test.cpp
index 42d9a96..c0af30b 100644
--- a/wifi/1.0/vts/functional/wifi_ap_iface_hidl_test.cpp
+++ b/wifi/1.0/vts/functional/wifi_ap_iface_hidl_test.cpp
@@ -20,9 +20,13 @@
 
 #include <VtsHalHidlTargetTestBase.h>
 
+#include "wifi_hidl_call_util.h"
 #include "wifi_hidl_test_utils.h"
 
+using ::android::hardware::wifi::V1_0::IfaceType;
 using ::android::hardware::wifi::V1_0::IWifiApIface;
+using ::android::hardware::wifi::V1_0::WifiBand;
+using ::android::hardware::wifi::V1_0::WifiStatusCode;
 using ::android::sp;
 
 /**
@@ -30,11 +34,15 @@
  */
 class WifiApIfaceHidlTest : public ::testing::VtsHalHidlTargetTestBase {
    public:
-    virtual void SetUp() override {}
+    virtual void SetUp() override {
+        wifi_ap_iface_ = getWifiApIface();
+        ASSERT_NE(nullptr, wifi_ap_iface_.get());
+    }
 
     virtual void TearDown() override { stopWifi(); }
 
    protected:
+    sp<IWifiApIface> wifi_ap_iface_;
 };
 
 /*
@@ -46,3 +54,36 @@
     EXPECT_NE(nullptr, getWifiApIface().get());
     stopWifi();
 }
+
+/*
+ * GetType:
+ * Ensures that the correct interface type is returned for AP interface.
+ */
+TEST_F(WifiApIfaceHidlTest, GetType) {
+    const auto& status_and_type = HIDL_INVOKE(wifi_ap_iface_, getType);
+    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_type.first.code);
+    EXPECT_EQ(IfaceType::AP, status_and_type.second);
+}
+
+/*
+ * SetCountryCode:
+ * Ensures that a call to set the country code will return with a success
+ * status code.
+ */
+TEST_F(WifiApIfaceHidlTest, SetCountryCode) {
+    const android::hardware::hidl_array<int8_t, 2> kCountryCode{
+        std::array<int8_t, 2>{{0x55, 0x53}}};
+    EXPECT_EQ(WifiStatusCode::SUCCESS,
+              HIDL_INVOKE(wifi_ap_iface_, setCountryCode, kCountryCode).code);
+}
+
+/*
+ * GetValidFrequenciesForBand:
+ * Ensures that we can retrieve valid frequencies for 2.4 GHz band.
+ */
+TEST_F(WifiApIfaceHidlTest, GetValidFrequenciesForBand) {
+    const auto& status_and_freqs = HIDL_INVOKE(
+        wifi_ap_iface_, getValidFrequenciesForBand, WifiBand::BAND_24GHZ);
+    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_freqs.first.code);
+    EXPECT_GT(status_and_freqs.second.size(), 0u);
+}
diff --git a/wifi/1.0/vts/functional/wifi_chip_hidl_test.cpp b/wifi/1.0/vts/functional/wifi_chip_hidl_test.cpp
index 084067c..0627a99 100644
--- a/wifi/1.0/vts/functional/wifi_chip_hidl_test.cpp
+++ b/wifi/1.0/vts/functional/wifi_chip_hidl_test.cpp
@@ -76,15 +76,14 @@
     // Helper function to configure the Chip in one of the supported modes.
     // Most of the non-mode-configuration-related methods require chip
     // to be first configured.
-    ChipModeId configureChipForIfaceType(IfaceType type) {
+    ChipModeId configureChipForIfaceType(IfaceType type, bool expectSuccess) {
         ChipModeId mode_id;
-        EXPECT_TRUE(
-            configureChipToSupportIfaceType(wifi_chip_, type, &mode_id));
+        EXPECT_EQ(expectSuccess, configureChipToSupportIfaceType(wifi_chip_, type, &mode_id));
         return mode_id;
     }
 
     uint32_t configureChipForStaIfaceAndGetCapabilities() {
-        configureChipForIfaceType(IfaceType::STA);
+        configureChipForIfaceType(IfaceType::STA, true);
         const auto& status_and_caps = HIDL_INVOKE(wifi_chip_, getCapabilities);
         EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_caps.first.code);
         return status_and_caps.second;
@@ -183,7 +182,7 @@
  * GetCapabilities:
  */
 TEST_F(WifiChipHidlTest, GetCapabilities) {
-    configureChipForIfaceType(IfaceType::STA);
+    configureChipForIfaceType(IfaceType::STA, true);
     const auto& status_and_caps = HIDL_INVOKE(wifi_chip_, getCapabilities);
     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_caps.first.code);
     EXPECT_NE(0u, status_and_caps.second);
@@ -193,7 +192,7 @@
  * GetMode:
  */
 TEST_F(WifiChipHidlTest, GetMode) {
-    ChipModeId chip_mode_id = configureChipForIfaceType(IfaceType::STA);
+    ChipModeId chip_mode_id = configureChipForIfaceType(IfaceType::STA, true);
     const auto& status_and_mode = HIDL_INVOKE(wifi_chip_, getMode);
     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_mode.first.code);
     EXPECT_EQ(chip_mode_id, status_and_mode.second);
@@ -203,7 +202,7 @@
  * RequestChipDebugInfo:
  */
 TEST_F(WifiChipHidlTest, RequestChipDebugInfo) {
-    configureChipForIfaceType(IfaceType::STA);
+    configureChipForIfaceType(IfaceType::STA, true);
     const auto& status_and_chip_info =
         HIDL_INVOKE(wifi_chip_, requestChipDebugInfo);
     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_chip_info.first.code);
@@ -236,8 +235,10 @@
     if (caps & IWifiChip::ChipCapabilityMask::DEBUG_MEMORY_DRIVER_DUMP) {
         EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_driver_dump.first.code);
     } else {
-        EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED,
-                  status_and_driver_dump.first.code);
+      // API semantics (today) are such that function cannot be called if not capable!
+      //
+      //  EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED,
+      //            status_and_driver_dump.first.code);
     }
 }
 
@@ -336,7 +337,7 @@
  * succeeds. The 2nd iface creation should be rejected.
  */
 TEST_F(WifiChipHidlTest, CreateApIface) {
-    configureChipForIfaceType(IfaceType::AP);
+    configureChipForIfaceType(IfaceType::AP, true);
 
     sp<IWifiApIface> iface;
     EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&iface));
@@ -352,7 +353,7 @@
  * iface name is returned via the list.
  */
 TEST_F(WifiChipHidlTest, GetApIfaceNames) {
-    configureChipForIfaceType(IfaceType::AP);
+    configureChipForIfaceType(IfaceType::AP, true);
 
     const auto& status_and_iface_names1 =
         HIDL_INVOKE(wifi_chip_, getApIfaceNames);
@@ -384,7 +385,7 @@
  * doesn't retrieve an iface object.
  */
 TEST_F(WifiChipHidlTest, GetApIface) {
-    configureChipForIfaceType(IfaceType::AP);
+    configureChipForIfaceType(IfaceType::AP, true);
 
     sp<IWifiApIface> ap_iface;
     EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&ap_iface));
@@ -410,7 +411,7 @@
  * doesn't remove the iface.
  */
 TEST_F(WifiChipHidlTest, RemoveApIface) {
-    configureChipForIfaceType(IfaceType::AP);
+    configureChipForIfaceType(IfaceType::AP, true);
 
     sp<IWifiApIface> ap_iface;
     EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&ap_iface));
@@ -431,13 +432,10 @@
  * succeeds. The 2nd iface creation should be rejected.
  */
 TEST_F(WifiChipHidlTest, CreateNanIface) {
-    configureChipForIfaceType(IfaceType::NAN);
+    configureChipForIfaceType(IfaceType::NAN, false);
 
     sp<IWifiNanIface> iface;
-    EXPECT_EQ(WifiStatusCode::SUCCESS, createNanIface(&iface));
-    EXPECT_NE(nullptr, iface.get());
-
-    EXPECT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createNanIface(&iface));
+    ASSERT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createNanIface(&iface));
 }
 
 /*
@@ -447,29 +445,12 @@
  * iface name is returned via the list.
  */
 TEST_F(WifiChipHidlTest, GetNanIfaceNames) {
-    configureChipForIfaceType(IfaceType::NAN);
+    configureChipForIfaceType(IfaceType::NAN, false);
 
     const auto& status_and_iface_names1 =
         HIDL_INVOKE(wifi_chip_, getNanIfaceNames);
-    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names1.first.code);
+    ASSERT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names1.first.code);
     EXPECT_EQ(0u, status_and_iface_names1.second.size());
-
-    sp<IWifiNanIface> iface;
-    EXPECT_EQ(WifiStatusCode::SUCCESS, createNanIface(&iface));
-    EXPECT_NE(nullptr, iface.get());
-
-    std::string iface_name = getIfaceName(iface);
-    const auto& status_and_iface_names2 =
-        HIDL_INVOKE(wifi_chip_, getNanIfaceNames);
-    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names2.first.code);
-    EXPECT_EQ(1u, status_and_iface_names2.second.size());
-    EXPECT_EQ(iface_name, status_and_iface_names2.second[0]);
-
-    EXPECT_EQ(WifiStatusCode::SUCCESS, removeNanIface(iface_name));
-    const auto& status_and_iface_names3 =
-        HIDL_INVOKE(wifi_chip_, getNanIfaceNames);
-    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names3.first.code);
-    EXPECT_EQ(0u, status_and_iface_names3.second.size());
 }
 
 /*
@@ -479,23 +460,10 @@
  * doesn't retrieve an iface object.
  */
 TEST_F(WifiChipHidlTest, GetNanIface) {
-    configureChipForIfaceType(IfaceType::NAN);
+    configureChipForIfaceType(IfaceType::NAN, false);
 
     sp<IWifiNanIface> nan_iface;
-    EXPECT_EQ(WifiStatusCode::SUCCESS, createNanIface(&nan_iface));
-    EXPECT_NE(nullptr, nan_iface.get());
-
-    std::string iface_name = getIfaceName(nan_iface);
-    const auto& status_and_iface1 =
-        HIDL_INVOKE(wifi_chip_, getNanIface, iface_name);
-    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface1.first.code);
-    EXPECT_NE(nullptr, status_and_iface1.second.get());
-
-    std::string invalid_name = iface_name + "0";
-    const auto& status_and_iface2 =
-        HIDL_INVOKE(wifi_chip_, getNanIface, invalid_name);
-    EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, status_and_iface2.first.code);
-    EXPECT_EQ(nullptr, status_and_iface2.second.get());
+    ASSERT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createNanIface(&nan_iface));
 }
 
 /*
@@ -505,20 +473,10 @@
  * doesn't remove the iface.
  */
 TEST_F(WifiChipHidlTest, RemoveNanIface) {
-    configureChipForIfaceType(IfaceType::NAN);
+    configureChipForIfaceType(IfaceType::NAN, false);
 
     sp<IWifiNanIface> nan_iface;
-    EXPECT_EQ(WifiStatusCode::SUCCESS, createNanIface(&nan_iface));
-    EXPECT_NE(nullptr, nan_iface.get());
-
-    std::string iface_name = getIfaceName(nan_iface);
-    std::string invalid_name = iface_name + "0";
-    EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeNanIface(invalid_name));
-
-    EXPECT_EQ(WifiStatusCode::SUCCESS, removeNanIface(iface_name));
-
-    // No such iface exists now. So, this should return failure.
-    EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeNanIface(iface_name));
+    ASSERT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createNanIface(&nan_iface));
 }
 
 /*
@@ -527,7 +485,7 @@
  * succeeds. The 2nd iface creation should be rejected.
  */
 TEST_F(WifiChipHidlTest, CreateP2pIface) {
-    configureChipForIfaceType(IfaceType::P2P);
+    configureChipForIfaceType(IfaceType::P2P, true);
 
     sp<IWifiP2pIface> iface;
     EXPECT_EQ(WifiStatusCode::SUCCESS, createP2pIface(&iface));
@@ -543,7 +501,7 @@
  * iface name is returned via the list.
  */
 TEST_F(WifiChipHidlTest, GetP2pIfaceNames) {
-    configureChipForIfaceType(IfaceType::P2P);
+    configureChipForIfaceType(IfaceType::P2P, true);
 
     const auto& status_and_iface_names1 =
         HIDL_INVOKE(wifi_chip_, getP2pIfaceNames);
@@ -575,7 +533,7 @@
  * doesn't retrieve an iface object.
  */
 TEST_F(WifiChipHidlTest, GetP2pIface) {
-    configureChipForIfaceType(IfaceType::P2P);
+    configureChipForIfaceType(IfaceType::P2P, true);
 
     sp<IWifiP2pIface> p2p_iface;
     EXPECT_EQ(WifiStatusCode::SUCCESS, createP2pIface(&p2p_iface));
@@ -601,7 +559,7 @@
  * doesn't remove the iface.
  */
 TEST_F(WifiChipHidlTest, RemoveP2pIface) {
-    configureChipForIfaceType(IfaceType::P2P);
+    configureChipForIfaceType(IfaceType::P2P, true);
 
     sp<IWifiP2pIface> p2p_iface;
     EXPECT_EQ(WifiStatusCode::SUCCESS, createP2pIface(&p2p_iface));
@@ -622,7 +580,7 @@
  * succeeds. The 2nd iface creation should be rejected.
  */
 TEST_F(WifiChipHidlTest, CreateStaIface) {
-    configureChipForIfaceType(IfaceType::STA);
+    configureChipForIfaceType(IfaceType::STA, true);
 
     sp<IWifiStaIface> iface;
     EXPECT_EQ(WifiStatusCode::SUCCESS, createStaIface(&iface));
@@ -638,7 +596,7 @@
  * iface name is returned via the list.
  */
 TEST_F(WifiChipHidlTest, GetStaIfaceNames) {
-    configureChipForIfaceType(IfaceType::STA);
+    configureChipForIfaceType(IfaceType::STA, true);
 
     const auto& status_and_iface_names1 =
         HIDL_INVOKE(wifi_chip_, getStaIfaceNames);
@@ -670,7 +628,7 @@
  * doesn't retrieve an iface object.
  */
 TEST_F(WifiChipHidlTest, GetStaIface) {
-    configureChipForIfaceType(IfaceType::STA);
+    configureChipForIfaceType(IfaceType::STA, true);
 
     sp<IWifiStaIface> sta_iface;
     EXPECT_EQ(WifiStatusCode::SUCCESS, createStaIface(&sta_iface));
@@ -696,7 +654,7 @@
  * doesn't remove the iface.
  */
 TEST_F(WifiChipHidlTest, RemoveStaIface) {
-    configureChipForIfaceType(IfaceType::STA);
+    configureChipForIfaceType(IfaceType::STA, true);
 
     sp<IWifiStaIface> sta_iface;
     EXPECT_EQ(WifiStatusCode::SUCCESS, createStaIface(&sta_iface));
@@ -715,7 +673,7 @@
  * CreateRttController
  */
 TEST_F(WifiChipHidlTest, CreateRttController) {
-    configureChipForIfaceType(IfaceType::AP);
+    configureChipForIfaceType(IfaceType::AP, true);
 
     sp<IWifiApIface> iface;
     EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&iface));
diff --git a/wifi/1.0/vts/functional/wifi_sta_iface_hidl_test.cpp b/wifi/1.0/vts/functional/wifi_sta_iface_hidl_test.cpp
index 95add61..83f83b6 100644
--- a/wifi/1.0/vts/functional/wifi_sta_iface_hidl_test.cpp
+++ b/wifi/1.0/vts/functional/wifi_sta_iface_hidl_test.cpp
@@ -24,7 +24,16 @@
 #include "wifi_hidl_test_utils.h"
 
 using ::android::sp;
+using ::android::hardware::wifi::V1_0::Bssid;
+using ::android::hardware::wifi::V1_0::CommandId;
+using ::android::hardware::wifi::V1_0::IfaceType;
 using ::android::hardware::wifi::V1_0::IWifiStaIface;
+using ::android::hardware::wifi::V1_0::Rssi;
+using ::android::hardware::wifi::V1_0::Ssid;
+using ::android::hardware::wifi::V1_0::StaApfPacketFilterCapabilities;
+using ::android::hardware::wifi::V1_0::StaRoamingConfig;
+using ::android::hardware::wifi::V1_0::StaRoamingState;
+using ::android::hardware::wifi::V1_0::WifiBand;
 using ::android::hardware::wifi::V1_0::WifiStatus;
 using ::android::hardware::wifi::V1_0::WifiStatusCode;
 
@@ -41,6 +50,13 @@
     virtual void TearDown() override { stopWifi(); }
 
    protected:
+    bool isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask cap_mask) {
+        const auto& status_and_caps =
+            HIDL_INVOKE(wifi_sta_iface_, getCapabilities);
+        EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_caps.first.code);
+        return (status_and_caps.second & cap_mask) != 0;
+    }
+
     sp<IWifiStaIface> wifi_sta_iface_;
 };
 
@@ -60,5 +76,190 @@
 TEST_F(WifiStaIfaceHidlTest, GetCapabilities) {
     const auto& status_and_caps = HIDL_INVOKE(wifi_sta_iface_, getCapabilities);
     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_caps.first.code);
-    EXPECT_NE(0u, status_and_caps.second);
+    EXPECT_GT(status_and_caps.second, 0u);
+}
+
+/*
+ * GetType:
+ * Ensures that the correct interface type is returned for station interface.
+ */
+TEST_F(WifiStaIfaceHidlTest, GetType) {
+    const auto& status_and_type = HIDL_INVOKE(wifi_sta_iface_, getType);
+    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_type.first.code);
+    EXPECT_EQ(IfaceType::STA, status_and_type.second);
+}
+
+/*
+ * GetApfPacketFilterCapabilities:
+ * Ensures that we can retrieve APF packet filter capabilites.
+ */
+TEST_F(WifiStaIfaceHidlTest, GetApfPacketFilterCapabilities) {
+    if (!isCapabilitySupported(IWifiStaIface::StaIfaceCapabilityMask::APF)) {
+        // No-op if APF packet filer is not supported.
+        return;
+    }
+
+    const auto& status_and_caps =
+        HIDL_INVOKE(wifi_sta_iface_, getApfPacketFilterCapabilities);
+    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_caps.first.code);
+}
+
+/*
+ * GetBackgroundScanCapabilities:
+ * Ensures that we can retrieve background scan capabilities.
+ */
+TEST_F(WifiStaIfaceHidlTest, GetBackgroundScanCapabilities) {
+    if (!isCapabilitySupported(
+            IWifiStaIface::StaIfaceCapabilityMask::BACKGROUND_SCAN)) {
+        // No-op if background scan is not supported.
+        return;
+    }
+
+    const auto& status_and_caps =
+        HIDL_INVOKE(wifi_sta_iface_, getBackgroundScanCapabilities);
+    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_caps.first.code);
+}
+
+/*
+ * GetValidFrequenciesForBand:
+ * Ensures that we can retrieve valid frequencies for 2.4 GHz band.
+ */
+TEST_F(WifiStaIfaceHidlTest, GetValidFrequenciesForBand) {
+    const auto& status_and_freqs = HIDL_INVOKE(
+        wifi_sta_iface_, getValidFrequenciesForBand, WifiBand::BAND_24GHZ);
+    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_freqs.first.code);
+    EXPECT_GT(status_and_freqs.second.size(), 0u);
+}
+
+/*
+ * LinkLayerStatsCollection:
+ * Ensures that calls to enable, disable, and retrieve link layer stats
+ * will return a success status code.
+ */
+TEST_F(WifiStaIfaceHidlTest, LinkLayerStatsCollection) {
+    if (!isCapabilitySupported(
+            IWifiStaIface::StaIfaceCapabilityMask::LINK_LAYER_STATS)) {
+        // No-op if link layer stats is not supported.
+        return;
+    }
+
+    // Enable link layer stats collection.
+    EXPECT_EQ(WifiStatusCode::SUCCESS,
+              HIDL_INVOKE(wifi_sta_iface_, enableLinkLayerStatsCollection, true)
+                  .code);
+    // Retrieve link layer stats.
+    EXPECT_EQ(WifiStatusCode::SUCCESS,
+              HIDL_INVOKE(wifi_sta_iface_, getLinkLayerStats).first.code);
+    // Disable link layer stats collection.
+    EXPECT_EQ(
+        WifiStatusCode::SUCCESS,
+        HIDL_INVOKE(wifi_sta_iface_, disableLinkLayerStatsCollection).code);
+}
+
+/*
+ * RSSIMonitoring:
+ * Ensures that calls to enable and disable RSSI monitoring will return
+ * a success status code.
+ */
+TEST_F(WifiStaIfaceHidlTest, RSSIMonitoring) {
+    if (!isCapabilitySupported(
+            IWifiStaIface::StaIfaceCapabilityMask::RSSI_MONITOR)) {
+        // No-op if RSSI monitor is not supported.
+        return;
+    }
+
+    const CommandId kCmd = 1;
+    const Rssi kMaxRssi = -50;
+    const Rssi kMinRssi = -90;
+    EXPECT_EQ(WifiStatusCode::SUCCESS,
+              HIDL_INVOKE(wifi_sta_iface_, startRssiMonitoring, kCmd, kMaxRssi,
+                          kMinRssi)
+                  .code);
+    EXPECT_EQ(WifiStatusCode::SUCCESS,
+              HIDL_INVOKE(wifi_sta_iface_, stopRssiMonitoring, kCmd).code);
+}
+
+/*
+ * RoamingControl:
+ * Ensures that calls to configure and enable roaming will return a success
+ * status code.
+ */
+TEST_F(WifiStaIfaceHidlTest, RoamingControl) {
+    if (!isCapabilitySupported(
+            IWifiStaIface::StaIfaceCapabilityMask::CONTROL_ROAMING)) {
+        // No-op if roaming control is not supported.
+        return;
+    }
+
+    // Retrieve roaming capabilities.
+    const auto& status_and_cap =
+        HIDL_INVOKE(wifi_sta_iface_, getRoamingCapabilities);
+    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_cap.first.code);
+
+    // Setup roaming configuration based on roaming capabilities.
+    const auto& cap = status_and_cap.second;
+    StaRoamingConfig roaming_config;
+    if (cap.maxBlacklistSize > 0) {
+        Bssid black_list_bssid{
+            std::array<uint8_t, 6>{{0x11, 0x22, 0x33, 0x44, 0x55, 0x66}}};
+        roaming_config.bssidBlacklist =
+            android::hardware::hidl_vec<Bssid>{black_list_bssid};
+    }
+    if (cap.maxWhitelistSize > 0) {
+        Ssid white_list_ssid{
+            std::array<uint8_t, 32>{{0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC}}};
+        roaming_config.ssidWhitelist =
+            android::hardware::hidl_vec<Ssid>{white_list_ssid};
+    }
+
+    // Configure roaming.
+    EXPECT_EQ(
+        WifiStatusCode::SUCCESS,
+        HIDL_INVOKE(wifi_sta_iface_, configureRoaming, roaming_config).code);
+
+    // Enable roaming.
+    EXPECT_EQ(
+        WifiStatusCode::SUCCESS,
+        HIDL_INVOKE(wifi_sta_iface_, setRoamingState, StaRoamingState::ENABLED)
+            .code);
+}
+
+/*
+ * EnableNDOffload:
+ * Ensures that calls to enable neighbor discovery offload will return a success
+ * status code.
+ */
+TEST_F(WifiStaIfaceHidlTest, EnableNDOffload) {
+    EXPECT_EQ(WifiStatusCode::SUCCESS,
+              HIDL_INVOKE(wifi_sta_iface_, enableNdOffload, true).code);
+}
+
+/*
+ * SetScanningMacOui:
+ * Ensures that calls to set scanning MAC OUI will return a success status
+ * code.
+ */
+TEST_F(WifiStaIfaceHidlTest, SetScanningMacOui) {
+    const android::hardware::hidl_array<uint8_t, 3> kOui{
+        std::array<uint8_t, 3>{{0x10, 0x22, 0x33}}};
+    EXPECT_EQ(WifiStatusCode::SUCCESS,
+              HIDL_INVOKE(wifi_sta_iface_, setScanningMacOui, kOui).code);
+}
+
+/*
+ * PacketFateMonitoring:
+ * Ensures that calls to start packet fate monitoring and retrieve TX/RX
+ * packets will return a success status code.
+ */
+TEST_F(WifiStaIfaceHidlTest, PacketFateMonitoring) {
+    // Start packet fate monitoring.
+    EXPECT_EQ(
+        WifiStatusCode::SUCCESS,
+        HIDL_INVOKE(wifi_sta_iface_, startDebugPacketFateMonitoring).code);
+
+    // Retrieve packets.
+    EXPECT_EQ(WifiStatusCode::SUCCESS,
+              HIDL_INVOKE(wifi_sta_iface_, getDebugTxPacketFates).first.code);
+    EXPECT_EQ(WifiStatusCode::SUCCESS,
+              HIDL_INVOKE(wifi_sta_iface_, getDebugRxPacketFates).first.code);
 }