diff --git a/bluetooth/1.0/default/vendor_interface.cc b/bluetooth/1.0/default/vendor_interface.cc
index 2576eca..57ea1a3 100644
--- a/bluetooth/1.0/default/vendor_interface.cc
+++ b/bluetooth/1.0/default/vendor_interface.cc
@@ -215,11 +215,9 @@
 
   ALOGD("%s vendor library loaded", __func__);
 
-  // Power cycle chip
+  // Power on the controller
 
-  int power_state = BT_VND_PWR_OFF;
-  lib_interface_->op(BT_VND_OP_POWER_CTRL, &power_state);
-  power_state = BT_VND_PWR_ON;
+  int power_state = BT_VND_PWR_ON;
   lib_interface_->op(BT_VND_OP_POWER_CTRL, &power_state);
 
   // Get the UART socket(s)
@@ -273,9 +271,6 @@
   if (lib_interface_ != nullptr) {
     bt_vendor_lpm_mode_t mode = BT_VND_LPM_DISABLE;
     lib_interface_->op(BT_VND_OP_LPM_SET_MODE, &mode);
-
-    int power_state = BT_VND_PWR_OFF;
-    lib_interface_->op(BT_VND_OP_POWER_CTRL, &power_state);
   }
 
   fd_watcher_.StopWatchingFileDescriptors();
@@ -287,6 +282,9 @@
 
   if (lib_interface_ != nullptr) {
     lib_interface_->op(BT_VND_OP_USERIAL_CLOSE, nullptr);
+
+    int power_state = BT_VND_PWR_OFF;
+    lib_interface_->op(BT_VND_OP_POWER_CTRL, &power_state);
   }
 
   if (lib_handle_ != nullptr) {
diff --git a/bluetooth/1.0/vts/functional/Android.bp b/bluetooth/1.0/vts/functional/Android.bp
index cb1abe8..d2e6553 100644
--- a/bluetooth/1.0/vts/functional/Android.bp
+++ b/bluetooth/1.0/vts/functional/Android.bp
@@ -28,7 +28,7 @@
         "libutils",
         "android.hardware.bluetooth@1.0",
     ],
-    static_libs: ["VtsHalHidlTargetBaseTest"],
+    static_libs: ["VtsHalHidlTargetTestBase"],
     cflags: [
         "-O0",
         "-g",
diff --git a/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp b/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp
index c8c7cb5..9a4efae 100644
--- a/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp
+++ b/bluetooth/1.0/vts/functional/VtsHalBluetoothV1_0TargetTest.cpp
@@ -23,7 +23,7 @@
 #include <hardware/bluetooth.h>
 #include <utils/Log.h>
 
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 #include <condition_variable>
 #include <mutex>
 #include <queue>
@@ -117,11 +117,11 @@
 };
 
 // The main test class for Bluetooth HIDL HAL.
