Home | History | Annotate | Download | only in functional 
      1 /*
      2  * Copyright (C) 2016 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include <android-base/logging.h>
     18 
     19 #include <android/hardware/wifi/1.0/IWifiChip.h>
     20 
     21 #include <VtsHalHidlTargetTestBase.h>
     22 
     23 #include "wifi_hidl_call_util.h"
     24 #include "wifi_hidl_test_utils.h"
     25 
     26 using ::android::sp;
     27 using ::android::hardware::hidl_string;
     28 using ::android::hardware::hidl_vec;
     29 using ::android::hardware::wifi::V1_0::IfaceType;
     30 using ::android::hardware::wifi::V1_0::ChipId;
     31 using ::android::hardware::wifi::V1_0::ChipModeId;
     32 using ::android::hardware::wifi::V1_0::WifiDebugRingBufferStatus;
     33 using ::android::hardware::wifi::V1_0::WifiDebugRingBufferVerboseLevel;
     34 using ::android::hardware::wifi::V1_0::WifiDebugHostWakeReasonStats;
     35 using ::android::hardware::wifi::V1_0::WifiStatus;
     36 using ::android::hardware::wifi::V1_0::WifiStatusCode;
     37 using ::android::hardware::wifi::V1_0::IWifiChip;
     38 using ::android::hardware::wifi::V1_0::IWifiApIface;
     39 using ::android::hardware::wifi::V1_0::IWifiIface;
     40 using ::android::hardware::wifi::V1_0::IWifiNanIface;
     41 using ::android::hardware::wifi::V1_0::IWifiP2pIface;
     42 using ::android::hardware::wifi::V1_0::IWifiRttController;
     43 using ::android::hardware::wifi::V1_0::IWifiStaIface;
     44 
     45 extern WifiHidlEnvironment* gEnv;
     46 
     47 namespace {
     48 constexpr WifiDebugRingBufferVerboseLevel kDebugRingBufferVerboseLvl =
     49     WifiDebugRingBufferVerboseLevel::VERBOSE;
     50 constexpr uint32_t kDebugRingBufferMaxInterval = 5;
     51 constexpr uint32_t kDebugRingBufferMaxDataSize = 1024;
     52 
     53 /**
     54  * Check if any of the ring buffer capabilities are set.
     55  */
     56 bool hasAnyRingBufferCapabilities(uint32_t caps) {
     57     return (caps &
     58             (IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_CONNECT_EVENT |
     59              IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_POWER_EVENT |
     60              IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_WAKELOCK_EVENT |
     61              IWifiChip::ChipCapabilityMask::DEBUG_RING_BUFFER_VENDOR_DATA));
     62 }
     63 }  // namespace
     64 
     65 /**
     66  * Fixture to use for all Wifi chip HIDL interface tests.
     67  */
     68 class WifiChipHidlTest : public ::testing::VtsHalHidlTargetTestBase {
     69    public:
     70     virtual void SetUp() override {
     71         wifi_chip_ = getWifiChip();
     72         ASSERT_NE(nullptr, wifi_chip_.get());
     73     }
     74 
     75     virtual void TearDown() override { stopWifi(); }
     76 
     77    protected:
     78     // Helper function to configure the Chip in one of the supported modes.
     79     // Most of the non-mode-configuration-related methods require chip
     80     // to be first configured.
     81     ChipModeId configureChipForIfaceType(IfaceType type, bool expectSuccess) {
     82         ChipModeId mode_id;
     83         EXPECT_EQ(expectSuccess,
     84             configureChipToSupportIfaceType(wifi_chip_, type, &mode_id));
     85         return mode_id;
     86     }
     87 
     88     uint32_t configureChipForStaIfaceAndGetCapabilities() {
     89         configureChipForIfaceType(IfaceType::STA, true);
     90         const auto& status_and_caps = HIDL_INVOKE(wifi_chip_, getCapabilities);
     91         EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_caps.first.code);
     92         return status_and_caps.second;
     93     }
     94 
     95     std::string getIfaceName(const sp<IWifiIface>& iface) {
     96         const auto& status_and_name = HIDL_INVOKE(iface, getName);
     97         EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_name.first.code);
     98         return status_and_name.second;
     99     }
    100 
    101     WifiStatusCode createApIface(sp<IWifiApIface>* ap_iface) {
    102         const auto& status_and_iface = HIDL_INVOKE(wifi_chip_, createApIface);
    103         *ap_iface = status_and_iface.second;
    104         return status_and_iface.first.code;
    105     }
    106 
    107     WifiStatusCode removeApIface(const std::string& name) {
    108         return HIDL_INVOKE(wifi_chip_, removeApIface, name).code;
    109     }
    110 
    111     WifiStatusCode createNanIface(sp<IWifiNanIface>* nan_iface) {
    112         const auto& status_and_iface = HIDL_INVOKE(wifi_chip_, createNanIface);
    113         *nan_iface = status_and_iface.second;
    114         return status_and_iface.first.code;
    115     }
    116 
    117     WifiStatusCode removeNanIface(const std::string& name) {
    118         return HIDL_INVOKE(wifi_chip_, removeNanIface, name).code;
    119     }
    120 
    121     WifiStatusCode createP2pIface(sp<IWifiP2pIface>* p2p_iface) {
    122         const auto& status_and_iface = HIDL_INVOKE(wifi_chip_, createP2pIface);
    123         *p2p_iface = status_and_iface.second;
    124         return status_and_iface.first.code;
    125     }
    126 
    127     WifiStatusCode removeP2pIface(const std::string& name) {
    128         return HIDL_INVOKE(wifi_chip_, removeP2pIface, name).code;
    129     }
    130 
    131     WifiStatusCode createStaIface(sp<IWifiStaIface>* sta_iface) {
    132         const auto& status_and_iface = HIDL_INVOKE(wifi_chip_, createStaIface);
    133         *sta_iface = status_and_iface.second;
    134         return status_and_iface.first.code;
    135     }
    136 
    137     WifiStatusCode removeStaIface(const std::string& name) {
    138         return HIDL_INVOKE(wifi_chip_, removeStaIface, name).code;
    139     }
    140 
    141     sp<IWifiChip> wifi_chip_;
    142 };
    143 
    144 /*
    145  * Create:
    146  * Ensures that an instance of the IWifiChip proxy object is
    147  * successfully created.
    148  */
    149 TEST(WifiChipHidlTestNoFixture, Create) {
    150     EXPECT_NE(nullptr, getWifiChip().get());
    151     stopWifi();
    152 }
    153 
    154 /*
    155  * GetId:
    156  */
    157 TEST_F(WifiChipHidlTest, GetId) {
    158     EXPECT_EQ(WifiStatusCode::SUCCESS,
    159               HIDL_INVOKE(wifi_chip_, getId).first.code);
    160 }
    161 
    162 /*
    163  * GetAvailableMode:
    164  */
    165 TEST_F(WifiChipHidlTest, GetAvailableModes) {
    166     const auto& status_and_modes = HIDL_INVOKE(wifi_chip_, getAvailableModes);
    167     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_modes.first.code);
    168     EXPECT_LT(0u, status_and_modes.second.size());
    169 }
    170 
    171 /*
    172  * ConfigureChip:
    173  */
    174 TEST_F(WifiChipHidlTest, ConfigureChip) {
    175     const auto& status_and_modes = HIDL_INVOKE(wifi_chip_, getAvailableModes);
    176     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_modes.first.code);
    177     EXPECT_LT(0u, status_and_modes.second.size());
    178     for (const auto& mode : status_and_modes.second) {
    179         // configureChip() requires to be called with a fresh IWifiChip object.
    180         wifi_chip_ = getWifiChip();
    181         ASSERT_NE(nullptr, wifi_chip_.get());
    182         EXPECT_EQ(WifiStatusCode::SUCCESS,
    183                   HIDL_INVOKE(wifi_chip_, configureChip, mode.id).code);
    184         stopWifi();
    185         // Sleep for 5 milliseconds between each wifi state toggle.
    186         usleep(5000);
    187     }
    188 }
    189 
    190 /*
    191  * GetCapabilities:
    192  */
    193 TEST_F(WifiChipHidlTest, GetCapabilities) {
    194     configureChipForIfaceType(IfaceType::STA, true);
    195     const auto& status_and_caps = HIDL_INVOKE(wifi_chip_, getCapabilities);
    196     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_caps.first.code);
    197     EXPECT_NE(0u, status_and_caps.second);
    198 }
    199 
    200 /*
    201  * GetMode:
    202  */
    203 TEST_F(WifiChipHidlTest, GetMode) {
    204     ChipModeId chip_mode_id = configureChipForIfaceType(IfaceType::STA, true);
    205     const auto& status_and_mode = HIDL_INVOKE(wifi_chip_, getMode);
    206     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_mode.first.code);
    207     EXPECT_EQ(chip_mode_id, status_and_mode.second);
    208 }
    209 
    210 /*
    211  * RequestChipDebugInfo:
    212  */
    213 TEST_F(WifiChipHidlTest, RequestChipDebugInfo) {
    214     configureChipForIfaceType(IfaceType::STA, true);
    215     const auto& status_and_chip_info =
    216         HIDL_INVOKE(wifi_chip_, requestChipDebugInfo);
    217     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_chip_info.first.code);
    218     EXPECT_LT(0u, status_and_chip_info.second.driverDescription.size());
    219     EXPECT_LT(0u, status_and_chip_info.second.firmwareDescription.size());
    220 }
    221 
    222 /*
    223  * RequestFirmwareDebugDump
    224  */
    225 TEST_F(WifiChipHidlTest, RequestFirmwareDebugDump) {
    226     uint32_t caps = configureChipForStaIfaceAndGetCapabilities();
    227     const auto& status_and_firmware_dump =
    228         HIDL_INVOKE(wifi_chip_, requestFirmwareDebugDump);
    229     if (caps & IWifiChip::ChipCapabilityMask::DEBUG_MEMORY_FIRMWARE_DUMP) {
    230         EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_firmware_dump.first.code);
    231     } else {
    232         EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED,
    233                   status_and_firmware_dump.first.code);
    234     }
    235 }
    236 
    237 /*
    238  * RequestDriverDebugDump
    239  */
    240 TEST_F(WifiChipHidlTest, RequestDriverDebugDump) {
    241     uint32_t caps = configureChipForStaIfaceAndGetCapabilities();
    242     const auto& status_and_driver_dump =
    243         HIDL_INVOKE(wifi_chip_, requestDriverDebugDump);
    244     if (caps & IWifiChip::ChipCapabilityMask::DEBUG_MEMORY_DRIVER_DUMP) {
    245         EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_driver_dump.first.code);
    246     } else {
    247       // API semantics (today) are such that function cannot be called if not capable!
    248       //
    249       //  EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED,
    250       //            status_and_driver_dump.first.code);
    251     }
    252 }
    253 
    254 /*
    255  * GetDebugRingBuffersStatus
    256  */
    257 TEST_F(WifiChipHidlTest, GetDebugRingBuffersStatus) {
    258     uint32_t caps = configureChipForStaIfaceAndGetCapabilities();
    259     const auto& status_and_ring_buffer_status =
    260         HIDL_INVOKE(wifi_chip_, getDebugRingBuffersStatus);
    261     if (hasAnyRingBufferCapabilities(caps)) {
    262         EXPECT_EQ(WifiStatusCode::SUCCESS,
    263                   status_and_ring_buffer_status.first.code);
    264         for (const auto& ring_buffer : status_and_ring_buffer_status.second) {
    265             EXPECT_LT(0u, ring_buffer.ringName.size());
    266         }
    267     } else {
    268         EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED,
    269                   status_and_ring_buffer_status.first.code);
    270     }
    271 }
    272 
    273 /*
    274  * StartLoggingToDebugRingBuffer
    275  */
    276 TEST_F(WifiChipHidlTest, StartLoggingToDebugRingBuffer) {
    277     uint32_t caps = configureChipForStaIfaceAndGetCapabilities();
    278     std::string ring_name;
    279     const auto& status_and_ring_buffer_status =
    280         HIDL_INVOKE(wifi_chip_, getDebugRingBuffersStatus);
    281     if (hasAnyRingBufferCapabilities(caps)) {
    282         EXPECT_EQ(WifiStatusCode::SUCCESS,
    283                   status_and_ring_buffer_status.first.code);
    284         ASSERT_LT(0u, status_and_ring_buffer_status.second.size());
    285         ring_name = status_and_ring_buffer_status.second[0].ringName.c_str();
    286     } else {
    287         EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED,
    288                   status_and_ring_buffer_status.first.code);
    289     }
    290     const auto& status =
    291         HIDL_INVOKE(wifi_chip_, startLoggingToDebugRingBuffer, ring_name,
    292                     kDebugRingBufferVerboseLvl, kDebugRingBufferMaxInterval,
    293                     kDebugRingBufferMaxDataSize);
    294     if (hasAnyRingBufferCapabilities(caps)) {
    295         EXPECT_EQ(WifiStatusCode::SUCCESS, status.code);
    296     } else {
    297         EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED, status.code);
    298     }
    299 }
    300 
    301 /*
    302  * ForceDumpToDebugRingBuffer
    303  */
    304 TEST_F(WifiChipHidlTest, ForceDumpToDebugRingBuffer) {
    305     uint32_t caps = configureChipForStaIfaceAndGetCapabilities();
    306     std::string ring_name;
    307     const auto& status_and_ring_buffer_status =
    308         HIDL_INVOKE(wifi_chip_, getDebugRingBuffersStatus);
    309     if (hasAnyRingBufferCapabilities(caps)) {
    310         EXPECT_EQ(WifiStatusCode::SUCCESS,
    311                   status_and_ring_buffer_status.first.code);
    312         ASSERT_LT(0u, status_and_ring_buffer_status.second.size());
    313         ring_name = status_and_ring_buffer_status.second[0].ringName.c_str();
    314     } else {
    315         EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED,
    316                   status_and_ring_buffer_status.first.code);
    317     }
    318     const auto& status =
    319         HIDL_INVOKE(wifi_chip_, forceDumpToDebugRingBuffer, ring_name);
    320     if (hasAnyRingBufferCapabilities(caps)) {
    321         EXPECT_EQ(WifiStatusCode::SUCCESS, status.code);
    322     } else {
    323         EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED, status.code);
    324     }
    325 }
    326 
    327 /*
    328  * GetDebugHostWakeReasonStats
    329  */
    330 TEST_F(WifiChipHidlTest, GetDebugHostWakeReasonStats) {
    331     uint32_t caps = configureChipForStaIfaceAndGetCapabilities();
    332     const auto& status_and_debug_wake_reason =
    333         HIDL_INVOKE(wifi_chip_, getDebugHostWakeReasonStats);
    334     if (caps & IWifiChip::ChipCapabilityMask::DEBUG_HOST_WAKE_REASON_STATS) {
    335         EXPECT_EQ(WifiStatusCode::SUCCESS,
    336                   status_and_debug_wake_reason.first.code);
    337     } else {
    338         EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED,
    339                   status_and_debug_wake_reason.first.code);
    340     }
    341 }
    342 
    343 /*
    344  * CreateApIface
    345  * Configures the chip in AP mode and ensures that only 1 iface creation
    346  * succeeds. The 2nd iface creation should be rejected.
    347  */
    348 TEST_F(WifiChipHidlTest, CreateApIface) {
    349     configureChipForIfaceType(IfaceType::AP, true);
    350 
    351     sp<IWifiApIface> iface;
    352     EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&iface));
    353     EXPECT_NE(nullptr, iface.get());
    354 
    355     EXPECT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createApIface(&iface));
    356 }
    357 
    358 /*
    359  * GetApIfaceNames
    360  * Configures the chip in AP mode and ensures that the iface list is empty
    361  * before creating the iface. Then, create the iface and ensure that
    362  * iface name is returned via the list.
    363  */
    364 TEST_F(WifiChipHidlTest, GetApIfaceNames) {
    365     configureChipForIfaceType(IfaceType::AP, true);
    366 
    367     const auto& status_and_iface_names1 =
    368         HIDL_INVOKE(wifi_chip_, getApIfaceNames);
    369     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names1.first.code);
    370     EXPECT_EQ(0u, status_and_iface_names1.second.size());
    371 
    372     sp<IWifiApIface> iface;
    373     EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&iface));
    374     EXPECT_NE(nullptr, iface.get());
    375 
    376     std::string iface_name = getIfaceName(iface);
    377     const auto& status_and_iface_names2 =
    378         HIDL_INVOKE(wifi_chip_, getApIfaceNames);
    379     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names2.first.code);
    380     EXPECT_EQ(1u, status_and_iface_names2.second.size());
    381     EXPECT_EQ(iface_name, status_and_iface_names2.second[0]);
    382 
    383     EXPECT_EQ(WifiStatusCode::SUCCESS, removeApIface(iface_name));
    384     const auto& status_and_iface_names3 =
    385         HIDL_INVOKE(wifi_chip_, getApIfaceNames);
    386     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names3.first.code);
    387     EXPECT_EQ(0u, status_and_iface_names3.second.size());
    388 }
    389 
    390 /*
    391  * GetApIface
    392  * Configures the chip in AP mode and create an iface. Then, retrieve
    393  * the iface object using the correct name and ensure any other name
    394  * doesn't retrieve an iface object.
    395  */
    396 TEST_F(WifiChipHidlTest, GetApIface) {
    397     configureChipForIfaceType(IfaceType::AP, true);
    398 
    399     sp<IWifiApIface> ap_iface;
    400     EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&ap_iface));
    401     EXPECT_NE(nullptr, ap_iface.get());
    402 
    403     std::string iface_name = getIfaceName(ap_iface);
    404     const auto& status_and_iface1 =
    405         HIDL_INVOKE(wifi_chip_, getApIface, iface_name);
    406     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface1.first.code);
    407     EXPECT_NE(nullptr, status_and_iface1.second.get());
    408 
    409     std::string invalid_name = iface_name + "0";
    410     const auto& status_and_iface2 =
    411         HIDL_INVOKE(wifi_chip_, getApIface, invalid_name);
    412     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, status_and_iface2.first.code);
    413     EXPECT_EQ(nullptr, status_and_iface2.second.get());
    414 }
    415 
    416 /*
    417  * RemoveApIface
    418  * Configures the chip in AP mode and create an iface. Then, remove
    419  * the iface object using the correct name and ensure any other name
    420  * doesn't remove the iface.
    421  */
    422 TEST_F(WifiChipHidlTest, RemoveApIface) {
    423     configureChipForIfaceType(IfaceType::AP, true);
    424 
    425     sp<IWifiApIface> ap_iface;
    426     EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&ap_iface));
    427     EXPECT_NE(nullptr, ap_iface.get());
    428 
    429     std::string iface_name = getIfaceName(ap_iface);
    430     std::string invalid_name = iface_name + "0";
    431     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeApIface(invalid_name));
    432     EXPECT_EQ(WifiStatusCode::SUCCESS, removeApIface(iface_name));
    433 
    434     // No such iface exists now. So, this should return failure.
    435     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeApIface(iface_name));
    436 }
    437 
    438 /*
    439  * CreateNanIface
    440  * Configures the chip in NAN mode and ensures that only 1 iface creation
    441  * succeeds. The 2nd iface creation should be rejected.
    442  */
    443 TEST_F(WifiChipHidlTest, CreateNanIface) {
    444     configureChipForIfaceType(IfaceType::NAN, gEnv->isNanOn);
    445     if (!gEnv->isNanOn) return;
    446 
    447     sp<IWifiNanIface> iface;
    448     ASSERT_EQ(WifiStatusCode::SUCCESS, createNanIface(&iface));
    449     EXPECT_NE(nullptr, iface.get());
    450 
    451     EXPECT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createNanIface(&iface));
    452 }
    453 
    454 /*
    455  * GetNanIfaceNames
    456  * Configures the chip in NAN mode and ensures that the iface list is empty
    457  * before creating the iface. Then, create the iface and ensure that
    458  * iface name is returned via the list.
    459  */
    460 TEST_F(WifiChipHidlTest, GetNanIfaceNames) {
    461     configureChipForIfaceType(IfaceType::NAN, gEnv->isNanOn);
    462     if (!gEnv->isNanOn) return;
    463 
    464     const auto& status_and_iface_names1 =
    465         HIDL_INVOKE(wifi_chip_, getNanIfaceNames);
    466     ASSERT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names1.first.code);
    467     EXPECT_EQ(0u, status_and_iface_names1.second.size());
    468 
    469     sp<IWifiNanIface> iface;
    470     EXPECT_EQ(WifiStatusCode::SUCCESS, createNanIface(&iface));
    471     EXPECT_NE(nullptr, iface.get());
    472 
    473     std::string iface_name = getIfaceName(iface);
    474     const auto& status_and_iface_names2 =
    475         HIDL_INVOKE(wifi_chip_, getNanIfaceNames);
    476     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names2.first.code);
    477     EXPECT_EQ(1u, status_and_iface_names2.second.size());
    478     EXPECT_EQ(iface_name, status_and_iface_names2.second[0]);
    479 
    480     EXPECT_EQ(WifiStatusCode::SUCCESS, removeNanIface(iface_name));
    481     const auto& status_and_iface_names3 =
    482         HIDL_INVOKE(wifi_chip_, getNanIfaceNames);
    483     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names3.first.code);
    484     EXPECT_EQ(0u, status_and_iface_names3.second.size());
    485 }
    486 
    487 /*
    488  * GetNanIface
    489  * Configures the chip in NAN mode and create an iface. Then, retrieve
    490  * the iface object using the correct name and ensure any other name
    491  * doesn't retrieve an iface object.
    492  */
    493 TEST_F(WifiChipHidlTest, GetNanIface) {
    494     configureChipForIfaceType(IfaceType::NAN, gEnv->isNanOn);
    495     if (!gEnv->isNanOn) return;
    496 
    497     sp<IWifiNanIface> nan_iface;
    498     EXPECT_EQ(WifiStatusCode::SUCCESS, createNanIface(&nan_iface));
    499     EXPECT_NE(nullptr, nan_iface.get());
    500 
    501     std::string iface_name = getIfaceName(nan_iface);
    502     const auto& status_and_iface1 =
    503         HIDL_INVOKE(wifi_chip_, getNanIface, iface_name);
    504     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface1.first.code);
    505     EXPECT_NE(nullptr, status_and_iface1.second.get());
    506 
    507     std::string invalid_name = iface_name + "0";
    508     const auto& status_and_iface2 =
    509         HIDL_INVOKE(wifi_chip_, getNanIface, invalid_name);
    510     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, status_and_iface2.first.code);
    511     EXPECT_EQ(nullptr, status_and_iface2.second.get());
    512 }
    513 
    514 /*
    515  * RemoveNanIface
    516  * Configures the chip in NAN mode and create an iface. Then, remove
    517  * the iface object using the correct name and ensure any other name
    518  * doesn't remove the iface.
    519  */
    520 TEST_F(WifiChipHidlTest, RemoveNanIface) {
    521     configureChipForIfaceType(IfaceType::NAN, gEnv->isNanOn);
    522     if (!gEnv->isNanOn) return;
    523 
    524     sp<IWifiNanIface> nan_iface;
    525     EXPECT_EQ(WifiStatusCode::SUCCESS, createNanIface(&nan_iface));
    526     EXPECT_NE(nullptr, nan_iface.get());
    527 
    528     std::string iface_name = getIfaceName(nan_iface);
    529     std::string invalid_name = iface_name + "0";
    530     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeNanIface(invalid_name));
    531 
    532     EXPECT_EQ(WifiStatusCode::SUCCESS, removeNanIface(iface_name));
    533 
    534     // No such iface exists now. So, this should return failure.
    535     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeNanIface(iface_name));
    536 }
    537 
    538 /*
    539  * CreateP2pIface
    540  * Configures the chip in P2P mode and ensures that only 1 iface creation
    541  * succeeds. The 2nd iface creation should be rejected.
    542  */
    543 TEST_F(WifiChipHidlTest, CreateP2pIface) {
    544     configureChipForIfaceType(IfaceType::P2P, true);
    545 
    546     sp<IWifiP2pIface> iface;
    547     EXPECT_EQ(WifiStatusCode::SUCCESS, createP2pIface(&iface));
    548     EXPECT_NE(nullptr, iface.get());
    549 
    550     EXPECT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createP2pIface(&iface));
    551 }
    552 
    553 /*
    554  * GetP2pIfaceNames
    555  * Configures the chip in P2P mode and ensures that the iface list is empty
    556  * before creating the iface. Then, create the iface and ensure that
    557  * iface name is returned via the list.
    558  */
    559 TEST_F(WifiChipHidlTest, GetP2pIfaceNames) {
    560     configureChipForIfaceType(IfaceType::P2P, true);
    561 
    562     const auto& status_and_iface_names1 =
    563         HIDL_INVOKE(wifi_chip_, getP2pIfaceNames);
    564     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names1.first.code);
    565     EXPECT_EQ(0u, status_and_iface_names1.second.size());
    566 
    567     sp<IWifiP2pIface> iface;
    568     EXPECT_EQ(WifiStatusCode::SUCCESS, createP2pIface(&iface));
    569     EXPECT_NE(nullptr, iface.get());
    570 
    571     std::string iface_name = getIfaceName(iface);
    572     const auto& status_and_iface_names2 =
    573         HIDL_INVOKE(wifi_chip_, getP2pIfaceNames);
    574     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names2.first.code);
    575     EXPECT_EQ(1u, status_and_iface_names2.second.size());
    576     EXPECT_EQ(iface_name, status_and_iface_names2.second[0]);
    577 
    578     EXPECT_EQ(WifiStatusCode::SUCCESS, removeP2pIface(iface_name));
    579     const auto& status_and_iface_names3 =
    580         HIDL_INVOKE(wifi_chip_, getP2pIfaceNames);
    581     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names3.first.code);
    582     EXPECT_EQ(0u, status_and_iface_names3.second.size());
    583 }
    584 
    585 /*
    586  * GetP2pIface
    587  * Configures the chip in P2P mode and create an iface. Then, retrieve
    588  * the iface object using the correct name and ensure any other name
    589  * doesn't retrieve an iface object.
    590  */
    591 TEST_F(WifiChipHidlTest, GetP2pIface) {
    592     configureChipForIfaceType(IfaceType::P2P, true);
    593 
    594     sp<IWifiP2pIface> p2p_iface;
    595     EXPECT_EQ(WifiStatusCode::SUCCESS, createP2pIface(&p2p_iface));
    596     EXPECT_NE(nullptr, p2p_iface.get());
    597 
    598     std::string iface_name = getIfaceName(p2p_iface);
    599     const auto& status_and_iface1 =
    600         HIDL_INVOKE(wifi_chip_, getP2pIface, iface_name);
    601     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface1.first.code);
    602     EXPECT_NE(nullptr, status_and_iface1.second.get());
    603 
    604     std::string invalid_name = iface_name + "0";
    605     const auto& status_and_iface2 =
    606         HIDL_INVOKE(wifi_chip_, getP2pIface, invalid_name);
    607     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, status_and_iface2.first.code);
    608     EXPECT_EQ(nullptr, status_and_iface2.second.get());
    609 }
    610 
    611 /*
    612  * RemoveP2pIface
    613  * Configures the chip in P2P mode and create an iface. Then, remove
    614  * the iface object using the correct name and ensure any other name
    615  * doesn't remove the iface.
    616  */
    617 TEST_F(WifiChipHidlTest, RemoveP2pIface) {
    618     configureChipForIfaceType(IfaceType::P2P, true);
    619 
    620     sp<IWifiP2pIface> p2p_iface;
    621     EXPECT_EQ(WifiStatusCode::SUCCESS, createP2pIface(&p2p_iface));
    622     EXPECT_NE(nullptr, p2p_iface.get());
    623 
    624     std::string iface_name = getIfaceName(p2p_iface);
    625     std::string invalid_name = iface_name + "0";
    626     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeP2pIface(invalid_name));
    627     EXPECT_EQ(WifiStatusCode::SUCCESS, removeP2pIface(iface_name));
    628 
    629     // No such iface exists now. So, this should return failure.
    630     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeP2pIface(iface_name));
    631 }
    632 
    633 /*
    634  * CreateStaIface
    635  * Configures the chip in STA mode and ensures that only 1 iface creation
    636  * succeeds. The 2nd iface creation should be rejected.
    637  */
    638 TEST_F(WifiChipHidlTest, CreateStaIface) {
    639     configureChipForIfaceType(IfaceType::STA, true);
    640 
    641     sp<IWifiStaIface> iface;
    642     EXPECT_EQ(WifiStatusCode::SUCCESS, createStaIface(&iface));
    643     EXPECT_NE(nullptr, iface.get());
    644 
    645     EXPECT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createStaIface(&iface));
    646 }
    647 
    648 /*
    649  * GetStaIfaceNames
    650  * Configures the chip in STA mode and ensures that the iface list is empty
    651  * before creating the iface. Then, create the iface and ensure that
    652  * iface name is returned via the list.
    653  */
    654 TEST_F(WifiChipHidlTest, GetStaIfaceNames) {
    655     configureChipForIfaceType(IfaceType::STA, true);
    656 
    657     const auto& status_and_iface_names1 =
    658         HIDL_INVOKE(wifi_chip_, getStaIfaceNames);
    659     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names1.first.code);
    660     EXPECT_EQ(0u, status_and_iface_names1.second.size());
    661 
    662     sp<IWifiStaIface> iface;
    663     EXPECT_EQ(WifiStatusCode::SUCCESS, createStaIface(&iface));
    664     EXPECT_NE(nullptr, iface.get());
    665 
    666     std::string iface_name = getIfaceName(iface);
    667     const auto& status_and_iface_names2 =
    668         HIDL_INVOKE(wifi_chip_, getStaIfaceNames);
    669     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names2.first.code);
    670     EXPECT_EQ(1u, status_and_iface_names2.second.size());
    671     EXPECT_EQ(iface_name, status_and_iface_names2.second[0]);
    672 
    673     EXPECT_EQ(WifiStatusCode::SUCCESS, removeStaIface(iface_name));
    674     const auto& status_and_iface_names3 =
    675         HIDL_INVOKE(wifi_chip_, getStaIfaceNames);
    676     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names3.first.code);
    677     EXPECT_EQ(0u, status_and_iface_names3.second.size());
    678 }
    679 
    680 /*
    681  * GetStaIface
    682  * Configures the chip in STA mode and create an iface. Then, retrieve
    683  * the iface object using the correct name and ensure any other name
    684  * doesn't retrieve an iface object.
    685  */
    686 TEST_F(WifiChipHidlTest, GetStaIface) {
    687     configureChipForIfaceType(IfaceType::STA, true);
    688 
    689     sp<IWifiStaIface> sta_iface;
    690     EXPECT_EQ(WifiStatusCode::SUCCESS, createStaIface(&sta_iface));
    691     EXPECT_NE(nullptr, sta_iface.get());
    692 
    693     std::string iface_name = getIfaceName(sta_iface);
    694     const auto& status_and_iface1 =
    695         HIDL_INVOKE(wifi_chip_, getStaIface, iface_name);
    696     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface1.first.code);
    697     EXPECT_NE(nullptr, status_and_iface1.second.get());
    698 
    699     std::string invalid_name = iface_name + "0";
    700     const auto& status_and_iface2 =
    701         HIDL_INVOKE(wifi_chip_, getStaIface, invalid_name);
    702     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, status_and_iface2.first.code);
    703     EXPECT_EQ(nullptr, status_and_iface2.second.get());
    704 }
    705 
    706 /*
    707  * RemoveStaIface
    708  * Configures the chip in STA mode and create an iface. Then, remove
    709  * the iface object using the correct name and ensure any other name
    710  * doesn't remove the iface.
    711  */
    712 TEST_F(WifiChipHidlTest, RemoveStaIface) {
    713     configureChipForIfaceType(IfaceType::STA, true);
    714 
    715     sp<IWifiStaIface> sta_iface;
    716     EXPECT_EQ(WifiStatusCode::SUCCESS, createStaIface(&sta_iface));
    717     EXPECT_NE(nullptr, sta_iface.get());
    718 
    719     std::string iface_name = getIfaceName(sta_iface);
    720     std::string invalid_name = iface_name + "0";
    721     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeStaIface(invalid_name));
    722     EXPECT_EQ(WifiStatusCode::SUCCESS, removeStaIface(iface_name));
    723 
    724     // No such iface exists now. So, this should return failure.
    725     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeStaIface(iface_name));
    726 }
    727 
    728 /*
    729  * CreateRttController
    730  */
    731 TEST_F(WifiChipHidlTest, CreateRttController) {
    732     configureChipForIfaceType(IfaceType::AP, true);
    733 
    734     sp<IWifiApIface> iface;
    735     EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&iface));
    736     EXPECT_NE(nullptr, iface.get());
    737 
    738     const auto& status_and_rtt_controller =
    739         HIDL_INVOKE(wifi_chip_, createRttController, iface);
    740     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_rtt_controller.first.code);
    741     EXPECT_NE(nullptr, status_and_rtt_controller.second.get());
    742 }
    743