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         if (status_and_caps.first.code != WifiStatusCode::SUCCESS) {
     92             EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED, status_and_caps.first.code);
     93             return 0;
     94         }
     95         return status_and_caps.second;
     96     }
     97 
     98     std::string getIfaceName(const sp<IWifiIface>& iface) {
     99         const auto& status_and_name = HIDL_INVOKE(iface, getName);
    100         EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_name.first.code);
    101         return status_and_name.second;
    102     }
    103 
    104     WifiStatusCode createApIface(sp<IWifiApIface>* ap_iface) {
    105         const auto& status_and_iface = HIDL_INVOKE(wifi_chip_, createApIface);
    106         *ap_iface = status_and_iface.second;
    107         return status_and_iface.first.code;
    108     }
    109 
    110     WifiStatusCode removeApIface(const std::string& name) {
    111         return HIDL_INVOKE(wifi_chip_, removeApIface, name).code;
    112     }
    113 
    114     WifiStatusCode createNanIface(sp<IWifiNanIface>* nan_iface) {
    115         const auto& status_and_iface = HIDL_INVOKE(wifi_chip_, createNanIface);
    116         *nan_iface = status_and_iface.second;
    117         return status_and_iface.first.code;
    118     }
    119 
    120     WifiStatusCode removeNanIface(const std::string& name) {
    121         return HIDL_INVOKE(wifi_chip_, removeNanIface, name).code;
    122     }
    123 
    124     WifiStatusCode createP2pIface(sp<IWifiP2pIface>* p2p_iface) {
    125         const auto& status_and_iface = HIDL_INVOKE(wifi_chip_, createP2pIface);
    126         *p2p_iface = status_and_iface.second;
    127         return status_and_iface.first.code;
    128     }
    129 
    130     WifiStatusCode removeP2pIface(const std::string& name) {
    131         return HIDL_INVOKE(wifi_chip_, removeP2pIface, name).code;
    132     }
    133 
    134     WifiStatusCode createStaIface(sp<IWifiStaIface>* sta_iface) {
    135         const auto& status_and_iface = HIDL_INVOKE(wifi_chip_, createStaIface);
    136         *sta_iface = status_and_iface.second;
    137         return status_and_iface.first.code;
    138     }
    139 
    140     WifiStatusCode removeStaIface(const std::string& name) {
    141         return HIDL_INVOKE(wifi_chip_, removeStaIface, name).code;
    142     }
    143 
    144     sp<IWifiChip> wifi_chip_;
    145 };
    146 
    147 /*
    148  * Create:
    149  * Ensures that an instance of the IWifiChip proxy object is
    150  * successfully created.
    151  */
    152 TEST(WifiChipHidlTestNoFixture, Create) {
    153     EXPECT_NE(nullptr, getWifiChip().get());
    154     stopWifi();
    155 }
    156 
    157 /*
    158  * GetId:
    159  */
    160 TEST_F(WifiChipHidlTest, GetId) {
    161     EXPECT_EQ(WifiStatusCode::SUCCESS,
    162               HIDL_INVOKE(wifi_chip_, getId).first.code);
    163 }
    164 
    165 /*
    166  * GetAvailableMode:
    167  */
    168 TEST_F(WifiChipHidlTest, GetAvailableModes) {
    169     const auto& status_and_modes = HIDL_INVOKE(wifi_chip_, getAvailableModes);
    170     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_modes.first.code);
    171     EXPECT_LT(0u, status_and_modes.second.size());
    172 }
    173 
    174 /*
    175  * ConfigureChip:
    176  */
    177 TEST_F(WifiChipHidlTest, ConfigureChip) {
    178     const auto& status_and_modes = HIDL_INVOKE(wifi_chip_, getAvailableModes);
    179     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_modes.first.code);
    180     EXPECT_LT(0u, status_and_modes.second.size());
    181     for (const auto& mode : status_and_modes.second) {
    182         // configureChip() requires to be called with a fresh IWifiChip object.
    183         wifi_chip_ = getWifiChip();
    184         ASSERT_NE(nullptr, wifi_chip_.get());
    185         EXPECT_EQ(WifiStatusCode::SUCCESS,
    186                   HIDL_INVOKE(wifi_chip_, configureChip, mode.id).code);
    187         stopWifi();
    188         // Sleep for 5 milliseconds between each wifi state toggle.
    189         usleep(5000);
    190     }
    191 }
    192 
    193 /*
    194  * GetCapabilities:
    195  */
    196 TEST_F(WifiChipHidlTest, GetCapabilities) {
    197     configureChipForIfaceType(IfaceType::STA, true);
    198     const auto& status_and_caps = HIDL_INVOKE(wifi_chip_, getCapabilities);
    199     if (status_and_caps.first.code != WifiStatusCode::SUCCESS) {
    200         EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED, status_and_caps.first.code);
    201         return;
    202     }
    203     EXPECT_NE(0u, status_and_caps.second);
    204 }
    205 
    206 /*
    207  * GetMode:
    208  */
    209 TEST_F(WifiChipHidlTest, GetMode) {
    210     ChipModeId chip_mode_id = configureChipForIfaceType(IfaceType::STA, true);
    211     const auto& status_and_mode = HIDL_INVOKE(wifi_chip_, getMode);
    212     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_mode.first.code);
    213     EXPECT_EQ(chip_mode_id, status_and_mode.second);
    214 }
    215 
    216 /*
    217  * RequestChipDebugInfo:
    218  */
    219 TEST_F(WifiChipHidlTest, RequestChipDebugInfo) {
    220     configureChipForIfaceType(IfaceType::STA, true);
    221     const auto& status_and_chip_info =
    222         HIDL_INVOKE(wifi_chip_, requestChipDebugInfo);
    223     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_chip_info.first.code);
    224     EXPECT_LT(0u, status_and_chip_info.second.driverDescription.size());
    225     EXPECT_LT(0u, status_and_chip_info.second.firmwareDescription.size());
    226 }
    227 
    228 /*
    229  * RequestFirmwareDebugDump
    230  */
    231 TEST_F(WifiChipHidlTest, RequestFirmwareDebugDump) {
    232     uint32_t caps = configureChipForStaIfaceAndGetCapabilities();
    233     const auto& status_and_firmware_dump =
    234         HIDL_INVOKE(wifi_chip_, requestFirmwareDebugDump);
    235     if (caps & IWifiChip::ChipCapabilityMask::DEBUG_MEMORY_FIRMWARE_DUMP) {
    236         EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_firmware_dump.first.code);
    237     } else {
    238         EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED,
    239                   status_and_firmware_dump.first.code);
    240     }
    241 }
    242 
    243 /*
    244  * RequestDriverDebugDump
    245  */
    246 TEST_F(WifiChipHidlTest, RequestDriverDebugDump) {
    247     uint32_t caps = configureChipForStaIfaceAndGetCapabilities();
    248     const auto& status_and_driver_dump =
    249         HIDL_INVOKE(wifi_chip_, requestDriverDebugDump);
    250     if (caps & IWifiChip::ChipCapabilityMask::DEBUG_MEMORY_DRIVER_DUMP) {
    251         EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_driver_dump.first.code);
    252     } else {
    253       // API semantics (today) are such that function cannot be called if not capable!
    254       //
    255       //  EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED,
    256       //            status_and_driver_dump.first.code);
    257     }
    258 }
    259 
    260 /*
    261  * GetDebugRingBuffersStatus
    262  */
    263 TEST_F(WifiChipHidlTest, GetDebugRingBuffersStatus) {
    264     uint32_t caps = configureChipForStaIfaceAndGetCapabilities();
    265     const auto& status_and_ring_buffer_status =
    266         HIDL_INVOKE(wifi_chip_, getDebugRingBuffersStatus);
    267     if (hasAnyRingBufferCapabilities(caps)) {
    268         EXPECT_EQ(WifiStatusCode::SUCCESS,
    269                   status_and_ring_buffer_status.first.code);
    270         for (const auto& ring_buffer : status_and_ring_buffer_status.second) {
    271             EXPECT_LT(0u, ring_buffer.ringName.size());
    272         }
    273     } else {
    274         EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED,
    275                   status_and_ring_buffer_status.first.code);
    276     }
    277 }
    278 
    279 /*
    280  * StartLoggingToDebugRingBuffer
    281  */
    282 TEST_F(WifiChipHidlTest, StartLoggingToDebugRingBuffer) {
    283     uint32_t caps = configureChipForStaIfaceAndGetCapabilities();
    284     std::string ring_name;
    285     const auto& status_and_ring_buffer_status =
    286         HIDL_INVOKE(wifi_chip_, getDebugRingBuffersStatus);
    287     if (hasAnyRingBufferCapabilities(caps)) {
    288         EXPECT_EQ(WifiStatusCode::SUCCESS,
    289                   status_and_ring_buffer_status.first.code);
    290         ASSERT_LT(0u, status_and_ring_buffer_status.second.size());
    291         ring_name = status_and_ring_buffer_status.second[0].ringName.c_str();
    292     } else {
    293         EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED,
    294                   status_and_ring_buffer_status.first.code);
    295     }
    296     const auto& status =
    297         HIDL_INVOKE(wifi_chip_, startLoggingToDebugRingBuffer, ring_name,
    298                     kDebugRingBufferVerboseLvl, kDebugRingBufferMaxInterval,
    299                     kDebugRingBufferMaxDataSize);
    300     if (hasAnyRingBufferCapabilities(caps)) {
    301         EXPECT_EQ(WifiStatusCode::SUCCESS, status.code);
    302     } else {
    303         EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED, status.code);
    304     }
    305 }
    306 
    307 /*
    308  * ForceDumpToDebugRingBuffer
    309  */
    310 TEST_F(WifiChipHidlTest, ForceDumpToDebugRingBuffer) {
    311     uint32_t caps = configureChipForStaIfaceAndGetCapabilities();
    312     std::string ring_name;
    313     const auto& status_and_ring_buffer_status =
    314         HIDL_INVOKE(wifi_chip_, getDebugRingBuffersStatus);
    315     if (hasAnyRingBufferCapabilities(caps)) {
    316         EXPECT_EQ(WifiStatusCode::SUCCESS,
    317                   status_and_ring_buffer_status.first.code);
    318         ASSERT_LT(0u, status_and_ring_buffer_status.second.size());
    319         ring_name = status_and_ring_buffer_status.second[0].ringName.c_str();
    320     } else {
    321         EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED,
    322                   status_and_ring_buffer_status.first.code);
    323     }
    324     const auto& status =
    325         HIDL_INVOKE(wifi_chip_, forceDumpToDebugRingBuffer, ring_name);
    326     if (hasAnyRingBufferCapabilities(caps)) {
    327         EXPECT_EQ(WifiStatusCode::SUCCESS, status.code);
    328     } else {
    329         EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED, status.code);
    330     }
    331 }
    332 
    333 /*
    334  * GetDebugHostWakeReasonStats
    335  */
    336 TEST_F(WifiChipHidlTest, GetDebugHostWakeReasonStats) {
    337     uint32_t caps = configureChipForStaIfaceAndGetCapabilities();
    338     const auto& status_and_debug_wake_reason =
    339         HIDL_INVOKE(wifi_chip_, getDebugHostWakeReasonStats);
    340     if (caps & IWifiChip::ChipCapabilityMask::DEBUG_HOST_WAKE_REASON_STATS) {
    341         EXPECT_EQ(WifiStatusCode::SUCCESS,
    342                   status_and_debug_wake_reason.first.code);
    343     } else {
    344         EXPECT_EQ(WifiStatusCode::ERROR_NOT_SUPPORTED,
    345                   status_and_debug_wake_reason.first.code);
    346     }
    347 }
    348 
    349 /*
    350  * CreateApIface
    351  * Configures the chip in AP mode and ensures that only 1 iface creation
    352  * succeeds. The 2nd iface creation should be rejected.
    353  */
    354 TEST_F(WifiChipHidlTest, CreateApIface) {
    355     configureChipForIfaceType(IfaceType::AP, true);
    356 
    357     sp<IWifiApIface> iface;
    358     EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&iface));
    359     EXPECT_NE(nullptr, iface.get());
    360 
    361     EXPECT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createApIface(&iface));
    362 }
    363 
    364 /*
    365  * GetApIfaceNames
    366  * Configures the chip in AP mode and ensures that the iface list is empty
    367  * before creating the iface. Then, create the iface and ensure that
    368  * iface name is returned via the list.
    369  */
    370 TEST_F(WifiChipHidlTest, GetApIfaceNames) {
    371     configureChipForIfaceType(IfaceType::AP, true);
    372 
    373     const auto& status_and_iface_names1 =
    374         HIDL_INVOKE(wifi_chip_, getApIfaceNames);
    375     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names1.first.code);
    376     EXPECT_EQ(0u, status_and_iface_names1.second.size());
    377 
    378     sp<IWifiApIface> iface;
    379     EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&iface));
    380     EXPECT_NE(nullptr, iface.get());
    381 
    382     std::string iface_name = getIfaceName(iface);
    383     const auto& status_and_iface_names2 =
    384         HIDL_INVOKE(wifi_chip_, getApIfaceNames);
    385     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names2.first.code);
    386     EXPECT_EQ(1u, status_and_iface_names2.second.size());
    387     EXPECT_EQ(iface_name, status_and_iface_names2.second[0]);
    388 
    389     EXPECT_EQ(WifiStatusCode::SUCCESS, removeApIface(iface_name));
    390     const auto& status_and_iface_names3 =
    391         HIDL_INVOKE(wifi_chip_, getApIfaceNames);
    392     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names3.first.code);
    393     EXPECT_EQ(0u, status_and_iface_names3.second.size());
    394 }
    395 
    396 /*
    397  * GetApIface
    398  * Configures the chip in AP mode and create an iface. Then, retrieve
    399  * the iface object using the correct name and ensure any other name
    400  * doesn't retrieve an iface object.
    401  */
    402 TEST_F(WifiChipHidlTest, GetApIface) {
    403     configureChipForIfaceType(IfaceType::AP, true);
    404 
    405     sp<IWifiApIface> ap_iface;
    406     EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&ap_iface));
    407     EXPECT_NE(nullptr, ap_iface.get());
    408 
    409     std::string iface_name = getIfaceName(ap_iface);
    410     const auto& status_and_iface1 =
    411         HIDL_INVOKE(wifi_chip_, getApIface, iface_name);
    412     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface1.first.code);
    413     EXPECT_NE(nullptr, status_and_iface1.second.get());
    414 
    415     std::string invalid_name = iface_name + "0";
    416     const auto& status_and_iface2 =
    417         HIDL_INVOKE(wifi_chip_, getApIface, invalid_name);
    418     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, status_and_iface2.first.code);
    419     EXPECT_EQ(nullptr, status_and_iface2.second.get());
    420 }
    421 
    422 /*
    423  * RemoveApIface
    424  * Configures the chip in AP mode and create an iface. Then, remove
    425  * the iface object using the correct name and ensure any other name
    426  * doesn't remove the iface.
    427  */
    428 TEST_F(WifiChipHidlTest, RemoveApIface) {
    429     configureChipForIfaceType(IfaceType::AP, true);
    430 
    431     sp<IWifiApIface> ap_iface;
    432     EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&ap_iface));
    433     EXPECT_NE(nullptr, ap_iface.get());
    434 
    435     std::string iface_name = getIfaceName(ap_iface);
    436     std::string invalid_name = iface_name + "0";
    437     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeApIface(invalid_name));
    438     EXPECT_EQ(WifiStatusCode::SUCCESS, removeApIface(iface_name));
    439 
    440     // No such iface exists now. So, this should return failure.
    441     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeApIface(iface_name));
    442 }
    443 
    444 /*
    445  * CreateNanIface
    446  * Configures the chip in NAN mode and ensures that only 1 iface creation
    447  * succeeds. The 2nd iface creation should be rejected.
    448  */
    449 TEST_F(WifiChipHidlTest, CreateNanIface) {
    450     if (!gEnv->isNanOn) return;
    451     configureChipForIfaceType(IfaceType::NAN, gEnv->isNanOn);
    452 
    453     sp<IWifiNanIface> iface;
    454     ASSERT_EQ(WifiStatusCode::SUCCESS, createNanIface(&iface));
    455     EXPECT_NE(nullptr, iface.get());
    456 
    457     EXPECT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createNanIface(&iface));
    458 }
    459 
    460 /*
    461  * GetNanIfaceNames
    462  * Configures the chip in NAN mode and ensures that the iface list is empty
    463  * before creating the iface. Then, create the iface and ensure that
    464  * iface name is returned via the list.
    465  */
    466 TEST_F(WifiChipHidlTest, GetNanIfaceNames) {
    467     if (!gEnv->isNanOn) return;
    468     configureChipForIfaceType(IfaceType::NAN, gEnv->isNanOn);
    469 
    470     const auto& status_and_iface_names1 =
    471         HIDL_INVOKE(wifi_chip_, getNanIfaceNames);
    472     ASSERT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names1.first.code);
    473     EXPECT_EQ(0u, status_and_iface_names1.second.size());
    474 
    475     sp<IWifiNanIface> iface;
    476     EXPECT_EQ(WifiStatusCode::SUCCESS, createNanIface(&iface));
    477     EXPECT_NE(nullptr, iface.get());
    478 
    479     std::string iface_name = getIfaceName(iface);
    480     const auto& status_and_iface_names2 =
    481         HIDL_INVOKE(wifi_chip_, getNanIfaceNames);
    482     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names2.first.code);
    483     EXPECT_EQ(1u, status_and_iface_names2.second.size());
    484     EXPECT_EQ(iface_name, status_and_iface_names2.second[0]);
    485 
    486     EXPECT_EQ(WifiStatusCode::SUCCESS, removeNanIface(iface_name));
    487     const auto& status_and_iface_names3 =
    488         HIDL_INVOKE(wifi_chip_, getNanIfaceNames);
    489     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names3.first.code);
    490     EXPECT_EQ(0u, status_and_iface_names3.second.size());
    491 }
    492 
    493 /*
    494  * GetNanIface
    495  * Configures the chip in NAN mode and create an iface. Then, retrieve
    496  * the iface object using the correct name and ensure any other name
    497  * doesn't retrieve an iface object.
    498  */
    499 TEST_F(WifiChipHidlTest, GetNanIface) {
    500     if (!gEnv->isNanOn) return;
    501     configureChipForIfaceType(IfaceType::NAN, gEnv->isNanOn);
    502 
    503     sp<IWifiNanIface> nan_iface;
    504     EXPECT_EQ(WifiStatusCode::SUCCESS, createNanIface(&nan_iface));
    505     EXPECT_NE(nullptr, nan_iface.get());
    506 
    507     std::string iface_name = getIfaceName(nan_iface);
    508     const auto& status_and_iface1 =
    509         HIDL_INVOKE(wifi_chip_, getNanIface, iface_name);
    510     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface1.first.code);
    511     EXPECT_NE(nullptr, status_and_iface1.second.get());
    512 
    513     std::string invalid_name = iface_name + "0";
    514     const auto& status_and_iface2 =
    515         HIDL_INVOKE(wifi_chip_, getNanIface, invalid_name);
    516     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, status_and_iface2.first.code);
    517     EXPECT_EQ(nullptr, status_and_iface2.second.get());
    518 }
    519 
    520 /*
    521  * RemoveNanIface
    522  * Configures the chip in NAN mode and create an iface. Then, remove
    523  * the iface object using the correct name and ensure any other name
    524  * doesn't remove the iface.
    525  */
    526 TEST_F(WifiChipHidlTest, RemoveNanIface) {
    527     if (!gEnv->isNanOn) return;
    528     configureChipForIfaceType(IfaceType::NAN, gEnv->isNanOn);
    529 
    530     sp<IWifiNanIface> nan_iface;
    531     EXPECT_EQ(WifiStatusCode::SUCCESS, createNanIface(&nan_iface));
    532     EXPECT_NE(nullptr, nan_iface.get());
    533 
    534     std::string iface_name = getIfaceName(nan_iface);
    535     std::string invalid_name = iface_name + "0";
    536     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeNanIface(invalid_name));
    537 
    538     EXPECT_EQ(WifiStatusCode::SUCCESS, removeNanIface(iface_name));
    539 
    540     // No such iface exists now. So, this should return failure.
    541     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeNanIface(iface_name));
    542 }
    543 
    544 /*
    545  * CreateP2pIface
    546  * Configures the chip in P2P mode and ensures that only 1 iface creation
    547  * succeeds. The 2nd iface creation should be rejected.
    548  */
    549 TEST_F(WifiChipHidlTest, CreateP2pIface) {
    550     configureChipForIfaceType(IfaceType::P2P, true);
    551 
    552     sp<IWifiP2pIface> iface;
    553     EXPECT_EQ(WifiStatusCode::SUCCESS, createP2pIface(&iface));
    554     EXPECT_NE(nullptr, iface.get());
    555 
    556     EXPECT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createP2pIface(&iface));
    557 }
    558 
    559 /*
    560  * GetP2pIfaceNames
    561  * Configures the chip in P2P mode and ensures that the iface list is empty
    562  * before creating the iface. Then, create the iface and ensure that
    563  * iface name is returned via the list.
    564  */
    565 TEST_F(WifiChipHidlTest, GetP2pIfaceNames) {
    566     configureChipForIfaceType(IfaceType::P2P, true);
    567 
    568     const auto& status_and_iface_names1 =
    569         HIDL_INVOKE(wifi_chip_, getP2pIfaceNames);
    570     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names1.first.code);
    571     EXPECT_EQ(0u, status_and_iface_names1.second.size());
    572 
    573     sp<IWifiP2pIface> iface;
    574     EXPECT_EQ(WifiStatusCode::SUCCESS, createP2pIface(&iface));
    575     EXPECT_NE(nullptr, iface.get());
    576 
    577     std::string iface_name = getIfaceName(iface);
    578     const auto& status_and_iface_names2 =
    579         HIDL_INVOKE(wifi_chip_, getP2pIfaceNames);
    580     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names2.first.code);
    581     EXPECT_EQ(1u, status_and_iface_names2.second.size());
    582     EXPECT_EQ(iface_name, status_and_iface_names2.second[0]);
    583 
    584     EXPECT_EQ(WifiStatusCode::SUCCESS, removeP2pIface(iface_name));
    585     const auto& status_and_iface_names3 =
    586         HIDL_INVOKE(wifi_chip_, getP2pIfaceNames);
    587     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names3.first.code);
    588     EXPECT_EQ(0u, status_and_iface_names3.second.size());
    589 }
    590 
    591 /*
    592  * GetP2pIface
    593  * Configures the chip in P2P mode and create an iface. Then, retrieve
    594  * the iface object using the correct name and ensure any other name
    595  * doesn't retrieve an iface object.
    596  */
    597 TEST_F(WifiChipHidlTest, GetP2pIface) {
    598     configureChipForIfaceType(IfaceType::P2P, true);
    599 
    600     sp<IWifiP2pIface> p2p_iface;
    601     EXPECT_EQ(WifiStatusCode::SUCCESS, createP2pIface(&p2p_iface));
    602     EXPECT_NE(nullptr, p2p_iface.get());
    603 
    604     std::string iface_name = getIfaceName(p2p_iface);
    605     const auto& status_and_iface1 =
    606         HIDL_INVOKE(wifi_chip_, getP2pIface, iface_name);
    607     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface1.first.code);
    608     EXPECT_NE(nullptr, status_and_iface1.second.get());
    609 
    610     std::string invalid_name = iface_name + "0";
    611     const auto& status_and_iface2 =
    612         HIDL_INVOKE(wifi_chip_, getP2pIface, invalid_name);
    613     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, status_and_iface2.first.code);
    614     EXPECT_EQ(nullptr, status_and_iface2.second.get());
    615 }
    616 
    617 /*
    618  * RemoveP2pIface
    619  * Configures the chip in P2P mode and create an iface. Then, remove
    620  * the iface object using the correct name and ensure any other name
    621  * doesn't remove the iface.
    622  */
    623 TEST_F(WifiChipHidlTest, RemoveP2pIface) {
    624     configureChipForIfaceType(IfaceType::P2P, true);
    625 
    626     sp<IWifiP2pIface> p2p_iface;
    627     EXPECT_EQ(WifiStatusCode::SUCCESS, createP2pIface(&p2p_iface));
    628     EXPECT_NE(nullptr, p2p_iface.get());
    629 
    630     std::string iface_name = getIfaceName(p2p_iface);
    631     std::string invalid_name = iface_name + "0";
    632     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeP2pIface(invalid_name));
    633     EXPECT_EQ(WifiStatusCode::SUCCESS, removeP2pIface(iface_name));
    634 
    635     // No such iface exists now. So, this should return failure.
    636     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeP2pIface(iface_name));
    637 }
    638 
    639 /*
    640  * CreateStaIface
    641  * Configures the chip in STA mode and ensures that only 1 iface creation
    642  * succeeds. The 2nd iface creation should be rejected.
    643  */
    644 TEST_F(WifiChipHidlTest, CreateStaIface) {
    645     configureChipForIfaceType(IfaceType::STA, true);
    646 
    647     sp<IWifiStaIface> iface;
    648     EXPECT_EQ(WifiStatusCode::SUCCESS, createStaIface(&iface));
    649     EXPECT_NE(nullptr, iface.get());
    650 
    651     EXPECT_EQ(WifiStatusCode::ERROR_NOT_AVAILABLE, createStaIface(&iface));
    652 }
    653 
    654 /*
    655  * GetStaIfaceNames
    656  * Configures the chip in STA mode and ensures that the iface list is empty
    657  * before creating the iface. Then, create the iface and ensure that
    658  * iface name is returned via the list.
    659  */
    660 TEST_F(WifiChipHidlTest, GetStaIfaceNames) {
    661     configureChipForIfaceType(IfaceType::STA, true);
    662 
    663     const auto& status_and_iface_names1 =
    664         HIDL_INVOKE(wifi_chip_, getStaIfaceNames);
    665     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names1.first.code);
    666     EXPECT_EQ(0u, status_and_iface_names1.second.size());
    667 
    668     sp<IWifiStaIface> iface;
    669     EXPECT_EQ(WifiStatusCode::SUCCESS, createStaIface(&iface));
    670     EXPECT_NE(nullptr, iface.get());
    671 
    672     std::string iface_name = getIfaceName(iface);
    673     const auto& status_and_iface_names2 =
    674         HIDL_INVOKE(wifi_chip_, getStaIfaceNames);
    675     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names2.first.code);
    676     EXPECT_EQ(1u, status_and_iface_names2.second.size());
    677     EXPECT_EQ(iface_name, status_and_iface_names2.second[0]);
    678 
    679     EXPECT_EQ(WifiStatusCode::SUCCESS, removeStaIface(iface_name));
    680     const auto& status_and_iface_names3 =
    681         HIDL_INVOKE(wifi_chip_, getStaIfaceNames);
    682     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface_names3.first.code);
    683     EXPECT_EQ(0u, status_and_iface_names3.second.size());
    684 }
    685 
    686 /*
    687  * GetStaIface
    688  * Configures the chip in STA mode and create an iface. Then, retrieve
    689  * the iface object using the correct name and ensure any other name
    690  * doesn't retrieve an iface object.
    691  */
    692 TEST_F(WifiChipHidlTest, GetStaIface) {
    693     configureChipForIfaceType(IfaceType::STA, true);
    694 
    695     sp<IWifiStaIface> sta_iface;
    696     EXPECT_EQ(WifiStatusCode::SUCCESS, createStaIface(&sta_iface));
    697     EXPECT_NE(nullptr, sta_iface.get());
    698 
    699     std::string iface_name = getIfaceName(sta_iface);
    700     const auto& status_and_iface1 =
    701         HIDL_INVOKE(wifi_chip_, getStaIface, iface_name);
    702     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_iface1.first.code);
    703     EXPECT_NE(nullptr, status_and_iface1.second.get());
    704 
    705     std::string invalid_name = iface_name + "0";
    706     const auto& status_and_iface2 =
    707         HIDL_INVOKE(wifi_chip_, getStaIface, invalid_name);
    708     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, status_and_iface2.first.code);
    709     EXPECT_EQ(nullptr, status_and_iface2.second.get());
    710 }
    711 
    712 /*
    713  * RemoveStaIface
    714  * Configures the chip in STA mode and create an iface. Then, remove
    715  * the iface object using the correct name and ensure any other name
    716  * doesn't remove the iface.
    717  */
    718 TEST_F(WifiChipHidlTest, RemoveStaIface) {
    719     configureChipForIfaceType(IfaceType::STA, true);
    720 
    721     sp<IWifiStaIface> sta_iface;
    722     EXPECT_EQ(WifiStatusCode::SUCCESS, createStaIface(&sta_iface));
    723     EXPECT_NE(nullptr, sta_iface.get());
    724 
    725     std::string iface_name = getIfaceName(sta_iface);
    726     std::string invalid_name = iface_name + "0";
    727     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeStaIface(invalid_name));
    728     EXPECT_EQ(WifiStatusCode::SUCCESS, removeStaIface(iface_name));
    729 
    730     // No such iface exists now. So, this should return failure.
    731     EXPECT_EQ(WifiStatusCode::ERROR_INVALID_ARGS, removeStaIface(iface_name));
    732 }
    733 
    734 /*
    735  * CreateRttController
    736  */
    737 TEST_F(WifiChipHidlTest, CreateRttController) {
    738     configureChipForIfaceType(IfaceType::AP, true);
    739 
    740     sp<IWifiApIface> iface;
    741     EXPECT_EQ(WifiStatusCode::SUCCESS, createApIface(&iface));
    742     EXPECT_NE(nullptr, iface.get());
    743 
    744     const auto& status_and_rtt_controller =
    745         HIDL_INVOKE(wifi_chip_, createRttController, iface);
    746     EXPECT_EQ(WifiStatusCode::SUCCESS, status_and_rtt_controller.first.code);
    747     EXPECT_NE(nullptr, status_and_rtt_controller.second.get());
    748 }
    749