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