-class BluetoothHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
+class BluetoothHidlTest : public ::testing::VtsHalHidlTargetTestBase {
  public:
   virtual void SetUp() override {
     // currently test passthrough mode only
-    bluetooth = ::testing::VtsHalHidlTargetBaseTest::getService<IBluetoothHci>();
+    bluetooth = ::testing::VtsHalHidlTargetTestBase::getService<IBluetoothHci>();
     ASSERT_NE(bluetooth, nullptr);
     ALOGI("%s: getService() for bluetooth is %s", __func__,
           bluetooth->isRemote() ? "remote" : "local");
diff --git a/ir/1.0/vts/functional/Android.bp b/ir/1.0/vts/functional/Android.bp
index 8076126..4aac297 100644
--- a/ir/1.0/vts/functional/Android.bp
+++ b/ir/1.0/vts/functional/Android.bp
@@ -27,7 +27,7 @@
         "libutils",
         "android.hardware.ir@1.0",
     ],
-    static_libs: ["VtsHalHidlTargetBaseTest"],
+    static_libs: ["VtsHalHidlTargetTestBase"],
     cflags: [
         "-O0",
         "-g",
diff --git a/ir/1.0/vts/functional/VtsHalIrV1_0TargetTest.cpp b/ir/1.0/vts/functional/VtsHalIrV1_0TargetTest.cpp
index ead41c8..3dad3c1 100644
--- a/ir/1.0/vts/functional/VtsHalIrV1_0TargetTest.cpp
+++ b/ir/1.0/vts/functional/VtsHalIrV1_0TargetTest.cpp
@@ -21,7 +21,7 @@
 #include <android/hardware/ir/1.0/IConsumerIr.h>
 #include <android/hardware/ir/1.0/types.h>
 
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 #include <algorithm>
 
 using ::android::hardware::ir::V1_0::IConsumerIr;
@@ -31,10 +31,10 @@
 using ::android::sp;
 
 // The main test class for IR HIDL HAL.
-class ConsumerIrHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
+class ConsumerIrHidlTest : public ::testing::VtsHalHidlTargetTestBase {
  public:
   virtual void SetUp() override {
-    ir = ::testing::VtsHalHidlTargetBaseTest::getService<IConsumerIr>();
+    ir = ::testing::VtsHalHidlTargetTestBase::getService<IConsumerIr>();
     ASSERT_NE(ir, nullptr);
   }
 
diff --git a/nfc/1.0/vts/functional/Android.bp b/nfc/1.0/vts/functional/Android.bp
index f0359dc..d9ba702 100644
--- a/nfc/1.0/vts/functional/Android.bp
+++ b/nfc/1.0/vts/functional/Android.bp
@@ -28,7 +28,7 @@
         "libutils",
         "android.hardware.nfc@1.0",
     ],
-    static_libs: ["VtsHalHidlTargetBaseTest"],
+    static_libs: ["VtsHalHidlTargetTestBase"],
     cflags: [
         "-O0",
         "-g",
diff --git a/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp b/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp
index 4aa6d7e..aa3bc9c 100644
--- a/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp
+++ b/nfc/1.0/vts/functional/VtsHalNfcV1_0TargetTest.cpp
@@ -22,7 +22,7 @@
 #include <android/hardware/nfc/1.0/types.h>
 #include <hardware/nfc.h>
 
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 #include <chrono>
 #include <condition_variable>
 #include <mutex>
@@ -56,10 +56,10 @@
 #define TIMEOUT_PERIOD 5
 
 // The main test class for NFC HIDL HAL.
-class NfcHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
+class NfcHidlTest : public ::testing::VtsHalHidlTargetTestBase {
  public:
   virtual void SetUp() override {
-    nfc_ = ::testing::VtsHalHidlTargetBaseTest::getService<INfc>();
+    nfc_ = ::testing::VtsHalHidlTargetTestBase::getService<INfc>();
     ASSERT_NE(nfc_, nullptr);
 
     nfc_cb_ = new NfcClientCallback(*this);
diff --git a/radio/1.0/vts/functional/Android.bp b/radio/1.0/vts/functional/Android.bp
index 67309ca..7f16163 100644
--- a/radio/1.0/vts/functional/Android.bp
+++ b/radio/1.0/vts/functional/Android.bp
@@ -33,7 +33,7 @@
         "libutils",
         "android.hardware.radio@1.0",
     ],
-    static_libs: ["VtsHalHidlTargetBaseTest"],
+    static_libs: ["VtsHalHidlTargetTestBase"],
     cflags: [
         "-O0",
         "-g",
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_test.cpp b/radio/1.0/vts/functional/radio_hidl_hal_test.cpp
index 50b27e9..db7356f 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_test.cpp
+++ b/radio/1.0/vts/functional/radio_hidl_hal_test.cpp
@@ -17,7 +17,7 @@
 #include<radio_hidl_hal_utils.h>
 
 void RadioHidlTest::SetUp() {
-    radio = ::testing::VtsHalHidlTargetBaseTest::getService<IRadio>(hidl_string("rild"));
+    radio = ::testing::VtsHalHidlTargetTestBase::getService<IRadio>(hidl_string("rild"));
     ASSERT_NE(radio, nullptr);
 
     radioRsp = new RadioResponse(*this);
diff --git a/radio/1.0/vts/functional/radio_hidl_hal_utils.h b/radio/1.0/vts/functional/radio_hidl_hal_utils.h
index 04d4563..bb693ac 100644
--- a/radio/1.0/vts/functional/radio_hidl_hal_utils.h
+++ b/radio/1.0/vts/functional/radio_hidl_hal_utils.h
@@ -16,7 +16,7 @@
 
 #include <android-base/logging.h>
 
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 #include <chrono>
 #include <condition_variable>
 #include <mutex>
@@ -435,7 +435,7 @@
 };
 
 // The main test class for Radio HIDL.
-class RadioHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
+class RadioHidlTest : public ::testing::VtsHalHidlTargetTestBase {
 private:
     std::mutex mtx;
     std::condition_variable cv;
diff --git a/wifi/1.0/default/Android.mk b/wifi/1.0/default/Android.mk
index 00e5f98..cc5e1c6 100644
--- a/wifi/1.0/default/Android.mk
+++ b/wifi/1.0/default/Android.mk
@@ -18,6 +18,9 @@
 LOCAL_MODULE_RELATIVE_PATH := hw
 LOCAL_PROPRIETARY_MODULE := true
 LOCAL_CPPFLAGS := -Wall -Werror -Wextra
+ifdef WIFI_HIDL_FEATURE_AWARE
+LOCAL_CPPFLAGS += -DWIFI_HIDL_FEATURE_AWARE
+endif
 LOCAL_SRC_FILES := \
     hidl_struct_util.cpp \
     hidl_sync_util.cpp \
@@ -43,7 +46,8 @@
     libnl \
     libutils \
     libwifi-hal \
-    libwifi-system
+    libwifi-system \
+    libcld80211
 LOCAL_WHOLE_STATIC_LIBRARIES := $(LIB_WIFI_HAL)
 LOCAL_INIT_RC := android.hardware.wifi@1.0-service.rc
 include $(BUILD_EXECUTABLE)
diff --git a/wifi/1.0/default/hidl_struct_util.cpp b/wifi/1.0/default/hidl_struct_util.cpp
index 98a62bf..a89f8c0 100644
--- a/wifi/1.0/default/hidl_struct_util.cpp
+++ b/wifi/1.0/default/hidl_struct_util.cpp
@@ -1898,10 +1898,12 @@
   hidl_result->timeStampInUs = legacy_result.ts;
   hidl_result->burstDurationInMs = legacy_result.burst_duration;
   hidl_result->negotiatedBurstNum = legacy_result.negotiated_burst_num;
-  if (!convertLegacyIeToHidl(*legacy_result.LCI, &hidl_result->lci)) {
+  if (legacy_result.LCI && !convertLegacyIeToHidl(*legacy_result.LCI,
+                                                  &hidl_result->lci)) {
     return false;
   }
-  if (!convertLegacyIeToHidl(*legacy_result.LCR, &hidl_result->lcr)) {
+  if (legacy_result.LCR && !convertLegacyIeToHidl(*legacy_result.LCR,
+                                                  &hidl_result->lcr)) {
     return false;
   }
   return true;
diff --git a/wifi/1.0/default/wifi_chip.cpp b/wifi/1.0/default/wifi_chip.cpp
index 6f980c0..9c41a40 100644
--- a/wifi/1.0/default/wifi_chip.cpp
+++ b/wifi/1.0/default/wifi_chip.cpp
@@ -19,6 +19,7 @@
 #include "hidl_return_util.h"
 #include "hidl_struct_util.h"
 #include "wifi_chip.h"
+#include "wifi_feature_flags.h"
 #include "wifi_status_util.h"
 
 namespace {
@@ -388,16 +389,21 @@
   // The chip combination supported for current devices is fixed for now with
   // 2 separate modes of operation:
   // Mode 1 (STA mode): Will support 1 STA and 1 P2P or NAN iface operations
-  // concurrently.
+  // concurrently [NAN conditional on wifiHidlFeatureAware]
   // Mode 2 (AP mode): Will support 1 AP iface operations.
   // TODO (b/32997844): Read this from some device specific flags in the
   // makefile.
   // STA mode iface combinations.
   const IWifiChip::ChipIfaceCombinationLimit
       sta_chip_iface_combination_limit_1 = {{IfaceType::STA}, 1};
-  const IWifiChip::ChipIfaceCombinationLimit
-      sta_chip_iface_combination_limit_2 = {{IfaceType::P2P, IfaceType::NAN},
-                                            1};
+  IWifiChip::ChipIfaceCombinationLimit sta_chip_iface_combination_limit_2;
+  if (WifiFeatureFlags::wifiHidlFeatureAware) {
+    sta_chip_iface_combination_limit_2 = {{IfaceType::P2P, IfaceType::NAN},
+                                          1};
+  } else {
+    sta_chip_iface_combination_limit_2 = {{IfaceType::P2P},
+                                          1};
+  }
   const IWifiChip::ChipIfaceCombination sta_chip_iface_combination = {
       {sta_chip_iface_combination_limit_1, sta_chip_iface_combination_limit_2}};
   const IWifiChip::ChipMode sta_chip_mode = {kStaChipModeId,
@@ -552,18 +558,22 @@
 
 std::pair<WifiStatus, sp<IWifiNanIface>> WifiChip::createNanIfaceInternal() {
   // Only 1 of NAN or P2P iface can be active at a time.
-  if (current_mode_id_ != kStaChipModeId || nan_iface_.get() ||
-      p2p_iface_.get()) {
+  if (WifiFeatureFlags::wifiHidlFeatureAware) {
+    if (current_mode_id_ != kStaChipModeId || nan_iface_.get() ||
+        p2p_iface_.get()) {
+      return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
+    }
+    std::string ifname = legacy_hal_.lock()->getNanIfaceName();
+    nan_iface_ = new WifiNanIface(ifname, legacy_hal_);
+    for (const auto& callback : event_cb_handler_.getCallbacks()) {
+      if (!callback->onIfaceAdded(IfaceType::NAN, ifname).isOk()) {
+        LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
+      }
+    }
+    return {createWifiStatus(WifiStatusCode::SUCCESS), nan_iface_};
+  } else {
     return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
   }
-  std::string ifname = legacy_hal_.lock()->getNanIfaceName();
-  nan_iface_ = new WifiNanIface(ifname, legacy_hal_);
-  for (const auto& callback : event_cb_handler_.getCallbacks()) {
-    if (!callback->onIfaceAdded(IfaceType::NAN, ifname).isOk()) {
-      LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
-    }
-  }
-  return {createWifiStatus(WifiStatusCode::SUCCESS), nan_iface_};
 }
 
 std::pair<WifiStatus, std::vector<hidl_string>>
diff --git a/wifi/1.0/default/wifi_feature_flags.h b/wifi/1.0/default/wifi_feature_flags.h
new file mode 100644
index 0000000..3502fbd
--- /dev/null
+++ b/wifi/1.0/default/wifi_feature_flags.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#ifndef WIFI_FEATURE_FLAGS_H_
+#define WIFI_FEATURE_FLAGS_H_
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_0 {
+namespace implementation {
+
+class WifiFeatureFlags {
+ public:
+#ifdef WIFI_HIDL_FEATURE_AWARE
+  static const bool wifiHidlFeatureAware = true;
+#else
+  static const bool wifiHidlFeatureAware = false;
+#endif // WIFI_HIDL_FEATURE_AWARE
+};
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
+
+#endif  // WIFI_FEATURE_FLAGS_H_
diff --git a/wifi/1.0/default/wifi_legacy_hal.cpp b/wifi/1.0/default/wifi_legacy_hal.cpp
index 7390b65..f902e64 100644
--- a/wifi/1.0/default/wifi_legacy_hal.cpp
+++ b/wifi/1.0/default/wifi_legacy_hal.cpp
@@ -59,6 +59,8 @@
   const auto lock = hidl_sync_util::acquireGlobalLock();
   if (on_stop_complete_internal_callback) {
     on_stop_complete_internal_callback(handle);
+    // Invalidate this callback since we don't want this firing again.
+    on_stop_complete_internal_callback = nullptr;
   }
 }
 
@@ -1261,7 +1263,6 @@
 void WifiLegacyHal::invalidate() {
   global_handle_ = nullptr;
   wlan_interface_handle_ = nullptr;
-  on_stop_complete_internal_callback = nullptr;
   on_driver_memory_dump_internal_callback = nullptr;
   on_firmware_memory_dump_internal_callback = nullptr;
   on_gscan_event_internal_callback = nullptr;
diff --git a/wifi/1.0/vts/functional/Android.bp b/wifi/1.0/vts/functional/Android.bp
index 11d0619..eab338b 100644
--- a/wifi/1.0/vts/functional/Android.bp
+++ b/wifi/1.0/vts/functional/Android.bp
@@ -38,7 +38,7 @@
         "libutils",
         "android.hardware.wifi@1.0",
     ],
-    static_libs: ["VtsHalHidlTargetBaseTest"],
+    static_libs: ["VtsHalHidlTargetTestBase"],
     cflags: [
         "-O0",
         "-g",
diff --git a/wifi/1.0/vts/functional/VtsHalWifiV1_0TargetTest.cpp b/wifi/1.0/vts/functional/VtsHalWifiV1_0TargetTest.cpp
index 51512a1..b56ed2b 100644
--- a/wifi/1.0/vts/functional/VtsHalWifiV1_0TargetTest.cpp
+++ b/wifi/1.0/vts/functional/VtsHalWifiV1_0TargetTest.cpp
@@ -16,7 +16,7 @@
 
 #include <android-base/logging.h>
 
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 
 #include "wifi_hidl_test_utils.h"
 
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 dd3df56..42d9a96 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
@@ -18,7 +18,7 @@
 
 #include <android/hardware/wifi/1.0/IWifiApIface.h>
 
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 
 #include "wifi_hidl_test_utils.h"
 
@@ -28,7 +28,7 @@
 /**
  * Fixture to use for all AP Iface HIDL interface tests.
  */
-class WifiApIfaceHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
+class WifiApIfaceHidlTest : public ::testing::VtsHalHidlTargetTestBase {
    public:
     virtual void SetUp() override {}
 
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 3c2ba9a..084067c 100644
--- a/wifi/1.0/vts/functional/wifi_chip_hidl_test.cpp
+++ b/wifi/1.0/vts/functional/wifi_chip_hidl_test.cpp
@@ -18,23 +18,125 @@
 
 #include <android/hardware/wifi/1.0/IWifiChip.h>
 
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 
+#include "wifi_hidl_call_util.h"
 #include "wifi_hidl_test_utils.h"
 
-using ::android::hardware::wifi::V1_0::IWifiChip;
 using ::android::sp;
+using ::android::hardware::hidl_string;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::wifi::V1_0::IfaceType;
+using ::android::hardware::wifi::V1_0::ChipId;
+using ::android::hardware::wifi::V1_0::ChipModeId;
+using ::android::hardware::wifi::V1_0::WifiDebugRingBufferStatus;
+using ::android::hardware::wifi::V1_0::WifiDebugRingBufferVerboseLevel;
+using ::android::hardware::wifi::V1_0::WifiDebugHostWakeReasonStats;
+using ::android::hardware::wifi::V1_0::WifiStatus;
+using ::android::hardware::wifi::V1_0::WifiStatusCode;
+using ::android::hardware::wifi::V1_0::IWifiChip;
+using ::android::hardware::wifi::V1_0::IWifiApIface;
+using ::android::hardware::wifi::V1_0::IWifiIface;
+using ::android::hardware::wifi::V1_0::IWifiNanIface;
+using ::android::hardware::wifi::V1_0::IWifiP2pIface;
+using ::android::hardware::wifi::V1_0::IWifiRttController;
+using ::android::hardware::wifi::V1_0::IWifiStaIface;
+
+namespace {
+constexpr WifiDebugRingBufferVerboseLevel kDebugRingBufferVerboseLvl =
+    WifiDebugRingBufferVerboseLevel::VERBOSE;
+constexpr uint32_t kDebugRingBufferMaxInterval = 5;
+constexpr uint32_t kDebugRingBufferMaxDataSize = 1024;
+
+/**
+ * Check if any of the ring buffer capabilities are set.
+ */
+bool hasAnyRingBufferCapabilities(uint32_t caps) {
+    return (caps &
+            (IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_CONNECT_EVENT |
+             IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_POWER_EVENT |
+             IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_WAKELOCK_EVENT |
+             IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_VENDOR_DATA));
+}
+}  // namespace
 
 /**
  * Fixture to use for all Wifi chip HIDL interface tests.
  */
-class WifiChipHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
+class WifiChipHidlTest : public ::testing::VtsHalHidlTargetTestBase {
    public:
-    virtual void SetUp() override {}
+    virtual void SetUp() override {
+        wifi_chip_ = getWifiChip();
+        ASSERT_NE(nullptr, wifi_chip_.get());
+    }
 
     virtual void TearDown() override { stopWifi(); }
 
    protected:
+    // 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 mode_id;
+        EXPECT_TRUE(
+            configureChipToSupportIfaceType(wifi_chip_, type, &mode_id));
+        return mode_id;
+    }
+
+    uint32_t configureChipForStaIfaceAndGetCapabilities() {
+        configureChipForIfaceType(IfaceType::STA);
+        const auto& status_and_caps = HIDL_INVOKE(wifi_chip_, getCapabilities);
+        EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_caps.first.code);
+        return status_and_caps.second;
+    }
+
+    std::string getIfaceName(const sp<IWifiIface>& iface) {
+        const auto& status_and_name = HIDL_INVOKE(iface, getName);
+        EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_name.first.code);
+        return status_and_name.second;
+    }
+
+    WifiStatusCode createApIface(sp<IWifiApIface>* ap_iface) {
+        const auto& status_and_iface = HIDL_INVOKE(wifi_chip_, createApIface);
+        *ap_iface = status_and_iface.second;
+        return status_and_iface.first.code;
+    }
+
+    WifiStatusCode removeApIface(const std::string& name) {
+        return HIDL_INVOKE(wifi_chip_, removeApIface, name).code;
+    }
+
+    WifiStatusCode createNanIface(sp<IWifiNanIface>* nan_iface) {
+        const auto& status_and_iface = HIDL_INVOKE(wifi_chip_, createNanIface);
+        *nan_iface = status_and_iface.second;
+        return status_and_iface.first.code;
+    }
+
+    WifiStatusCode removeNanIface(const std::string& name) {
+        return HIDL_INVOKE(wifi_chip_, removeNanIface, name).code;
+    }
+
+    WifiStatusCode createP2pIface(sp<IWifiP2pIface>* p2p_iface) {
+        const auto& status_and_iface = HIDL_INVOKE(wifi_chip_, createP2pIface);
+        *p2p_iface = status_and_iface.second;
+        return status_and_iface.first.code;
+    }
+
+    WifiStatusCode removeP2pIface(const std::string& name) {
+        return HIDL_INVOKE(wifi_chip_, removeP2pIface, name).code;
+    }
+
+    WifiStatusCode createStaIface(sp<IWifiStaIface>* sta_iface) {
+        const auto& status_and_iface = HIDL_INVOKE(wifi_chip_, createStaIface);
+        *sta_iface = status_and_iface.second;
+        return status_and_iface.first.code;
+    }
+
+    WifiStatusCode removeStaIface(const std::string& name) {
+        return HIDL_INVOKE(wifi_chip_, removeStaIface, name).code;
+    }
+
+    sp<IWifiChip> wifi_chip_;
 };
 
 /*
@@ -46,3 +148,581 @@
     EXPECT_NE(nullptr, getWifiChip().get());
     stopWifi();
 }
+
+/*
+ * GetId:
+ */
+TEST_F(WifiChipHidlTest, GetId) {
+    EXPECT_EQ(WifiStatusCode::SUCCESS,
+              HIDL_INVOKE(wifi_chip_, getId).first.code);
+}
+
+/*
+ * GetAvailableMode:
+ */
+TEST_F(WifiChipHidlTest, GetAvailableModes) {
+    const auto& status_and_modes = HIDL_INVOKE(wifi_chip_, getAvailableModes);
+    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_modes.first.code);
+    EXPECT_LT(0u, status_and_modes.second.size());
+}
+
+/*
+ * ConfigureChip:
+ */
+TEST_F(WifiChipHidlTest, ConfigureChip) {
+    const auto& status_and_modes = HIDL_INVOKE(wifi_chip_, getAvailableModes);
+    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_modes.first.code);
+    EXPECT_LT(0u, status_and_modes.second.size());
+    for (const auto& mode : status_and_modes.second) {
+        EXPECT_EQ(WifiStatusCode::SUCCESS,
+                  HIDL_INVOKE(wifi_chip_, configureChip, mode.id).code);
+    }
+}
+
+/*
+ * GetCapabilities:
+ */
+TEST_F(WifiChipHidlTest, GetCapabilities) {
+    configureChipForIfaceType(IfaceType::STA);
+    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);
+}
+
+/*
+ * GetMode:
+ */
+TEST_F(WifiChipHidlTest, GetMode) {
+    ChipModeId chip_mode_id = configureChipForIfaceType(IfaceType::STA);
+    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);
+}
+
+/*
+ * RequestChipDebugInfo:
+ */
+TEST_F(WifiChipHidlTest, RequestChipDebugInfo) {
+    configureChipForIfaceType(IfaceType::STA);
+    const auto& status_and_chip_info =
+        HIDL_INVOKE(wifi_chip_, requestChipDebugInfo);
+    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_chip_info.first.code);
+    EXPECT_LT(0u, status_and_chip_info.second.driverDescription.size());
+    EXPECT_LT(0u, status_and_chip_info.second.firmwareDescription.size());
+}
+
+/*
+ * RequestFirmwareDebugDump
+ */
+TEST_F(WifiChipHidlTest, RequestFirmwareDebugDump) {
+    uint32_t caps = configureChipForStaIfaceAndGetCapabilities();
+    const auto& status_and_firmware_dump =
+        HIDL_INVOKE(wifi_chip_, requestFirmwareDebugDump);
+    if (caps & IWifiChip::ChipCapabilityMask::DEBUG_MEMORY_FIRMWARE_DUMP) {
+        EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_firmware_dump.first.code);
+    } else {
+        EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED,
+                  status_and_firmware_dump.first.code);
+    }
+}
+
+/*
+ * RequestDriverDebugDump
+ */
+TEST_F(WifiChipHidlTest, RequestDriverDebugDump) {
+    uint32_t caps = configureChipForStaIfaceAndGetCapabilities();
+    const auto& status_and_driver_dump =
+        HIDL_INVOKE(wifi_chip_, requestDriverDebugDump);
+    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);
+    }
+}
+
+/*
+ * GetDebugRingBuffersStatus
+ */
+TEST_F(WifiChipHidlTest, GetDebugRingBuffersStatus) {
+    uint32_t caps = configureChipForStaIfaceAndGetCapabilities();
+    const auto& status_and_ring_buffer_status =
+        HIDL_INVOKE(wifi_chip_, getDebugRingBuffersStatus);
+    if (hasAnyRingBufferCapabilities(caps)) {
+        EXPECT_EQ(WifiStatusCode::SUCCESS,
+                  status_and_ring_buffer_status.first.code);
+        for (const auto& ring_buffer : status_and_ring_buffer_status.second) {
+            EXPECT_LT(0u, ring_buffer.ringName.size());
+        }
+    } else {
+        EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED,
+                  status_and_ring_buffer_status.first.code);
+    }
+}
+
+/*
+ * StartLoggingToDebugRingBuffer
+ */
+TEST_F(WifiChipHidlTest, StartLoggingToDebugRingBuffer) {
+    uint32_t caps = configureChipForStaIfaceAndGetCapabilities();
+    std::string ring_name;
+    const auto& status_and_ring_buffer_status =
+        HIDL_INVOKE(wifi_chip_, getDebugRingBuffersStatus);
+    if (hasAnyRingBufferCapabilities(caps)) {
+        EXPECT_EQ(WifiStatusCode::SUCCESS,
+                  status_and_ring_buffer_status.first.code);
+        ASSERT_LT(0u, status_and_ring_buffer_status.second.size());
+        ring_name = status_and_ring_buffer_status.second[0].ringName.c_str();
+    } else {
+        EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED,
+                  status_and_ring_buffer_status.first.code);
+    }
+    const auto& status =
+        HIDL_INVOKE(wifi_chip_, startLoggingToDebugRingBuffer, ring_name,
+                    kDebugRingBufferVerboseLvl, kDebugRingBufferMaxInterval,
+                    kDebugRingBufferMaxDataSize);
+    if (hasAnyRingBufferCapabilities(caps)) {
+        EXPECT_EQ(WifiStatusCode::SUCCESS, status.code);
+    } else {
+        EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED, status.code);
+    }
+}
+
+/*
+ * ForceDumpToDebugRingBuffer
+ */
+TEST_F(WifiChipHidlTest, ForceDumpToDebugRingBuffer) {
+    uint32_t caps = configureChipForStaIfaceAndGetCapabilities();
+    std::string ring_name;
+    const auto& status_and_ring_buffer_status =
+        HIDL_INVOKE(wifi_chip_, getDebugRingBuffersStatus);
+    if (hasAnyRingBufferCapabilities(caps)) {
+        EXPECT_EQ(WifiStatusCode::SUCCESS,
+                  status_and_ring_buffer_status.first.code);
+        ASSERT_LT(0u, status_and_ring_buffer_status.second.size());
+        ring_name = status_and_ring_buffer_status.second[0].ringName.c_str();
+    } else {
+        EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED,
+                  status_and_ring_buffer_status.first.code);
+    }
+    const auto& status =
+        HIDL_INVOKE(wifi_chip_, forceDumpToDebugRingBuffer, ring_name);
+    if (hasAnyRingBufferCapabilities(caps)) {
+        EXPECT_EQ(WifiStatusCode::SUCCESS, status.code);
+    } else {
+        EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED, status.code);
+    }
+}
+
+/*
+ * GetDebugHostWakeReasonStats
+ */
+TEST_F(WifiChipHidlTest, GetDebugHostWakeReasonStats) {
+    uint32_t caps = configureChipForStaIfaceAndGetCapabilities();
+    const auto& status_and_debug_wake_reason =
+        HIDL_INVOKE(wifi_chip_, getDebugHostWakeReasonStats);
+    if (caps & IWifiChip::ChipCapabilityMask::DEBUG_HOST_WAKE_REASON_STATS) {
+        EXPECT_EQ(WifiStatusCode::SUCCESS,
+                  status_and_debug_wake_reason.first.code);
+    } else {
+        EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED,
+                  status_and_debug_wake_reason.first.code);
+    }
+}
+
+/*
+ * CreateApIface
+ * Configures the chip in AP mode and ensures that only 1 iface creation
+ * succeeds. The 2nd iface creation should be rejected.
+ */
+TEST_F(WifiChipHidlTest, CreateApIface) {
+    configureChipForIfaceType(IfaceType::AP);
+
+    sp<IWifiApIface> iface;
+    EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&iface));
+    EXPECT_NE(nullptr, iface.get());
+
+    EXPECT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createApIface(&iface));
+}
+
+/*
+ * GetApIfaceNames
+ * Configures the chip in AP mode and ensures that the iface list is empty
+ * before creating the iface. Then, create the iface and ensure that
+ * iface name is returned via the list.
+ */
+TEST_F(WifiChipHidlTest, GetApIfaceNames) {
+    configureChipForIfaceType(IfaceType::AP);
+
+    const auto& status_and_iface_names1 =
+        HIDL_INVOKE(wifi_chip_, getApIfaceNames);
+    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names1.first.code);
+    EXPECT_EQ(0u, status_and_iface_names1.second.size());
+
+    sp<IWifiApIface> iface;
+    EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&iface));
+    EXPECT_NE(nullptr, iface.get());
+
+    std::string iface_name = getIfaceName(iface);
+    const auto& status_and_iface_names2 =
+        HIDL_INVOKE(wifi_chip_, getApIfaceNames);
+    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, removeApIface(iface_name));
+    const auto& status_and_iface_names3 =
+        HIDL_INVOKE(wifi_chip_, getApIfaceNames);
+    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names3.first.code);
+    EXPECT_EQ(0u, status_and_iface_names3.second.size());
+}
+
+/*
+ * GetApIface
+ * Configures the chip in AP mode and create an iface. Then, retrieve
+ * the iface object using the correct name and ensure any other name
+ * doesn't retrieve an iface object.
+ */
+TEST_F(WifiChipHidlTest, GetApIface) {
+    configureChipForIfaceType(IfaceType::AP);
+
+    sp<IWifiApIface> ap_iface;
+    EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&ap_iface));
+    EXPECT_NE(nullptr, ap_iface.get());
+
+    std::string iface_name = getIfaceName(ap_iface);
+    const auto& status_and_iface1 =
+        HIDL_INVOKE(wifi_chip_, getApIface, 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_, getApIface, invalid_name);
+    EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, status_and_iface2.first.code);
+    EXPECT_EQ(nullptr, status_and_iface2.second.get());
+}
+
+/*
+ * RemoveApIface
+ * Configures the chip in AP mode and create an iface. Then, remove
+ * the iface object using the correct name and ensure any other name
+ * doesn't remove the iface.
+ */
+TEST_F(WifiChipHidlTest, RemoveApIface) {
+    configureChipForIfaceType(IfaceType::AP);
+
+    sp<IWifiApIface> ap_iface;
+    EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&ap_iface));
+    EXPECT_NE(nullptr, ap_iface.get());
+
+    std::string iface_name = getIfaceName(ap_iface);
+    std::string invalid_name = iface_name + "0";
+    EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeApIface(invalid_name));
+    EXPECT_EQ(WifiStatusCode::SUCCESS, removeApIface(iface_name));
+
+    // No such iface exists now. So, this should return failure.
+    EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeApIface(iface_name));
+}
+
+/*
+ * CreateNanIface
+ * Configures the chip in NAN mode and ensures that only 1 iface creation
+ * succeeds. The 2nd iface creation should be rejected.
+ */
+TEST_F(WifiChipHidlTest, CreateNanIface) {
+    configureChipForIfaceType(IfaceType::NAN);
+
+    sp<IWifiNanIface> iface;
+    EXPECT_EQ(WifiStatusCode::SUCCESS, createNanIface(&iface));
+    EXPECT_NE(nullptr, iface.get());
+
+    EXPECT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createNanIface(&iface));
+}
+
+/*
+ * GetNanIfaceNames
+ * Configures the chip in NAN mode and ensures that the iface list is empty
+ * before creating the iface. Then, create the iface and ensure that
+ * iface name is returned via the list.
+ */
+TEST_F(WifiChipHidlTest, GetNanIfaceNames) {
+    configureChipForIfaceType(IfaceType::NAN);
+
+    const auto& status_and_iface_names1 =
+        HIDL_INVOKE(wifi_chip_, getNanIfaceNames);
+    EXPECT_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());
+}
+
+/*
+ * GetNanIface
+ * Configures the chip in NAN mode and create an iface. Then, retrieve
+ * the iface object using the correct name and ensure any other name
+ * doesn't retrieve an iface object.
+ */
+TEST_F(WifiChipHidlTest, GetNanIface) {
+    configureChipForIfaceType(IfaceType::NAN);
+
+    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());
+}
+
+/*
+ * RemoveNanIface
+ * Configures the chip in NAN mode and create an iface. Then, remove
+ * the iface object using the correct name and ensure any other name
+ * doesn't remove the iface.
+ */
+TEST_F(WifiChipHidlTest, RemoveNanIface) {
+    configureChipForIfaceType(IfaceType::NAN);
+
+    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));
+}
+
+/*
+ * CreateP2pIface
+ * Configures the chip in P2P mode and ensures that only 1 iface creation
+ * succeeds. The 2nd iface creation should be rejected.
+ */
+TEST_F(WifiChipHidlTest, CreateP2pIface) {
+    configureChipForIfaceType(IfaceType::P2P);
+
+    sp<IWifiP2pIface> iface;
+    EXPECT_EQ(WifiStatusCode::SUCCESS, createP2pIface(&iface));
+    EXPECT_NE(nullptr, iface.get());
+
+    EXPECT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createP2pIface(&iface));
+}
+
+/*
+ * GetP2pIfaceNames
+ * Configures the chip in P2P mode and ensures that the iface list is empty
+ * before creating the iface. Then, create the iface and ensure that
+ * iface name is returned via the list.
+ */
+TEST_F(WifiChipHidlTest, GetP2pIfaceNames) {
+    configureChipForIfaceType(IfaceType::P2P);
+
+    const auto& status_and_iface_names1 =
+        HIDL_INVOKE(wifi_chip_, getP2pIfaceNames);
+    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names1.first.code);
+    EXPECT_EQ(0u, status_and_iface_names1.second.size());
+
+    sp<IWifiP2pIface> iface;
+    EXPECT_EQ(WifiStatusCode::SUCCESS, createP2pIface(&iface));
+    EXPECT_NE(nullptr, iface.get());
+
+    std::string iface_name = getIfaceName(iface);
+    const auto& status_and_iface_names2 =
+        HIDL_INVOKE(wifi_chip_, getP2pIfaceNames);
+    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, removeP2pIface(iface_name));
+    const auto& status_and_iface_names3 =
+        HIDL_INVOKE(wifi_chip_, getP2pIfaceNames);
+    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names3.first.code);
+    EXPECT_EQ(0u, status_and_iface_names3.second.size());
+}
+
+/*
+ * GetP2pIface
+ * Configures the chip in P2P mode and create an iface. Then, retrieve
+ * the iface object using the correct name and ensure any other name
+ * doesn't retrieve an iface object.
+ */
+TEST_F(WifiChipHidlTest, GetP2pIface) {
+    configureChipForIfaceType(IfaceType::P2P);
+
+    sp<IWifiP2pIface> p2p_iface;
+    EXPECT_EQ(WifiStatusCode::SUCCESS, createP2pIface(&p2p_iface));
+    EXPECT_NE(nullptr, p2p_iface.get());
+
+    std::string iface_name = getIfaceName(p2p_iface);
+    const auto& status_and_iface1 =
+        HIDL_INVOKE(wifi_chip_, getP2pIface, 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_, getP2pIface, invalid_name);
+    EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, status_and_iface2.first.code);
+    EXPECT_EQ(nullptr, status_and_iface2.second.get());
+}
+
+/*
+ * RemoveP2pIface
+ * Configures the chip in P2P mode and create an iface. Then, remove
+ * the iface object using the correct name and ensure any other name
+ * doesn't remove the iface.
+ */
+TEST_F(WifiChipHidlTest, RemoveP2pIface) {
+    configureChipForIfaceType(IfaceType::P2P);
+
+    sp<IWifiP2pIface> p2p_iface;
+    EXPECT_EQ(WifiStatusCode::SUCCESS, createP2pIface(&p2p_iface));
+    EXPECT_NE(nullptr, p2p_iface.get());
+
+    std::string iface_name = getIfaceName(p2p_iface);
+    std::string invalid_name = iface_name + "0";
+    EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeP2pIface(invalid_name));
+    EXPECT_EQ(WifiStatusCode::SUCCESS, removeP2pIface(iface_name));
+
+    // No such iface exists now. So, this should return failure.
+    EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeP2pIface(iface_name));
+}
+
+/*
+ * CreateStaIface
+ * Configures the chip in STA mode and ensures that only 1 iface creation
+ * succeeds. The 2nd iface creation should be rejected.
+ */
+TEST_F(WifiChipHidlTest, CreateStaIface) {
+    configureChipForIfaceType(IfaceType::STA);
+
+    sp<IWifiStaIface> iface;
+    EXPECT_EQ(WifiStatusCode::SUCCESS, createStaIface(&iface));
+    EXPECT_NE(nullptr, iface.get());
+
+    EXPECT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createStaIface(&iface));
+}
+
+/*
+ * GetStaIfaceNames
+ * Configures the chip in STA mode and ensures that the iface list is empty
+ * before creating the iface. Then, create the iface and ensure that
+ * iface name is returned via the list.
+ */
+TEST_F(WifiChipHidlTest, GetStaIfaceNames) {
+    configureChipForIfaceType(IfaceType::STA);
+
+    const auto& status_and_iface_names1 =
+        HIDL_INVOKE(wifi_chip_, getStaIfaceNames);
+    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names1.first.code);
+    EXPECT_EQ(0u, status_and_iface_names1.second.size());
+
+    sp<IWifiStaIface> iface;
+    EXPECT_EQ(WifiStatusCode::SUCCESS, createStaIface(&iface));
+    EXPECT_NE(nullptr, iface.get());
+
+    std::string iface_name = getIfaceName(iface);
+    const auto& status_and_iface_names2 =
+        HIDL_INVOKE(wifi_chip_, getStaIfaceNames);
+    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, removeStaIface(iface_name));
+    const auto& status_and_iface_names3 =
+        HIDL_INVOKE(wifi_chip_, getStaIfaceNames);
+    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names3.first.code);
+    EXPECT_EQ(0u, status_and_iface_names3.second.size());
+}
+
+/*
+ * GetStaIface
+ * Configures the chip in STA mode and create an iface. Then, retrieve
+ * the iface object using the correct name and ensure any other name
+ * doesn't retrieve an iface object.
+ */
+TEST_F(WifiChipHidlTest, GetStaIface) {
+    configureChipForIfaceType(IfaceType::STA);
+
+    sp<IWifiStaIface> sta_iface;
+    EXPECT_EQ(WifiStatusCode::SUCCESS, createStaIface(&sta_iface));
+    EXPECT_NE(nullptr, sta_iface.get());
+
+    std::string iface_name = getIfaceName(sta_iface);
+    const auto& status_and_iface1 =
+        HIDL_INVOKE(wifi_chip_, getStaIface, 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_, getStaIface, invalid_name);
+    EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, status_and_iface2.first.code);
+    EXPECT_EQ(nullptr, status_and_iface2.second.get());
+}
+
+/*
+ * RemoveStaIface
+ * Configures the chip in STA mode and create an iface. Then, remove
+ * the iface object using the correct name and ensure any other name
+ * doesn't remove the iface.
+ */
+TEST_F(WifiChipHidlTest, RemoveStaIface) {
+    configureChipForIfaceType(IfaceType::STA);
+
+    sp<IWifiStaIface> sta_iface;
+    EXPECT_EQ(WifiStatusCode::SUCCESS, createStaIface(&sta_iface));
+    EXPECT_NE(nullptr, sta_iface.get());
+
+    std::string iface_name = getIfaceName(sta_iface);
+    std::string invalid_name = iface_name + "0";
+    EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeStaIface(invalid_name));
+    EXPECT_EQ(WifiStatusCode::SUCCESS, removeStaIface(iface_name));
+
+    // No such iface exists now. So, this should return failure.
+    EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeStaIface(iface_name));
+}
+
+/*
+ * CreateRttController
+ */
+TEST_F(WifiChipHidlTest, CreateRttController) {
+    configureChipForIfaceType(IfaceType::AP);
+
+    sp<IWifiApIface> iface;
+    EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&iface));
+    EXPECT_NE(nullptr, iface.get());
+
+    const auto& status_and_rtt_controller =
+        HIDL_INVOKE(wifi_chip_, createRttController, iface);
+    EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_rtt_controller.first.code);
+    EXPECT_NE(nullptr, status_and_rtt_controller.second.get());
+}
diff --git a/wifi/1.0/vts/functional/wifi_hidl_call_util.h b/wifi/1.0/vts/functional/wifi_hidl_call_util.h
index 4797423..f3ca517 100644
--- a/wifi/1.0/vts/functional/wifi_hidl_call_util.h
+++ b/wifi/1.0/vts/functional/wifi_hidl_call_util.h
@@ -21,7 +21,7 @@
 #include <type_traits>
 #include <utility>
 
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 
 namespace {
 namespace detail {
diff --git a/wifi/1.0/vts/functional/wifi_hidl_test.cpp b/wifi/1.0/vts/functional/wifi_hidl_test.cpp
index 2f4e01e..b8e501c 100644
--- a/wifi/1.0/vts/functional/wifi_hidl_test.cpp
+++ b/wifi/1.0/vts/functional/wifi_hidl_test.cpp
@@ -18,7 +18,7 @@
 
 #include <android/hardware/wifi/1.0/IWifi.h>
 
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 
 #include "wifi_hidl_test_utils.h"
 
@@ -28,7 +28,7 @@
 /**
  * Fixture to use for all root Wifi HIDL interface tests.
  */
-class WifiHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
+class WifiHidlTest : public ::testing::VtsHalHidlTargetTestBase {
    public:
     virtual void SetUp() override {}
 
diff --git a/wifi/1.0/vts/functional/wifi_hidl_test_utils.cpp b/wifi/1.0/vts/functional/wifi_hidl_test_utils.cpp
index e0c92fe..2d0b081 100644
--- a/wifi/1.0/vts/functional/wifi_hidl_test_utils.cpp
+++ b/wifi/1.0/vts/functional/wifi_hidl_test_utils.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 
 #include "wifi_hidl_call_util.h"
 #include "wifi_hidl_test_utils.h"
@@ -35,6 +35,53 @@
 using ::android::hardware::hidl_string;
 using ::android::hardware::hidl_vec;
 
+namespace {
+bool findAnyModeSupportingIfaceType(
+    IfaceType desired_type, const std::vector<IWifiChip::ChipMode>& modes,
+    ChipModeId* mode_id) {
+    for (const auto& mode : modes) {
+        for (const auto& combination : mode.availableCombinations) {
+            for (const auto& iface_limit : combination.limits) {
+                const auto& iface_types = iface_limit.types;
+                if (std::find(iface_types.begin(), iface_types.end(),
+                              desired_type) != iface_types.end()) {
+                    *mode_id = mode.id;
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+
+bool configureChipToSupportIfaceTypeInternal(const sp<IWifiChip>& wifi_chip,
+                                             IfaceType type,
+                                             ChipModeId* configured_mode_id) {
+    if (!configured_mode_id) {
+        return false;
+    }
+    const auto& status_and_modes = HIDL_INVOKE(wifi_chip, getAvailableModes);
+    if (status_and_modes.first.code != WifiStatusCode::SUCCESS) {
+        return false;
+    }
+    if (!findAnyModeSupportingIfaceType(type, status_and_modes.second,
+                                        configured_mode_id)) {
+        return false;
+    }
+    if (HIDL_INVOKE(wifi_chip, configureChip, *configured_mode_id).code !=
+        WifiStatusCode::SUCCESS) {
+        return false;
+    }
+    return true;
+}
+
+bool configureChipToSupportIfaceTypeInternal(const sp<IWifiChip>& wifi_chip,
+                                             IfaceType type) {
+    ChipModeId mode_id;
+    return configureChipToSupportIfaceTypeInternal(wifi_chip, type, &mode_id);
+}
+}  // namespace
+
 void stopFramework() {
     ASSERT_EQ(std::system("stop"), 0);
     stopWifi();
@@ -44,7 +91,7 @@
 void startFramework() { ASSERT_EQ(std::system("start"), 0); }
 
 sp<IWifi> getWifi() {
-    sp<IWifi> wifi = ::testing::VtsHalHidlTargetBaseTest::getService<IWifi>();
+    sp<IWifi> wifi = ::testing::VtsHalHidlTargetTestBase::getService<IWifi>();
     return wifi;
 }
 
@@ -53,79 +100,30 @@
     if (!wifi.get()) {
         return nullptr;
     }
-
     if (HIDL_INVOKE(wifi, start).code != WifiStatusCode::SUCCESS) {
         return nullptr;
     }
-
     const auto& status_and_chip_ids = HIDL_INVOKE(wifi, getChipIds);
     const auto& chip_ids = status_and_chip_ids.second;
     if (status_and_chip_ids.first.code != WifiStatusCode::SUCCESS ||
         chip_ids.size() != 1) {
         return nullptr;
     }
-
     const auto& status_and_chip = HIDL_INVOKE(wifi, getChip, chip_ids[0]);
     if (status_and_chip.first.code != WifiStatusCode::SUCCESS) {
         return nullptr;
     }
-
     return status_and_chip.second;
 }
 
-// Since we currently only support one iface of each type. Just iterate thru the
-// modes of operation and find the mode ID to use for that iface type.
-bool findModeToSupportIfaceType(IfaceType type,
-                                const std::vector<IWifiChip::ChipMode>& modes,
-                                ChipModeId* mode_id) {
-    for (const auto& mode : modes) {
-        std::vector<IWifiChip::ChipIfaceCombination> combinations =
-            mode.availableCombinations;
-        for (const auto& combination : combinations) {
-            std::vector<IWifiChip::ChipIfaceCombinationLimit> iface_limits =
-                combination.limits;
-            for (const auto& iface_limit : iface_limits) {
-                std::vector<IfaceType> iface_types = iface_limit.types;
-                for (const auto& iface_type : iface_types) {
-                    if (iface_type == type) {
-                        *mode_id = mode.id;
-                        return true;
-                    }
-                }
-            }
-        }
-    }
-    return false;
-}
-
-bool configureChipToSupportIfaceType(const sp<IWifiChip>& wifi_chip,
-                                     IfaceType type) {
-    const auto& status_and_modes = HIDL_INVOKE(wifi_chip, getAvailableModes);
-    if (status_and_modes.first.code != WifiStatusCode::SUCCESS) {
-        return false;
-    }
-
-    ChipModeId mode_id;
-    if (!findModeToSupportIfaceType(type, status_and_modes.second, &mode_id)) {
-        return false;
-    }
-
-    if (HIDL_INVOKE(wifi_chip, configureChip, mode_id).code !=
-        WifiStatusCode::SUCCESS) {
-        return false;
-    }
-    return true;
-}
-
 sp<IWifiApIface> getWifiApIface() {
     sp<IWifiChip> wifi_chip = getWifiChip();
     if (!wifi_chip.get()) {
         return nullptr;
     }
-    if (!configureChipToSupportIfaceType(wifi_chip, IfaceType::AP)) {
+    if (!configureChipToSupportIfaceTypeInternal(wifi_chip, IfaceType::AP)) {
         return nullptr;
     }
-
     const auto& status_and_iface = HIDL_INVOKE(wifi_chip, createApIface);
     if (status_and_iface.first.code != WifiStatusCode::SUCCESS) {
         return nullptr;
@@ -138,10 +136,9 @@
     if (!wifi_chip.get()) {
         return nullptr;
     }
-    if (!configureChipToSupportIfaceType(wifi_chip, IfaceType::NAN)) {
+    if (!configureChipToSupportIfaceTypeInternal(wifi_chip, IfaceType::NAN)) {
         return nullptr;
     }
-
     const auto& status_and_iface = HIDL_INVOKE(wifi_chip, createNanIface);
     if (status_and_iface.first.code != WifiStatusCode::SUCCESS) {
         return nullptr;
@@ -154,10 +151,9 @@
     if (!wifi_chip.get()) {
         return nullptr;
     }
-    if (!configureChipToSupportIfaceType(wifi_chip, IfaceType::P2P)) {
+    if (!configureChipToSupportIfaceTypeInternal(wifi_chip, IfaceType::P2P)) {
         return nullptr;
     }
-
     const auto& status_and_iface = HIDL_INVOKE(wifi_chip, createP2pIface);
     if (status_and_iface.first.code != WifiStatusCode::SUCCESS) {
         return nullptr;
@@ -170,10 +166,9 @@
     if (!wifi_chip.get()) {
         return nullptr;
     }
-    if (!configureChipToSupportIfaceType(wifi_chip, IfaceType::STA)) {
+    if (!configureChipToSupportIfaceTypeInternal(wifi_chip, IfaceType::STA)) {
         return nullptr;
     }
-
     const auto& status_and_iface = HIDL_INVOKE(wifi_chip, createStaIface);
     if (status_and_iface.first.code != WifiStatusCode::SUCCESS) {
         return nullptr;
@@ -190,7 +185,6 @@
     if (!wifi_sta_iface.get()) {
         return nullptr;
     }
-
     const auto& status_and_controller =
         HIDL_INVOKE(wifi_chip, createRttController, wifi_sta_iface);
     if (status_and_controller.first.code != WifiStatusCode::SUCCESS) {
@@ -199,6 +193,13 @@
     return status_and_controller.second;
 }
 
+bool configureChipToSupportIfaceType(const sp<IWifiChip>& wifi_chip,
+                                     IfaceType type,
+                                     ChipModeId* configured_mode_id) {
+    return configureChipToSupportIfaceTypeInternal(wifi_chip, type,
+                                                   configured_mode_id);
+}
+
 void stopWifi() {
     sp<IWifi> wifi = getWifi();
     ASSERT_NE(wifi, nullptr);
diff --git a/wifi/1.0/vts/functional/wifi_hidl_test_utils.h b/wifi/1.0/vts/functional/wifi_hidl_test_utils.h
index 08933d9..a723b2a 100644
--- a/wifi/1.0/vts/functional/wifi_hidl_test_utils.h
+++ b/wifi/1.0/vts/functional/wifi_hidl_test_utils.h
@@ -41,5 +41,11 @@
 android::sp<android::hardware::wifi::V1_0::IWifiStaIface> getWifiStaIface();
 android::sp<android::hardware::wifi::V1_0::IWifiRttController>
 getWifiRttController();
+// Configure the chip in a mode to support the creation of the provided
+// iface type.
+bool configureChipToSupportIfaceType(
+    const android::sp<android::hardware::wifi::V1_0::IWifiChip>& wifi_chip,
+    android::hardware::wifi::V1_0::IfaceType type,
+    android::hardware::wifi::V1_0::ChipModeId* configured_mode_id);
 // Used to trigger IWifi.stop() at the end of every test.
 void stopWifi();
diff --git a/wifi/1.0/vts/functional/wifi_nan_iface_hidl_test.cpp b/wifi/1.0/vts/functional/wifi_nan_iface_hidl_test.cpp
index 95c0e5d..85bcccd 100644
--- a/wifi/1.0/vts/functional/wifi_nan_iface_hidl_test.cpp
+++ b/wifi/1.0/vts/functional/wifi_nan_iface_hidl_test.cpp
@@ -19,7 +19,7 @@
 #include <android/hardware/wifi/1.0/IWifiNanIface.h>
 #include <android/hardware/wifi/1.0/IWifiNanIfaceEventCallback.h>
 
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 #include <chrono>
 #include <condition_variable>
 #include <mutex>
@@ -38,7 +38,7 @@
 /**
  * Fixture to use for all NAN Iface HIDL interface tests.
  */
-class WifiNanIfaceHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
+class WifiNanIfaceHidlTest : public ::testing::VtsHalHidlTargetTestBase {
   public:
     virtual void SetUp() override {
       iwifiNanIface = getWifiNanIface();
diff --git a/wifi/1.0/vts/functional/wifi_p2p_iface_hidl_test.cpp b/wifi/1.0/vts/functional/wifi_p2p_iface_hidl_test.cpp
index d53096c..269eb6c 100644
--- a/wifi/1.0/vts/functional/wifi_p2p_iface_hidl_test.cpp
+++ b/wifi/1.0/vts/functional/wifi_p2p_iface_hidl_test.cpp
@@ -18,7 +18,7 @@
 
 #include <android/hardware/wifi/1.0/IWifiP2pIface.h>
 
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 
 #include "wifi_hidl_test_utils.h"
 
@@ -28,7 +28,7 @@
 /**
  * Fixture to use for all P2P Iface HIDL interface tests.
  */
-class WifiP2pIfaceHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
+class WifiP2pIfaceHidlTest : public ::testing::VtsHalHidlTargetTestBase {
    public:
     virtual void SetUp() override {}
 
diff --git a/wifi/1.0/vts/functional/wifi_rtt_controller_hidl_test.cpp b/wifi/1.0/vts/functional/wifi_rtt_controller_hidl_test.cpp
index 4d08919..e13086d 100644
--- a/wifi/1.0/vts/functional/wifi_rtt_controller_hidl_test.cpp
+++ b/wifi/1.0/vts/functional/wifi_rtt_controller_hidl_test.cpp
@@ -18,7 +18,7 @@
 
 #include <android/hardware/wifi/1.0/IWifiRttController.h>
 
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 
 #include "wifi_hidl_test_utils.h"
 
@@ -28,7 +28,7 @@
 /**
  * Fixture to use for all RTT controller HIDL interface tests.
  */
-class WifiRttControllerHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
+class WifiRttControllerHidlTest : public ::testing::VtsHalHidlTargetTestBase {
    public:
     virtual void SetUp() override {}
 
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 4457487..95add61 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
@@ -18,23 +18,30 @@
 
 #include <android/hardware/wifi/1.0/IWifiStaIface.h>
 
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 
+#include "wifi_hidl_call_util.h"
 #include "wifi_hidl_test_utils.h"
 
-using ::android::hardware::wifi::V1_0::IWifiStaIface;
 using ::android::sp;
+using ::android::hardware::wifi::V1_0::IWifiStaIface;
+using ::android::hardware::wifi::V1_0::WifiStatus;
+using ::android::hardware::wifi::V1_0::WifiStatusCode;
 
 /**
  * Fixture to use for all STA Iface HIDL interface tests.
  */
-class WifiStaIfaceHidlTest : public ::testing::VtsHalHidlTargetBaseTest {
+class WifiStaIfaceHidlTest : public ::testing::VtsHalHidlTargetTestBase {
    public:
-    virtual void SetUp() override {}
+    virtual void SetUp() override {
+        wifi_sta_iface_ = getWifiStaIface();
+        ASSERT_NE(nullptr, wifi_sta_iface_.get());
+    }
 
     virtual void TearDown() override { stopWifi(); }
 
    protected:
+    sp<IWifiStaIface> wifi_sta_iface_;
 };
 
 /*
@@ -46,3 +53,12 @@
     EXPECT_NE(nullptr, getWifiStaIface().get());
     stopWifi();
 }
+
+/*
+ * GetCapabilities:
+ */
+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);
+}
diff --git a/wifi/supplicant/1.0/vts/functional/Android.mk b/wifi/supplicant/1.0/vts/functional/Android.mk
index 93e5250..cfcd4f8 100644
--- a/wifi/supplicant/1.0/vts/functional/Android.mk
+++ b/wifi/supplicant/1.0/vts/functional/Android.mk
@@ -37,6 +37,6 @@
     libwifi-system
 LOCAL_STATIC_LIBRARIES := \
     libgmock \
-    VtsHalHidlTargetBaseTest
+    VtsHalHidlTargetTestBase
 include $(BUILD_NATIVE_TEST)
 
diff --git a/wifi/supplicant/1.0/vts/functional/VtsHalWifiSupplicantV1_0TargetTest.cpp b/wifi/supplicant/1.0/vts/functional/VtsHalWifiSupplicantV1_0TargetTest.cpp
index 802d11c..a69d14d 100644
--- a/wifi/supplicant/1.0/vts/functional/VtsHalWifiSupplicantV1_0TargetTest.cpp
+++ b/wifi/supplicant/1.0/vts/functional/VtsHalWifiSupplicantV1_0TargetTest.cpp
@@ -16,7 +16,7 @@
 
 #include <android-base/logging.h>
 
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 
 #include "supplicant_hidl_test_utils.h"
 
diff --git a/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test.cpp b/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test.cpp
index eb02445..ab1b6a3 100644
--- a/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test.cpp
+++ b/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test.cpp
@@ -16,7 +16,7 @@
 
 #include <android-base/logging.h>
 
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 
 #include "supplicant_hidl_test_utils.h"
 
diff --git a/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test_utils.cpp b/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test_utils.cpp
index 3f7ee1a..fdee0c6 100644
--- a/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test_utils.cpp
+++ b/wifi/supplicant/1.0/vts/functional/supplicant_hidl_test_utils.cpp
@@ -15,7 +15,7 @@
  */
 
 #include <android-base/logging.h>
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 
 #include <hidl/HidlTransportSupport.h>
 #include <android/hidl/manager/1.0/IServiceManager.h>
diff --git a/wifi/supplicant/1.0/vts/functional/supplicant_p2p_iface_hidl_test.cpp b/wifi/supplicant/1.0/vts/functional/supplicant_p2p_iface_hidl_test.cpp
index 200845b..332b57b 100644
--- a/wifi/supplicant/1.0/vts/functional/supplicant_p2p_iface_hidl_test.cpp
+++ b/wifi/supplicant/1.0/vts/functional/supplicant_p2p_iface_hidl_test.cpp
@@ -16,7 +16,7 @@
 
 #include <android-base/logging.h>
 
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 
 #include "supplicant_hidl_test_utils.h"
 
diff --git a/wifi/supplicant/1.0/vts/functional/supplicant_sta_iface_hidl_test.cpp b/wifi/supplicant/1.0/vts/functional/supplicant_sta_iface_hidl_test.cpp
index a1f5513..c50539b 100644
--- a/wifi/supplicant/1.0/vts/functional/supplicant_sta_iface_hidl_test.cpp
+++ b/wifi/supplicant/1.0/vts/functional/supplicant_sta_iface_hidl_test.cpp
@@ -16,7 +16,7 @@
 
 #include <android-base/logging.h>
 
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 
 #include "supplicant_hidl_test_utils.h"
 
diff --git a/wifi/supplicant/1.0/vts/functional/supplicant_sta_network_hidl_test.cpp b/wifi/supplicant/1.0/vts/functional/supplicant_sta_network_hidl_test.cpp
index e2572c2..cde75fa 100644
--- a/wifi/supplicant/1.0/vts/functional/supplicant_sta_network_hidl_test.cpp
+++ b/wifi/supplicant/1.0/vts/functional/supplicant_sta_network_hidl_test.cpp
@@ -16,7 +16,7 @@
 
 #include <android-base/logging.h>
 
-#include <VtsHalHidlTargetBaseTest.h>
+#include <VtsHalHidlTargetTestBase.h>
 
 #include "supplicant_hidl_test_utils.h"