1/* 2 * Copyright (c) 2021-2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16#include <gtest/gtest.h> 17#include <osal_mem.h> 18#include "hdf_base.h" 19#include "hdf_sbuf.h" 20#include "wifi_hal.h" 21#include "wifi_hal_ap_feature.h" 22#include "wifi_hal_base_feature.h" 23#include "wifi_hal_sta_feature.h" 24#include "securec.h" 25 26struct ElementHeader { 27 uint8_t id; 28 uint8_t datalen; 29}; 30 31using namespace testing::ext; 32 33namespace HalTest { 34struct IWiFi *g_wifi = nullptr; 35const int32_t WLAN_TX_POWER = 160; 36const uint32_t IFNAME_MIN_NUM = 0; 37const uint32_t IFNAME_MAX_NUM = 32; 38const uint32_t MAX_IF_NAME_LENGTH = 16; 39const uint32_t TEST_PARAM_BUF_SIZE = 64; 40const uint32_t SIZE = 4; 41const int32_t TEST_CMD = 123; 42const uint32_t RESET_TIME = 3; 43const uint32_t SCAN_TIME = 3; 44const uint32_t TEST_BUF_SIZE = 64; 45const uint32_t WLAN_EID_SSID = 0; 46 47class WifiHalTest : public testing::Test { 48public: 49 static void SetUpTestCase(); 50 static void TearDownTestCase(); 51 void SetUp(); 52 void TearDown(); 53}; 54 55void WifiHalTest::SetUpTestCase() 56{ 57 int ret; 58 59 ret = WifiConstruct(&g_wifi); 60 ASSERT_EQ(HDF_SUCCESS, ret); 61} 62 63void WifiHalTest::TearDownTestCase() 64{ 65 int ret; 66 67 ret = WifiDestruct(&g_wifi); 68 ASSERT_EQ(HDF_SUCCESS, ret); 69} 70 71void WifiHalTest::SetUp() 72{ 73 int ret; 74 75 ret = g_wifi->start(nullptr); 76 ASSERT_EQ(HDF_ERR_INVALID_PARAM, ret); 77 ret = g_wifi->start(g_wifi); 78 ASSERT_EQ(HDF_SUCCESS, ret); 79} 80 81void WifiHalTest::TearDown() 82{ 83 int ret; 84 85 ret = g_wifi->stop(nullptr); 86 ASSERT_EQ(HDF_ERR_INVALID_PARAM, ret); 87 ret = g_wifi->stop(g_wifi); 88 ASSERT_EQ(HDF_SUCCESS, ret); 89} 90 91static void PrintSsid(const uint8_t *ie, uint32_t len) 92{ 93 char ssid[MAX_SSID_LEN] = {0}; 94 uint8_t *pos = NULL; 95 struct ElementHeader *hdr = (struct ElementHeader *)ie; 96 97 if (ie == NULL || len < sizeof(struct ElementHeader)) { 98 return; 99 } 100 while (ie + len >= ((uint8_t *)hdr + sizeof(*hdr) + hdr->datalen)) { 101 pos = (uint8_t *)hdr + sizeof(*hdr); 102 if (hdr->id == WLAN_EID_SSID) { 103 if (hdr->datalen < MAX_SSID_LEN && memcpy_s(ssid, MAX_SSID_LEN, pos, hdr->datalen) == EOK) { 104 printf("ssid: %s\n", ssid); 105 } 106 return; 107 } 108 hdr = (struct ElementHeader *)(pos + hdr->datalen); 109 } 110} 111 112static void ParseScanResult(WifiScanResult *scanResult) 113{ 114 printf("ParseScanResult: flags=%d, caps=%d, freq=%d, beaconInt=%d,\n", scanResult->flags, scanResult->caps, 115 scanResult->freq, scanResult->beaconInt); 116 printf("ParseScanResult: qual=%d, beaconIeLen=%d, level=%d, age=%d, ieLen=%d,\n", scanResult->qual, 117 scanResult->beaconIeLen, scanResult->level, scanResult->age, scanResult->ieLen); 118 PrintSsid(scanResult->ie, scanResult->ieLen); 119} 120 121static void ParseScanResults(WifiScanResults *scanResults) 122{ 123 uint32_t i; 124 printf("Receive %u scan results\n", scanResults->num); 125 for (i = 0 ; i < scanResults->num; i++) { 126 ParseScanResult(&scanResults->scanResult[i]); 127 } 128} 129 130static int32_t Hid2dFunCb(const uint8_t *recvMsg, uint32_t recvMsgLen) 131{ 132 (void)recvMsg; 133 (void)recvMsgLen; 134 return HDF_SUCCESS; 135} 136 137/** 138 * @tc.name: WifiHalCreateAndDestroyFeature001 139 * @tc.desc: Wifi hal create and destroy feature function test 140 * @tc.type: FUNC 141 * @tc.require: AR000F869G 142 */ 143HWTEST_F(WifiHalTest, WifiHalCreateAndDestroyFeature001, TestSize.Level1) 144{ 145 int ret; 146 struct IWiFiAp *apFeature = nullptr; 147 148 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 149 if (ret == HDF_SUCCESS) { 150 EXPECT_NE(nullptr, apFeature); 151 ret = g_wifi->destroyFeature(nullptr); 152 EXPECT_NE(HDF_SUCCESS, ret); 153 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 154 EXPECT_EQ(HDF_SUCCESS, ret); 155 } 156} 157 158/** 159 * @tc.name: WifiHalCreateAndDestroyFeature002 160 * @tc.desc: Wifi hal create and destroy feature function test 161 * @tc.type: FUNC 162 * @tc.require: AR000F869E 163 */ 164HWTEST_F(WifiHalTest, WifiHalCreateAndDestroyFeature002, TestSize.Level1) 165{ 166 int ret; 167 struct IWiFiSta *staFeature = nullptr; 168 169 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 170 if (ret == HDF_SUCCESS) { 171 EXPECT_NE(nullptr, staFeature); 172 ret = g_wifi->destroyFeature(nullptr); 173 EXPECT_NE(HDF_SUCCESS, ret); 174 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 175 EXPECT_EQ(HDF_SUCCESS, ret); 176 } 177} 178 179/** 180 * @tc.name: WifiHalGetFeatureByIfName001 181 * @tc.desc: Wifi hal get feature by ifname function test 182 * @tc.type: FUNC 183 * @tc.require: AR000F869G 184 */ 185HWTEST_F(WifiHalTest, WifiHalGetFeatureByIfName001, TestSize.Level1) 186{ 187 int ret; 188 struct IWiFiAp *apFeature = nullptr; 189 struct IWiFiAp *apFeatureGet = nullptr; 190 const char *ifName0 = "wlanTest"; 191 192 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 193 if (ret == HDF_SUCCESS) { 194 EXPECT_NE(nullptr, apFeature); 195 ret = g_wifi->getFeatureByIfName(nullptr, (struct IWiFiBaseFeature **)&apFeatureGet); 196 EXPECT_NE(HDF_SUCCESS, ret); 197 ret = g_wifi->getFeatureByIfName(ifName0, (struct IWiFiBaseFeature **)&apFeatureGet); 198 EXPECT_NE(HDF_SUCCESS, ret); 199 ret = g_wifi->getFeatureByIfName(apFeature->baseFeature.ifName, (struct IWiFiBaseFeature **)&apFeatureGet); 200 EXPECT_EQ(HDF_SUCCESS, ret); 201 EXPECT_NE(nullptr, apFeatureGet); 202 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 203 EXPECT_EQ(HDF_SUCCESS, ret); 204 } 205} 206 207static int32_t HalCallbackEvent(uint32_t event, void *respData, const char *ifName) 208{ 209 (void)event; 210 if (respData == nullptr) { 211 return HDF_FAILURE; 212 } 213 printf("HalCallbackEvent ifName = %s, event = %d\n", ifName, event); 214 switch (event) { 215 case WIFI_EVENT_SCAN_DONE: 216 printf("HalCallbackEvent WIFI_EVENT_SCAN_DONE Process\n"); 217 break; 218 case WIFI_EVENT_SCAN_RESULT: 219 ParseScanResult((WifiScanResult *)respData); 220 break; 221 case WIFI_EVENT_SCAN_RESULTS: 222 ParseScanResults((WifiScanResults *)respData); 223 break; 224 default: 225 printf("HalCallbackEvent: Invalid event\n"); 226 } 227 return HDF_SUCCESS; 228} 229 230/** 231 * @tc.name: WifiHalRegisterEventCallback001 232 * @tc.desc: Wifi hal register callback function test 233 * @tc.type: FUNC 234 * @tc.require: AR000F869G 235 */ 236HWTEST_F(WifiHalTest, WifiHalRegisterEventCallback001, TestSize.Level1) 237{ 238 int ret; 239 240 ret = g_wifi->registerEventCallback(HalCallbackEvent, "wlan0"); 241 EXPECT_EQ(HDF_SUCCESS, ret); 242} 243 244/** 245 * @tc.name: WifiHalUnRegisterEventCallback001 246 * @tc.desc: Wifi hal unregister callback function test 247 * @tc.type: FUNC 248 * @tc.require: AR000F869G 249 */ 250HWTEST_F(WifiHalTest, WifiHalUnRegisterEventCallback001, TestSize.Level1) 251{ 252 int ret; 253 254 ret = g_wifi->unregisterEventCallback(HalCallbackEvent, "wlan0"); 255 EXPECT_EQ(HDF_SUCCESS, ret); 256} 257 258/** 259 * @tc.name: WifiHalGetNetworkIfaceName001 260 * @tc.desc: Wifi hal get network iface name function test 261 * @tc.type: FUNC 262 * @tc.require: AR000F869G 263 */ 264HWTEST_F(WifiHalTest, WifiHalGetNetworkIfaceName001, TestSize.Level1) 265{ 266 int ret; 267 struct IWiFiAp *apFeature = nullptr; 268 269 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 270 if (ret == HDF_SUCCESS) { 271 EXPECT_NE(nullptr, apFeature); 272 const char *ifnameTest = apFeature->baseFeature.getNetworkIfaceName(nullptr); 273 EXPECT_EQ(nullptr, ifnameTest); 274 const char *ifName = apFeature->baseFeature.getNetworkIfaceName((const struct IWiFiBaseFeature *)apFeature); 275 EXPECT_NE(nullptr, ifName); 276 if (strncmp(ifName, "wlan", 4) == 0 || strncmp(ifName, "nan", 3) == 0 || strncmp(ifName, "p2p", 3) == 0) { 277 ret = 0; 278 } else { 279 ret = -1; 280 } 281 EXPECT_EQ(0, ret); 282 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 283 EXPECT_EQ(HDF_SUCCESS, ret); 284 } 285} 286 287/** 288 * @tc.name: WifiHalGetGetFeatureType001 289 * @tc.desc: Wifi hal get feature type function test 290 * @tc.type: FUNC 291 * @tc.require: AR000F869G 292 */ 293HWTEST_F(WifiHalTest, WifiHalGetGetFeatureType001, TestSize.Level1) 294{ 295 int ret; 296 struct IWiFiAp *apFeature = nullptr; 297 int32_t type; 298 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 299 if (ret == HDF_SUCCESS) { 300 EXPECT_NE(nullptr, apFeature); 301 type = apFeature->baseFeature.getFeatureType(nullptr); 302 EXPECT_EQ(HDF_FAILURE, type); 303 type = apFeature->baseFeature.getFeatureType((struct IWiFiBaseFeature *)apFeature); 304 EXPECT_EQ(PROTOCOL_80211_IFTYPE_AP, type); 305 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 306 EXPECT_EQ(HDF_SUCCESS, ret); 307 } 308} 309 310/** 311 * @tc.name: WifiHalSetMacAddress001 312 * @tc.desc: Wifi hal set Mac address function test 313 * @tc.type: FUNC 314 * @tc.require: AR000F869G 315 */ 316HWTEST_F(WifiHalTest, WifiHalSetMacAddress001, TestSize.Level1) 317{ 318 int ret; 319 struct IWiFiAp *apFeature = nullptr; 320 unsigned char errorMac[ETH_ADDR_LEN] = {0x11, 0x34, 0x56, 0x78, 0xab, 0xcd}; 321 unsigned char mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd}; 322 323 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 324 if (ret == HDF_SUCCESS) { 325 EXPECT_NE(nullptr, apFeature); 326 ret = apFeature->baseFeature.setMacAddress(nullptr, mac, ETH_ADDR_LEN); 327 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 328 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, nullptr, ETH_ADDR_LEN); 329 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 330 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, mac, 0); 331 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 332 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, errorMac, ETH_ADDR_LEN); 333 EXPECT_NE(HDF_SUCCESS, ret); 334 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, mac, ETH_ADDR_LEN); 335 printf("%s: ret = %d\n", __func__, ret); 336 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_DEVICE_BUSY); 337 ASSERT_TRUE(flag); 338 339 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 340 EXPECT_EQ(HDF_SUCCESS, ret); 341 } 342} 343 344/** 345 * @tc.name: WifiHalSetMacAddress002 346 * @tc.desc: Wifi hal set Mac address function test 347 * @tc.type: FUNC 348 * @tc.require: AR000F869E 349 */ 350HWTEST_F(WifiHalTest, WifiHalSetMacAddress002, TestSize.Level1) 351{ 352 int ret; 353 struct IWiFiSta *staFeature = nullptr; 354 unsigned char mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd}; 355 unsigned char errorMac[ETH_ADDR_LEN] = {0x11, 0x34, 0x56, 0x78, 0xab, 0xcd}; 356 357 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 358 if (ret == HDF_SUCCESS) { 359 EXPECT_NE(nullptr, staFeature); 360 ret = staFeature->baseFeature.setMacAddress(nullptr, mac, ETH_ADDR_LEN); 361 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 362 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, nullptr, ETH_ADDR_LEN); 363 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 364 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, mac, 0); 365 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 366 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, errorMac, ETH_ADDR_LEN); 367 EXPECT_NE(HDF_SUCCESS, ret); 368 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, mac, ETH_ADDR_LEN); 369 printf("%s: ret = %d\n", __func__, ret); 370 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_DEVICE_BUSY); 371 ASSERT_TRUE(flag); 372 373 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 374 EXPECT_EQ(HDF_SUCCESS, ret); 375 } 376} 377 378/** 379 * @tc.name: WifiHalSetTxPower001 380 * @tc.desc: Wifi hal set transmit power function test 381 * @tc.type: FUNC 382 * @tc.require: AR000F869G 383 */ 384HWTEST_F(WifiHalTest, WifiHalSetTxPower001, TestSize.Level1) 385{ 386 int ret; 387 struct IWiFiAp *apFeature = nullptr; 388 389 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 390 if (ret == HDF_SUCCESS) { 391 EXPECT_NE(nullptr, apFeature); 392 ret = apFeature->baseFeature.setTxPower(nullptr, WLAN_TX_POWER); 393 EXPECT_NE(HDF_SUCCESS, ret); 394 ret = apFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)apFeature, 0); 395 EXPECT_NE(HDF_SUCCESS, ret); 396 ret = apFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)apFeature, WLAN_TX_POWER); 397 EXPECT_EQ(HDF_SUCCESS, ret); 398 399 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 400 EXPECT_EQ(HDF_SUCCESS, ret); 401 } 402} 403 404/** 405 * @tc.name: ResetDriver001 406 * @tc.desc: wifi hal reset driver function test 407 * @tc.type: FUNC 408 * @tc.require: 409 */ 410HWTEST_F(WifiHalTest, ResetDriver001, TestSize.Level1) 411{ 412 int32_t ret; 413 struct IWiFiSta *staFeature = nullptr; 414 uint8_t chipId = 0; 415 uint8_t chipIdInvalid = 20; 416 417 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 418 if (ret == HDF_SUCCESS) { 419 EXPECT_NE(nullptr, staFeature); 420 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId); 421 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE); 422 EXPECT_EQ(HDF_SUCCESS, ret); 423 424 ret = g_wifi->resetDriver(chipIdInvalid, "wlan0"); 425 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 426 ret = g_wifi->resetDriver(chipId, nullptr); 427 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 428 ret = g_wifi->resetDriver(chipId, staFeature->baseFeature.ifName); 429 EXPECT_EQ(HDF_SUCCESS, ret); 430 sleep(RESET_TIME); 431 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 432 EXPECT_EQ(HDF_SUCCESS, ret); 433 } 434} 435 436/** 437 * @tc.name: ResetDriver002 438 * @tc.desc: wifi hal reset driver function test 439 * @tc.type: FUNC 440 * @tc.require: 441 */ 442HWTEST_F(WifiHalTest, ResetDriver002, TestSize.Level1) 443{ 444 int32_t ret; 445 struct IWiFiAp *apFeature = nullptr; 446 uint8_t chipId = 0; 447 uint8_t chipIdInvalid = 20; 448 449 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 450 if (ret == HDF_SUCCESS) { 451 EXPECT_NE(nullptr, apFeature); 452 ret = apFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)apFeature, &chipId); 453 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE); 454 EXPECT_EQ(HDF_SUCCESS, ret); 455 456 ret = g_wifi->resetDriver(chipIdInvalid, "wlan0"); 457 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 458 ret = g_wifi->resetDriver(chipId, nullptr); 459 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 460 ret = g_wifi->resetDriver(chipId, apFeature->baseFeature.ifName); 461 EXPECT_EQ(HDF_SUCCESS, ret); 462 sleep(RESET_TIME); 463 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 464 EXPECT_EQ(HDF_SUCCESS, ret); 465 } 466} 467 468/** 469 * @tc.name: WifiHalSetCountryCode001 470 * @tc.desc: Wifi hal set country code function test 471 * @tc.type: FUNC 472 * @tc.require: AR000F869K 473 */ 474HWTEST_F(WifiHalTest, WifiHalSetCountryCode001, TestSize.Level1) 475{ 476 int ret; 477 struct IWiFiAp *apFeature = nullptr; 478 479 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 480 if (ret == HDF_SUCCESS) { 481 EXPECT_NE(nullptr, apFeature); 482 ret = apFeature->setCountryCode(apFeature, nullptr, 0); 483 EXPECT_NE(HDF_SUCCESS, ret); 484 ret = apFeature->setCountryCode(nullptr, "CN", 2); 485 EXPECT_NE(HDF_SUCCESS, ret); 486 ret = apFeature->setCountryCode(apFeature, "CN", 3); 487 EXPECT_NE(HDF_SUCCESS, ret); 488 ret = apFeature->setCountryCode(apFeature, "99", 2); 489 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_TIMEOUT || ret == HDF_FAILURE); 490 ASSERT_TRUE(flag); 491 ret = apFeature->setCountryCode(apFeature, "CN", 2); 492 EXPECT_EQ(HDF_SUCCESS, ret); 493 494 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 495 EXPECT_EQ(HDF_SUCCESS, ret); 496 } 497} 498 499/** 500 * @tc.name: WifiHalGetIfNamesByChipId001 501 * @tc.desc: Obtain all ifNames and the number of the current chip 502 * @tc.type: FUNC 503 * @tc.require: AR000F869G 504 */ 505HWTEST_F(WifiHalTest, WifiHalGetIfNamesByChipId001, TestSize.Level1) 506{ 507 int ret; 508 struct IWiFiSta *staFeature = nullptr; 509 char *ifNames = nullptr; 510 unsigned int num = 0; 511 unsigned char chipId = 0; 512 uint8_t i; 513 514 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 515 if (ret == HDF_SUCCESS) { 516 EXPECT_NE(nullptr, staFeature); 517 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId); 518 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE); 519 EXPECT_EQ(HDF_SUCCESS, ret); 520 ret = staFeature->baseFeature.getIfNamesByChipId(chipId, nullptr, nullptr); 521 EXPECT_NE(HDF_SUCCESS, ret); 522 ret = staFeature->baseFeature.getIfNamesByChipId(100, &ifNames, &num); 523 EXPECT_NE(HDF_SUCCESS, ret); 524 ret = staFeature->baseFeature.getIfNamesByChipId(chipId, &ifNames, &num); 525 EXPECT_NE(nullptr, ifNames); 526 EXPECT_EQ(HDF_SUCCESS, ret); 527 ASSERT_TRUE(num <= IFNAME_MAX_NUM && num >= IFNAME_MIN_NUM); 528 for (i = 0; i < num; i++) { 529 EXPECT_EQ(0, strncmp("wlan", ifNames + i * MAX_IF_NAME_LENGTH, SIZE)); 530 } 531 free(ifNames); 532 533 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 534 EXPECT_EQ(HDF_SUCCESS, ret); 535 } 536} 537 538HWTEST_F(WifiHalTest, GetNetDevInfo001, TestSize.Level1) 539{ 540 int ret; 541 struct IWiFiAp *apFeature = nullptr; 542 struct NetDeviceInfoResult netDeviceInfoResult; 543 544 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 545 if (ret == HDF_SUCCESS) { 546 EXPECT_NE(nullptr, apFeature); 547 ret = g_wifi->getNetDevInfo(nullptr); 548 EXPECT_NE(HDF_SUCCESS, ret); 549 ret = g_wifi->getNetDevInfo(&netDeviceInfoResult); 550 EXPECT_EQ(HDF_SUCCESS, ret); 551 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 552 EXPECT_EQ(HDF_SUCCESS, ret); 553 } 554} 555 556HWTEST_F(WifiHalTest, GetNetDevInfo002, TestSize.Level1) 557{ 558 int ret; 559 struct IWiFiSta *staFeature = nullptr; 560 struct NetDeviceInfoResult netDeviceInfoResult; 561 562 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 563 if (ret == HDF_SUCCESS) { 564 EXPECT_NE(nullptr, staFeature); 565 ret = g_wifi->getNetDevInfo(nullptr); 566 EXPECT_NE(HDF_SUCCESS, ret); 567 ret = g_wifi->getNetDevInfo(&netDeviceInfoResult); 568 EXPECT_EQ(HDF_SUCCESS, ret); 569 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 570 EXPECT_EQ(HDF_SUCCESS, ret); 571 } 572} 573 574/** 575 * @tc.name: GetPowerModeTest_001 576 * @tc.desc: Wifi hdi get power mode function test 577 * @tc.type: FUNC 578 * @tc.require: AR000H60O7 579 */ 580HWTEST_F(WifiHalTest, GetPowerMode001, TestSize.Level1) 581{ 582 int32_t ret; 583 struct IWiFiAp *apFeature = nullptr; 584 const char *ifName = "eth0"; 585 uint8_t mode; 586 587 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 588 if (ret == HDF_SUCCESS) { 589 EXPECT_NE(nullptr, apFeature); 590 printf("GetPowerMode001: ifname is %s\n", apFeature->baseFeature.ifName); 591 ret = g_wifi->getPowerMode(nullptr, &mode); 592 EXPECT_NE(HDF_SUCCESS, ret); 593 ret = g_wifi->getPowerMode(ifName, nullptr); 594 EXPECT_NE(HDF_SUCCESS, ret); 595 ret = g_wifi->getPowerMode(ifName, &mode); 596 EXPECT_NE(HDF_SUCCESS, ret); 597 ret = g_wifi->getPowerMode(apFeature->baseFeature.ifName, nullptr); 598 EXPECT_NE(HDF_SUCCESS, ret); 599 ret = g_wifi->getPowerMode(apFeature->baseFeature.ifName, &mode); 600 printf("%s: ret = %d\n", __func__, ret); 601 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 602 ASSERT_TRUE(flag); 603 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 604 EXPECT_EQ(HDF_SUCCESS, ret); 605 } 606} 607 608/** 609 * @tc.name: GetPowerModeTest_002 610 * @tc.desc: Wifi hdi get power mode function test 611 * @tc.type: FUNC 612 * @tc.require: AR000H60O7 613 */ 614HWTEST_F(WifiHalTest, GetPowerMode002, TestSize.Level1) 615{ 616 int32_t ret; 617 struct IWiFiSta *staFeature = nullptr; 618 const char *ifName = "eth0"; 619 uint8_t mode; 620 621 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 622 if (ret == HDF_SUCCESS) { 623 EXPECT_NE(nullptr, staFeature); 624 printf("GetPowerMode002: ifname is %s\n", staFeature->baseFeature.ifName); 625 ret = g_wifi->getPowerMode(nullptr, &mode); 626 EXPECT_NE(HDF_SUCCESS, ret); 627 ret = g_wifi->getPowerMode(ifName, nullptr); 628 EXPECT_NE(HDF_SUCCESS, ret); 629 ret = g_wifi->getPowerMode(ifName, &mode); 630 EXPECT_NE(HDF_SUCCESS, ret); 631 ret = g_wifi->getPowerMode(staFeature->baseFeature.ifName, nullptr); 632 EXPECT_NE(HDF_SUCCESS, ret); 633 ret = g_wifi->getPowerMode(staFeature->baseFeature.ifName, &mode); 634 printf("%s: ret = %d\n", __func__, ret); 635 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 636 ASSERT_TRUE(flag); 637 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 638 EXPECT_EQ(HDF_SUCCESS, ret); 639 } 640} 641 642/** 643 * @tc.name: SetPowerMode001 644 * @tc.desc: Wifi hdi set power mode function test 645 * @tc.type: FUNC 646 * @tc.require: AR000H60O7 647 */ 648HWTEST_F(WifiHalTest, SetPowerMode001, TestSize.Level1) 649{ 650 int32_t ret; 651 struct IWiFiAp *apFeature = nullptr; 652 const char *ifName = "eth0"; 653 654 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 655 if (ret == HDF_SUCCESS) { 656 EXPECT_NE(nullptr, apFeature); 657 printf("SetPowerMode001: ifname is %s\n", apFeature->baseFeature.ifName); 658 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_NUM); 659 EXPECT_NE(HDF_SUCCESS, ret); 660 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_NUM); 661 EXPECT_NE(HDF_SUCCESS, ret); 662 ret = g_wifi->setPowerMode(apFeature->baseFeature.ifName, WIFI_POWER_MODE_NUM); 663 EXPECT_NE(HDF_SUCCESS, ret); 664 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 665 EXPECT_EQ(HDF_SUCCESS, ret); 666 } 667} 668 669/** 670 * @tc.name: SetPowerMode002 671 * @tc.desc: Wifi hdi set power mode function test 672 * @tc.type: FUNC 673 * @tc.require: AR000H60O7 674 */ 675HWTEST_F(WifiHalTest, SetPowerMode002, TestSize.Level1) 676{ 677 int32_t ret; 678 struct IWiFiAp *apFeature = nullptr; 679 const char *ifName = "eth0"; 680 681 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 682 if (ret == HDF_SUCCESS) { 683 EXPECT_NE(nullptr, apFeature); 684 printf("SetPowerMode002: ifname is %s\n", apFeature->baseFeature.ifName); 685 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_SLEEPING); 686 EXPECT_NE(HDF_SUCCESS, ret); 687 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_SLEEPING); 688 EXPECT_NE(HDF_SUCCESS, ret); 689 ret = g_wifi->setPowerMode(apFeature->baseFeature.ifName, WIFI_POWER_MODE_SLEEPING); 690 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 691 ASSERT_TRUE(flag); 692 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 693 EXPECT_EQ(HDF_SUCCESS, ret); 694 } 695} 696 697/** 698 * @tc.name: SetPowerMode003 699 * @tc.desc: Wifi hdi set power mode function test 700 * @tc.type: FUNC 701 * @tc.require: AR000H60O7 702 */ 703HWTEST_F(WifiHalTest, SetPowerMode003, TestSize.Level1) 704{ 705 int32_t ret; 706 struct IWiFiAp *apFeature = nullptr; 707 const char *ifName = "eth0"; 708 709 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 710 if (ret == HDF_SUCCESS) { 711 EXPECT_NE(nullptr, apFeature); 712 printf("SetPowerMode003: ifname is %s\n", apFeature->baseFeature.ifName); 713 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_GENERAL); 714 EXPECT_NE(HDF_SUCCESS, ret); 715 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_GENERAL); 716 EXPECT_NE(HDF_SUCCESS, ret); 717 ret = g_wifi->setPowerMode(apFeature->baseFeature.ifName, WIFI_POWER_MODE_GENERAL); 718 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 719 ASSERT_TRUE(flag); 720 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 721 EXPECT_EQ(HDF_SUCCESS, ret); 722 } 723} 724 725/** 726 * @tc.name: SetPowerMode004 727 * @tc.desc: Wifi hdi set power mode function test 728 * @tc.type: FUNC 729 * @tc.require: AR000H60O7 730 */ 731HWTEST_F(WifiHalTest, SetPowerMode004, TestSize.Level1) 732{ 733 int32_t ret; 734 struct IWiFiAp *apFeature = nullptr; 735 const char *ifName = "eth0"; 736 737 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 738 if (ret == HDF_SUCCESS) { 739 EXPECT_NE(nullptr, apFeature); 740 printf("SetPowerMode004: ifname is %s\n", apFeature->baseFeature.ifName); 741 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_THROUGH_WALL); 742 EXPECT_NE(HDF_SUCCESS, ret); 743 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_THROUGH_WALL); 744 EXPECT_NE(HDF_SUCCESS, ret); 745 ret = g_wifi->setPowerMode(apFeature->baseFeature.ifName, WIFI_POWER_MODE_THROUGH_WALL); 746 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 747 ASSERT_TRUE(flag); 748 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 749 EXPECT_EQ(HDF_SUCCESS, ret); 750 } 751} 752 753/** 754 * @tc.name: SetPowerMode005 755 * @tc.desc: Wifi hdi set power mode function test 756 * @tc.type: FUNC 757 * @tc.require: AR000H60O7 758 */ 759HWTEST_F(WifiHalTest, SetPowerMode005, TestSize.Level1) 760{ 761 int32_t ret; 762 struct IWiFiSta *staFeature = nullptr; 763 const char *ifName = "eth0"; 764 765 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 766 if (ret == HDF_SUCCESS) { 767 EXPECT_NE(nullptr, staFeature); 768 printf("SetPowerMode005: ifname is %s\n", staFeature->baseFeature.ifName); 769 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_NUM); 770 EXPECT_NE(HDF_SUCCESS, ret); 771 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_NUM); 772 EXPECT_NE(HDF_SUCCESS, ret); 773 ret = g_wifi->setPowerMode(staFeature->baseFeature.ifName, WIFI_POWER_MODE_NUM); 774 EXPECT_NE(HDF_SUCCESS, ret); 775 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 776 EXPECT_EQ(HDF_SUCCESS, ret); 777 } 778} 779 780/** 781 * @tc.name: SetPowerMode006 782 * @tc.desc: Wifi hdi set power mode function test 783 * @tc.type: FUNC 784 * @tc.require: AR000H60O7 785 */ 786HWTEST_F(WifiHalTest, SetPowerMode006, TestSize.Level1) 787{ 788 int32_t ret; 789 struct IWiFiSta *staFeature = nullptr; 790 const char *ifName = "eth0"; 791 792 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 793 if (ret == HDF_SUCCESS) { 794 EXPECT_NE(nullptr, staFeature); 795 printf("SetPowerMode005: ifname is %s\n", staFeature->baseFeature.ifName); 796 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_SLEEPING); 797 EXPECT_NE(HDF_SUCCESS, ret); 798 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_SLEEPING); 799 EXPECT_NE(HDF_SUCCESS, ret); 800 ret = g_wifi->setPowerMode(staFeature->baseFeature.ifName, WIFI_POWER_MODE_SLEEPING); 801 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 802 ASSERT_TRUE(flag); 803 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 804 EXPECT_EQ(HDF_SUCCESS, ret); 805 } 806} 807 808/** 809 * @tc.name: SetPowerMode007 810 * @tc.desc: Wifi hdi set power mode function test 811 * @tc.type: FUNC 812 * @tc.require: AR000H60O7 813 */ 814HWTEST_F(WifiHalTest, SetPowerMode007, TestSize.Level1) 815{ 816 int32_t ret; 817 struct IWiFiSta *staFeature = nullptr; 818 const char *ifName = "eth0"; 819 820 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 821 if (ret == HDF_SUCCESS) { 822 EXPECT_NE(nullptr, staFeature); 823 printf("SetPowerMode005: ifname is %s\n", staFeature->baseFeature.ifName); 824 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_GENERAL); 825 EXPECT_NE(HDF_SUCCESS, ret); 826 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_GENERAL); 827 EXPECT_NE(HDF_SUCCESS, ret); 828 ret = g_wifi->setPowerMode(staFeature->baseFeature.ifName, WIFI_POWER_MODE_GENERAL); 829 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 830 ASSERT_TRUE(flag); 831 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 832 EXPECT_EQ(HDF_SUCCESS, ret); 833 } 834} 835 836/** 837 * @tc.name: SetPowerMode008 838 * @tc.desc: Wifi hdi set power mode function test 839 * @tc.type: FUNC 840 * @tc.require: AR000H60O7 841 */ 842HWTEST_F(WifiHalTest, SetPowerMode008, TestSize.Level1) 843{ 844 int32_t ret; 845 struct IWiFiSta *staFeature = nullptr; 846 const char *ifName = "eth0"; 847 848 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 849 if (ret == HDF_SUCCESS) { 850 EXPECT_NE(nullptr, staFeature); 851 printf("SetPowerMode005: ifname is %s\n", staFeature->baseFeature.ifName); 852 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_THROUGH_WALL); 853 EXPECT_NE(HDF_SUCCESS, ret); 854 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_THROUGH_WALL); 855 EXPECT_NE(HDF_SUCCESS, ret); 856 ret = g_wifi->setPowerMode(staFeature->baseFeature.ifName, WIFI_POWER_MODE_THROUGH_WALL); 857 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 858 ASSERT_TRUE(flag); 859 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 860 EXPECT_EQ(HDF_SUCCESS, ret); 861 } 862} 863 864/** 865 * @tc.name: WifiHalStartScan001 866 * @tc.desc: Wifi hdi Start Scan function test 867 * @tc.type: FUNC 868 * @tc.require: AR000H60O7 869 */ 870HWTEST_F(WifiHalTest, WifiHalStartScan001, TestSize.Level1) 871{ 872 int ret; 873 struct IWiFiSta *staFeature = nullptr; 874 const char *ifName = "wlan0"; 875 const char *ifNameInvalid = "wlanTest"; 876 WifiScan scan = {0}; 877 878 ret = g_wifi->registerEventCallback(HalCallbackEvent, ifName); 879 EXPECT_EQ(HDF_SUCCESS, ret); 880 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 881 if (ret == HDF_SUCCESS) { 882 EXPECT_NE(staFeature, nullptr); 883 ret = staFeature->startScan(nullptr, &scan); 884 EXPECT_NE(HDF_SUCCESS, ret); 885 ret = staFeature->startScan(ifName, nullptr); 886 EXPECT_NE(HDF_SUCCESS, ret); 887 ret = staFeature->startScan(ifNameInvalid, &scan); 888 EXPECT_NE(HDF_SUCCESS, ret); 889 ret = staFeature->startScan(ifName, &scan); 890 EXPECT_EQ(HDF_SUCCESS, ret); 891 sleep(SCAN_TIME); 892 } 893} 894 895/** 896 * @tc.name: WifiHalCreateFeature003 897 * @tc.desc: Wifi hal create feature function test 898 * @tc.type: FUNC 899 * @tc.require: AR000H603L 900 */ 901HWTEST_F(WifiHalTest, WifiHalCreateFeature003, TestSize.Level1) 902{ 903 int32_t ret; 904 struct IWiFiSta *staFeature = nullptr; 905 906 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, nullptr); 907 EXPECT_EQ(ret, HDF_FAILURE); 908 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, nullptr); 909 EXPECT_EQ(ret, HDF_FAILURE); 910 911 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_NUM, (struct IWiFiBaseFeature **)&staFeature); 912 EXPECT_NE(HDF_SUCCESS, ret); 913 ret = g_wifi->createFeature(-1, (struct IWiFiBaseFeature **)&staFeature); 914 EXPECT_NE(HDF_SUCCESS, ret); 915} 916 917/** 918 * @tc.name: WifiHalGetFeatureByIfName002 919 * @tc.desc: Wifi hal get feature by ifname function test 920 * @tc.type: FUNC 921 * @tc.require: AR000H603L 922 */ 923HWTEST_F(WifiHalTest, WifiHalGetFeatureByIfName002, TestSize.Level1) 924{ 925 int32_t ret; 926 struct IWiFiSta *staFeature = nullptr; 927 struct IWiFiSta *staFeatureGet = nullptr; 928 const char *ifName0 = "wlanTest"; 929 930 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 931 if (ret == HDF_SUCCESS) { 932 EXPECT_NE(nullptr, staFeature); 933 ret = g_wifi->getFeatureByIfName(nullptr, (struct IWiFiBaseFeature **)&staFeature); 934 EXPECT_NE(HDF_SUCCESS, ret); 935 ret = g_wifi->getFeatureByIfName(ifName0, (struct IWiFiBaseFeature **)&staFeature); 936 EXPECT_NE(HDF_SUCCESS, ret); 937 ret = g_wifi->getFeatureByIfName(staFeature->baseFeature.ifName, (struct IWiFiBaseFeature **)&staFeatureGet); 938 EXPECT_EQ(HDF_SUCCESS, ret); 939 EXPECT_NE(nullptr, staFeatureGet); 940 941 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 942 EXPECT_EQ(HDF_SUCCESS, ret); 943 } 944} 945 946/** 947 * @tc.name: WifiHalRegisterEventCallback002 948 * @tc.desc: Wifi hal register event callback test 949 * @tc.type: FUNC 950 * @tc.require: AR000H603L 951 */ 952HWTEST_F(WifiHalTest, WifiHalRegisterEventCallback002, TestSize.Level1) 953{ 954 int32_t ret; 955 956 ret = g_wifi->registerEventCallback(nullptr, "wlan0"); 957 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 958 ret = g_wifi->registerEventCallback(HalCallbackEvent, nullptr); 959 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 960} 961 962/** 963 * @tc.name: WifiHalUnRegisterEventCallback002 964 * @tc.desc: Wifi hal unregister event callback test 965 * @tc.type: FUNC 966 * @tc.require: AR000H603L 967 */ 968HWTEST_F(WifiHalTest, WifiHalUnRegisterEventCallback002, TestSize.Level1) 969{ 970 int32_t ret; 971 972 ret = g_wifi->unregisterEventCallback(nullptr, "wlan0"); 973 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 974 ret = g_wifi->unregisterEventCallback(HalCallbackEvent, nullptr); 975 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 976} 977 978/** 979 * @tc.name: GetSupportFeature001 980 * @tc.desc: Wifi hal get supported feature test 981 * @tc.type: FUNC 982 * @tc.require: AR000H603L 983 */ 984HWTEST_F(WifiHalTest, GetSupportFeature001, TestSize.Level1) 985{ 986 int32_t ret; 987 uint8_t supType[PROTOCOL_80211_IFTYPE_NUM + 1] = {0}; 988 989 ret = g_wifi->getSupportFeature(nullptr, PROTOCOL_80211_IFTYPE_NUM + 1); 990 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 991 ret = g_wifi->getSupportFeature(supType, PROTOCOL_80211_IFTYPE_NUM); 992 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 993 994 ret = g_wifi->getSupportFeature(supType, PROTOCOL_80211_IFTYPE_NUM + 1); 995 EXPECT_EQ(RET_CODE_SUCCESS, ret); 996} 997 998/** 999 * @tc.name: WifiHalGetNetworkIfaceName002 1000 * @tc.desc: Wifi hal get network iface name function test 1001 * @tc.type: FUNC 1002 * @tc.require: AR000H603L 1003 */ 1004HWTEST_F(WifiHalTest, WifiHalGetNetworkIfaceName002, TestSize.Level1) 1005{ 1006 int32_t ret; 1007 struct IWiFiSta *staFeature = nullptr; 1008 1009 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1010 if (ret == HDF_SUCCESS) { 1011 EXPECT_NE(nullptr, staFeature); 1012 const char *ifnameTest = staFeature->baseFeature.getNetworkIfaceName(nullptr); 1013 EXPECT_EQ(nullptr, ifnameTest); 1014 const char *ifName = staFeature->baseFeature.getNetworkIfaceName((const struct IWiFiBaseFeature *)staFeature); 1015 EXPECT_NE(nullptr, ifName); 1016 if (strncmp(ifName, "wlan", 4) == 0 || strncmp(ifName, "nan", 3) == 0 || strncmp(ifName, "p2p", 3) == 0) { 1017 ret = 0; 1018 } else { 1019 ret = -1; 1020 } 1021 EXPECT_EQ(0, ret); 1022 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1023 EXPECT_EQ(HDF_SUCCESS, ret); 1024 } 1025} 1026 1027/** 1028 * @tc.name: WifiHalGetGetFeatureType002 1029 * @tc.desc: Wifi hal get feature type function test 1030 * @tc.type: FUNC 1031 * @tc.require: AR000H603L 1032 */ 1033HWTEST_F(WifiHalTest, WifiHalGetGetFeatureType002, TestSize.Level1) 1034{ 1035 int32_t ret; 1036 struct IWiFiSta *staFeature = nullptr; 1037 int32_t type; 1038 1039 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1040 if (ret == HDF_SUCCESS) { 1041 EXPECT_NE(nullptr, staFeature); 1042 type = staFeature->baseFeature.getFeatureType(nullptr); 1043 EXPECT_EQ(HDF_FAILURE, type); 1044 type = staFeature->baseFeature.getFeatureType((struct IWiFiBaseFeature *)staFeature); 1045 EXPECT_EQ(PROTOCOL_80211_IFTYPE_STATION, type); 1046 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1047 EXPECT_EQ(HDF_SUCCESS, ret); 1048 } 1049} 1050 1051/** 1052 * @tc.name: GetDeviceMacAddress001 1053 * @tc.desc: Wifi hal get device's MAC address test 1054 * @tc.type: FUNC 1055 * @tc.require: AR000H603L 1056 */ 1057HWTEST_F(WifiHalTest, GetDeviceMacAddress001, TestSize.Level1) 1058{ 1059 int32_t ret; 1060 struct IWiFiAp *apFeature = nullptr; 1061 1062 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1063 if (ret == HDF_SUCCESS) { 1064 EXPECT_NE(nullptr, apFeature); 1065 unsigned char readMac[ETH_ADDR_LEN] = {0}; 1066 ret = apFeature->baseFeature.getDeviceMacAddress(nullptr, readMac, ETH_ADDR_LEN); 1067 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 1068 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, nullptr, 0); 1069 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 1070 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, readMac, 0); 1071 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 1072 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, readMac, ETH_ADDR_LEN); 1073 EXPECT_EQ(HDF_SUCCESS, ret); 1074 1075 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1076 EXPECT_EQ(HDF_SUCCESS, ret); 1077 } 1078} 1079 1080/** 1081 * @tc.name: GetDeviceMacAddress002 1082 * @tc.desc: Wifi hal get device's MAC address test 1083 * @tc.type: FUNC 1084 * @tc.require: AR000H603L 1085 */ 1086HWTEST_F(WifiHalTest, GetDeviceMacAddress002, TestSize.Level1) 1087{ 1088 int32_t ret; 1089 struct IWiFiSta *staFeature = nullptr; 1090 1091 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1092 if (ret == HDF_SUCCESS) { 1093 EXPECT_NE(nullptr, staFeature); 1094 unsigned char readMac[ETH_ADDR_LEN] = {0}; 1095 ret = staFeature->baseFeature.getDeviceMacAddress(nullptr, readMac, ETH_ADDR_LEN); 1096 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 1097 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, nullptr, 0); 1098 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 1099 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, readMac, 0); 1100 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 1101 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, readMac, ETH_ADDR_LEN); 1102 EXPECT_EQ(HDF_SUCCESS, ret); 1103 1104 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1105 EXPECT_EQ(HDF_SUCCESS, ret); 1106 } 1107} 1108 1109/** 1110 * @tc.name: GetValidFreqsWithBand001 1111 * @tc.desc: Wifi hal get valid frequency with specific band test 1112 * @tc.type: FUNC 1113 * @tc.require: AR000H603L 1114 */ 1115HWTEST_F(WifiHalTest, GetValidFreqsWithBand001, TestSize.Level1) 1116{ 1117 int32_t ret; 1118 struct IWiFiSta *staFeature = nullptr; 1119 int32_t band = IEEE80211_BAND_2GHZ; 1120 int32_t bandNotSupport = IEEE80211_NUM_BANDS; 1121 int32_t freqs[MAX_CHANNEL_NUM] = {0}; 1122 uint32_t size = MAX_CHANNEL_NUM; 1123 uint32_t num = 0; 1124 1125 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1126 if (ret == HDF_SUCCESS) { 1127 EXPECT_NE(nullptr, staFeature); 1128 ret = staFeature->baseFeature.getValidFreqsWithBand(nullptr, band, freqs, size, &num); 1129 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 1130 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature, 1131 band, nullptr, size, &num); 1132 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 1133 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature, 1134 band, freqs, 10, &num); 1135 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 1136 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature, 1137 band, freqs, size, nullptr); 1138 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 1139 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature, 1140 bandNotSupport, freqs, size, &num); 1141 EXPECT_NE(HDF_SUCCESS, ret); 1142 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature, 1143 band, freqs, size, &num); 1144 EXPECT_EQ(HDF_SUCCESS, ret); 1145 1146 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1147 EXPECT_EQ(HDF_SUCCESS, ret); 1148 } 1149} 1150 1151/** 1152 * @tc.name: GetValidFreqsWithBand002 1153 * @tc.desc: Wifi hal get valid frequency with specific band test 1154 * @tc.type: FUNC 1155 * @tc.require: AR000H603L 1156 */ 1157HWTEST_F(WifiHalTest, GetValidFreqsWithBand002, TestSize.Level1) 1158{ 1159 int32_t ret; 1160 struct IWiFiAp *apFeature = nullptr; 1161 int32_t band = IEEE80211_BAND_2GHZ; 1162 int32_t bandNotSupport = IEEE80211_NUM_BANDS; 1163 int32_t freqs[MAX_CHANNEL_NUM] = {0}; 1164 uint32_t size = MAX_CHANNEL_NUM; 1165 uint32_t num = 0; 1166 1167 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1168 if (ret == HDF_SUCCESS) { 1169 EXPECT_NE(nullptr, apFeature); 1170 ret = apFeature->baseFeature.getValidFreqsWithBand(nullptr, band, freqs, size, &num); 1171 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 1172 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature, 1173 band, nullptr, size, &num); 1174 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 1175 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature, band, freqs, 10, &num); 1176 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 1177 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature, 1178 band, freqs, size, nullptr); 1179 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 1180 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature, 1181 bandNotSupport, freqs, size, &num); 1182 EXPECT_NE(HDF_SUCCESS, ret); 1183 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature, 1184 band, freqs, size, &num); 1185 EXPECT_EQ(HDF_SUCCESS, ret); 1186 1187 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1188 EXPECT_EQ(HDF_SUCCESS, ret); 1189 } 1190} 1191 1192/** 1193 * @tc.name: WifiHalSetTxPower002 1194 * @tc.desc: Wifi hal set transmit power function test 1195 * @tc.type: FUNC 1196 * @tc.require: AR000H603L 1197 */ 1198HWTEST_F(WifiHalTest, WifiHalSetTxPower002, TestSize.Level1) 1199{ 1200 int32_t ret; 1201 struct IWiFiSta *staFeature = nullptr; 1202 1203 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1204 if (ret == HDF_SUCCESS) { 1205 EXPECT_NE(nullptr, staFeature); 1206 ret = staFeature->baseFeature.setTxPower(nullptr, WLAN_TX_POWER); 1207 EXPECT_NE(HDF_SUCCESS, ret); 1208 ret = staFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)staFeature, -1); 1209 EXPECT_NE(HDF_SUCCESS, ret); 1210 ret = staFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)staFeature, WLAN_TX_POWER); 1211 EXPECT_EQ(HDF_SUCCESS, ret); 1212 1213 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1214 EXPECT_EQ(HDF_SUCCESS, ret); 1215 } 1216} 1217 1218/** 1219 * @tc.name: WifiHalGetIfNamesByChipId002 1220 * @tc.desc: Obtain all ifNames and the number of the current chip 1221 * @tc.type: FUNC 1222 * @tc.require: AR000H603L 1223 */ 1224HWTEST_F(WifiHalTest, WifiHalGetIfNamesByChipId002, TestSize.Level1) 1225{ 1226 int32_t ret; 1227 struct IWiFiAp *apFeature = nullptr; 1228 char *ifNames = nullptr; 1229 unsigned int num = 0; 1230 unsigned char chipId = 0; 1231 uint8_t i; 1232 1233 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1234 if (ret == HDF_SUCCESS) { 1235 EXPECT_NE(nullptr, apFeature); 1236 ret = apFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)apFeature, &chipId); 1237 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE); 1238 EXPECT_EQ(HDF_SUCCESS, ret); 1239 1240 ret = apFeature->baseFeature.getIfNamesByChipId(chipId, nullptr, nullptr); 1241 EXPECT_NE(HDF_SUCCESS, ret); 1242 ret = apFeature->baseFeature.getIfNamesByChipId(100, &ifNames, &num); 1243 EXPECT_NE(HDF_SUCCESS, ret); 1244 ret = apFeature->baseFeature.getIfNamesByChipId(chipId, &ifNames, &num); 1245 EXPECT_NE(nullptr, ifNames); 1246 EXPECT_EQ(HDF_SUCCESS, ret); 1247 bool flag = (num <= IFNAME_MAX_NUM && num >= IFNAME_MIN_NUM); 1248 ASSERT_TRUE(flag); 1249 for (i = 0; i < num; i++) { 1250 EXPECT_EQ(0, strncmp("wlan", ifNames + i * MAX_IF_NAME_LENGTH, SIZE)); 1251 } 1252 free(ifNames); 1253 1254 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1255 EXPECT_EQ(HDF_SUCCESS, ret); 1256 } 1257} 1258 1259/** 1260 * @tc.name: HalGetChipId001 1261 * @tc.desc: wifi hal get chip ID function test 1262 * @tc.type: FUNC 1263 * @tc.require: AR000H603L 1264 */ 1265HWTEST_F(WifiHalTest, HalGetChipId001, TestSize.Level1) 1266{ 1267 int32_t ret; 1268 struct IWiFiSta *staFeature = nullptr; 1269 unsigned char chipId = 0; 1270 1271 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1272 if (ret == HDF_SUCCESS) { 1273 EXPECT_NE(nullptr, staFeature); 1274 ret = staFeature->baseFeature.getChipId(nullptr, &chipId); 1275 EXPECT_NE(HDF_SUCCESS, ret); 1276 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, nullptr); 1277 EXPECT_NE(HDF_SUCCESS, ret); 1278 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId); 1279 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE); 1280 EXPECT_EQ(HDF_SUCCESS, ret); 1281 1282 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1283 EXPECT_EQ(HDF_SUCCESS, ret); 1284 } 1285} 1286 1287/** 1288 * @tc.name: HalGetChipId002 1289 * @tc.desc: wifi hal get chip ID function test 1290 * @tc.type: FUNC 1291 * @tc.require: AR000H603L 1292 */ 1293HWTEST_F(WifiHalTest, HalGetChipId002, TestSize.Level1) 1294{ 1295 int32_t ret; 1296 struct IWiFiAp *apFeature = nullptr; 1297 unsigned char chipId = 0; 1298 1299 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1300 if (ret == HDF_SUCCESS) { 1301 EXPECT_NE(nullptr, apFeature); 1302 ret = apFeature->baseFeature.getChipId(nullptr, &chipId); 1303 EXPECT_NE(HDF_SUCCESS, ret); 1304 ret = apFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)apFeature, nullptr); 1305 EXPECT_NE(HDF_SUCCESS, ret); 1306 ret = apFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)apFeature, &chipId); 1307 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE); 1308 EXPECT_EQ(HDF_SUCCESS, ret); 1309 1310 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1311 EXPECT_EQ(HDF_SUCCESS, ret); 1312 } 1313} 1314 1315/** 1316 * @tc.name: GetAssociatedStas001 1317 * @tc.desc: wifi hal get association state function test 1318 * @tc.type: FUNC 1319 * @tc.require: AR000H603L 1320 */ 1321HWTEST_F(WifiHalTest, GetAssociatedStas001, TestSize.Level1) 1322{ 1323 int32_t ret; 1324 struct IWiFiAp *apFeature = nullptr; 1325 struct StaInfo staInfo[MAX_ASSOC_STA_NUM]; 1326 (void)memset_s(staInfo, sizeof(StaInfo) * MAX_ASSOC_STA_NUM, 0, sizeof(StaInfo) * MAX_ASSOC_STA_NUM); 1327 uint32_t num = 0; 1328 1329 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1330 if (ret == HDF_SUCCESS) { 1331 EXPECT_NE(nullptr, apFeature); 1332 ret = apFeature->getAssociatedStas(nullptr, staInfo, MAX_ASSOC_STA_NUM, &num); 1333 EXPECT_NE(HDF_SUCCESS, ret); 1334 ret = apFeature->getAssociatedStas(apFeature, nullptr, MAX_ASSOC_STA_NUM, &num); 1335 EXPECT_NE(HDF_SUCCESS, ret); 1336 ret = apFeature->getAssociatedStas(apFeature, staInfo, 0, &num); 1337 EXPECT_NE(HDF_SUCCESS, ret); 1338 ret = apFeature->getAssociatedStas(apFeature, staInfo, MAX_ASSOC_STA_NUM, nullptr); 1339 EXPECT_NE(HDF_SUCCESS, ret); 1340 ret = apFeature->getAssociatedStas(apFeature, staInfo, MAX_ASSOC_STA_NUM, &num); 1341 EXPECT_EQ(HDF_SUCCESS, ret); 1342 1343 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1344 EXPECT_EQ(HDF_SUCCESS, ret); 1345 } 1346} 1347 1348/** 1349 * @tc.name: SetScanningMacAddress001 1350 * @tc.desc: wifi hal set scanning MAC address function test 1351 * @tc.type: FUNC 1352 * @tc.require: AR000H603L 1353 */ 1354HWTEST_F(WifiHalTest, SetScanningMacAddress001, TestSize.Level1) 1355{ 1356 int32_t ret; 1357 struct IWiFiSta *staFeature = nullptr; 1358 unsigned char scanMac[WIFI_MAC_ADDR_LENGTH] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd}; 1359 1360 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1361 if (ret == HDF_SUCCESS) { 1362 EXPECT_NE(nullptr, staFeature); 1363 ret = staFeature->setScanningMacAddress(nullptr, scanMac, WIFI_MAC_ADDR_LENGTH); 1364 EXPECT_NE(HDF_SUCCESS, ret); 1365 ret = staFeature->setScanningMacAddress(staFeature, nullptr, WIFI_MAC_ADDR_LENGTH); 1366 EXPECT_NE(HDF_SUCCESS, ret); 1367 ret = staFeature->setScanningMacAddress(staFeature, scanMac, 0); 1368 EXPECT_NE(HDF_SUCCESS, ret); 1369 ret = staFeature->setScanningMacAddress(staFeature, scanMac, WIFI_MAC_ADDR_LENGTH); 1370 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 1371 ASSERT_TRUE(flag); 1372 1373 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1374 EXPECT_EQ(HDF_SUCCESS, ret); 1375 } 1376} 1377 1378/** 1379 * @tc.name: SetProjectionScreenParam001 1380 * @tc.desc: wifi hal config projection screen function test 1381 * @tc.type: FUNC 1382 * @tc.require: AR000HDUEE 1383 */ 1384HWTEST_F(WifiHalTest, SetProjectionScreenParam001, TestSize.Level1) 1385{ 1386 int32_t ret; 1387 bool flag; 1388 struct IWiFiAp *apFeature = nullptr; 1389 ProjectionScreenParam *param; 1390 1391 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 1392 EXPECT_NE(nullptr, param); 1393 param->cmdId = TEST_CMD; 1394 param->bufLen = 1; 1395 param->buf[0] = 0; 1396 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1397 if (ret == HDF_SUCCESS) { 1398 ret = g_wifi->setProjectionScreenParam(nullptr, nullptr); 1399 EXPECT_NE(ret, HDF_SUCCESS); 1400 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, nullptr); 1401 EXPECT_NE(ret, HDF_SUCCESS); 1402 ret = g_wifi->setProjectionScreenParam(nullptr, param); 1403 EXPECT_NE(ret, HDF_SUCCESS); 1404 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, param); 1405 EXPECT_NE(ret, HDF_SUCCESS); 1406 1407 param->cmdId = CMD_CLOSE_GO_CAC; 1408 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, param); 1409 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret); 1410 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 1411 ASSERT_TRUE(flag); 1412 1413 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1414 EXPECT_EQ(ret, HDF_SUCCESS); 1415 } 1416 OsalMemFree(param); 1417} 1418 1419/** 1420 * @tc.name: SetProjectionScreenParam002 1421 * @tc.desc: wifi hal config projection screen function test 1422 * @tc.type: FUNC 1423 * @tc.require: 1424 */ 1425HWTEST_F(WifiHalTest, SetProjectionScreenParam002, TestSize.Level1) 1426{ 1427 int32_t ret; 1428 bool flag; 1429 struct IWiFiAp *apFeature = nullptr; 1430 ProjectionScreenParam *param; 1431 1432 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 1433 EXPECT_NE(nullptr, param); 1434 param->bufLen = 1; 1435 param->buf[0] = 0; 1436 param->cmdId = CMD_SET_GO_CSA_CHANNEL; 1437 1438 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1439 if (ret == HDF_SUCCESS) { 1440 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, param); 1441 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret); 1442 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN); 1443 ASSERT_TRUE(flag); 1444 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1445 EXPECT_EQ(ret, HDF_SUCCESS); 1446 } 1447 OsalMemFree(param); 1448} 1449 1450/** 1451 * @tc.name: SetProjectionScreenParam003 1452 * @tc.desc: wifi hal config projection screen function test 1453 * @tc.type: FUNC 1454 * @tc.require: 1455 */ 1456HWTEST_F(WifiHalTest, SetProjectionScreenParam003, TestSize.Level1) 1457{ 1458 int32_t ret; 1459 bool flag; 1460 struct IWiFiAp *apFeature = nullptr; 1461 ProjectionScreenParam *param; 1462 1463 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 1464 EXPECT_NE(nullptr, param); 1465 param->bufLen = 1; 1466 param->buf[0] = 0; 1467 param->cmdId = CMD_SET_GO_RADAR_DETECT; 1468 1469 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1470 if (ret == HDF_SUCCESS) { 1471 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, param); 1472 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret); 1473 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN); 1474 ASSERT_TRUE(flag); 1475 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1476 EXPECT_EQ(ret, HDF_SUCCESS); 1477 } 1478 OsalMemFree(param); 1479} 1480 1481/** 1482 * @tc.name: SetProjectionScreenParam004 1483 * @tc.desc: wifi hal config projection screen function test 1484 * @tc.type: FUNC 1485 * @tc.require: 1486 */ 1487HWTEST_F(WifiHalTest, SetProjectionScreenParam004, TestSize.Level1) 1488{ 1489 int32_t ret; 1490 bool flag; 1491 struct IWiFiAp *apFeature = nullptr; 1492 ProjectionScreenParam *param; 1493 1494 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 1495 EXPECT_NE(nullptr, param); 1496 param->bufLen = 1; 1497 param->buf[0] = 0; 1498 param->cmdId = CMD_ID_MCC_STA_P2P_QUOTA_TIME; 1499 1500 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1501 if (ret == HDF_SUCCESS) { 1502 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, param); 1503 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret); 1504 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN); 1505 ASSERT_TRUE(flag); 1506 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1507 EXPECT_EQ(ret, HDF_SUCCESS); 1508 } 1509 OsalMemFree(param); 1510} 1511 1512/** 1513 * @tc.name: SetProjectionScreenParam005 1514 * @tc.desc: wifi hal config projection screen function test 1515 * @tc.type: FUNC 1516 * @tc.require: 1517 */ 1518HWTEST_F(WifiHalTest, SetProjectionScreenParam005, TestSize.Level1) 1519{ 1520 int32_t ret; 1521 bool flag; 1522 struct IWiFiAp *apFeature = nullptr; 1523 ProjectionScreenParam *param; 1524 1525 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 1526 EXPECT_NE(nullptr, param); 1527 param->bufLen = 1; 1528 param->buf[0] = 0; 1529 param->cmdId = CMD_ID_CTRL_ROAM_CHANNEL; 1530 1531 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1532 if (ret == HDF_SUCCESS) { 1533 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, param); 1534 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret); 1535 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN); 1536 ASSERT_TRUE(flag); 1537 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1538 EXPECT_EQ(ret, HDF_SUCCESS); 1539 } 1540 OsalMemFree(param); 1541} 1542 1543/** 1544 * @tc.name: SetProjectionScreenParam006 1545 * @tc.desc: wifi hal config projection screen function test 1546 * @tc.type: FUNC 1547 * @tc.require: 1548 */ 1549HWTEST_F(WifiHalTest, SetProjectionScreenParam006, TestSize.Level1) 1550{ 1551 int32_t ret; 1552 bool flag; 1553 struct IWiFiSta *staFeature = nullptr; 1554 ProjectionScreenParam *param; 1555 1556 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 1557 EXPECT_NE(nullptr, param); 1558 param->cmdId = TEST_CMD; 1559 param->bufLen = 1; 1560 param->buf[0] = 0; 1561 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1562 if (ret == HDF_SUCCESS) { 1563 ret = g_wifi->setProjectionScreenParam(nullptr, nullptr); 1564 EXPECT_NE(ret, HDF_SUCCESS); 1565 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, nullptr); 1566 EXPECT_NE(ret, HDF_SUCCESS); 1567 ret = g_wifi->setProjectionScreenParam(nullptr, param); 1568 EXPECT_NE(ret, HDF_SUCCESS); 1569 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, param); 1570 EXPECT_NE(ret, HDF_SUCCESS); 1571 1572 param->cmdId = CMD_CLOSE_GO_CAC; 1573 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, param); 1574 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret); 1575 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 1576 ASSERT_TRUE(flag); 1577 1578 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1579 EXPECT_EQ(ret, HDF_SUCCESS); 1580 } 1581 OsalMemFree(param); 1582} 1583 1584/** 1585 * @tc.name: SetProjectionScreenParam007 1586 * @tc.desc: wifi hal config projection screen function test 1587 * @tc.type: FUNC 1588 * @tc.require: 1589 */ 1590HWTEST_F(WifiHalTest, SetProjectionScreenParam007, TestSize.Level1) 1591{ 1592 int32_t ret; 1593 bool flag; 1594 struct IWiFiSta *staFeature = nullptr; 1595 ProjectionScreenParam *param; 1596 1597 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 1598 EXPECT_NE(nullptr, param); 1599 param->bufLen = 1; 1600 param->buf[0] = 0; 1601 param->cmdId = CMD_SET_GO_CSA_CHANNEL; 1602 1603 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1604 if (ret == HDF_SUCCESS) { 1605 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, param); 1606 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret); 1607 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN); 1608 ASSERT_TRUE(flag); 1609 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1610 EXPECT_EQ(ret, HDF_SUCCESS); 1611 } 1612 OsalMemFree(param); 1613} 1614 1615/** 1616 * @tc.name: SetProjectionScreenParam008 1617 * @tc.desc: wifi hal config projection screen function test 1618 * @tc.type: FUNC 1619 * @tc.require: 1620 */ 1621HWTEST_F(WifiHalTest, SetProjectionScreenParam008, TestSize.Level1) 1622{ 1623 int32_t ret; 1624 bool flag; 1625 struct IWiFiSta *staFeature = nullptr; 1626 ProjectionScreenParam *param; 1627 1628 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 1629 EXPECT_NE(nullptr, param); 1630 param->bufLen = 1; 1631 param->buf[0] = 0; 1632 param->cmdId = CMD_SET_GO_RADAR_DETECT; 1633 1634 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1635 if (ret == HDF_SUCCESS) { 1636 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, param); 1637 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret); 1638 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN); 1639 ASSERT_TRUE(flag); 1640 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1641 EXPECT_EQ(ret, HDF_SUCCESS); 1642 } 1643 OsalMemFree(param); 1644} 1645 1646/** 1647 * @tc.name: SetProjectionScreenParam009 1648 * @tc.desc: wifi hal config projection screen function test 1649 * @tc.type: FUNC 1650 * @tc.require: 1651 */ 1652HWTEST_F(WifiHalTest, SetProjectionScreenParam009, TestSize.Level1) 1653{ 1654 int32_t ret; 1655 bool flag; 1656 struct IWiFiSta *staFeature = nullptr; 1657 ProjectionScreenParam *param; 1658 1659 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 1660 EXPECT_NE(nullptr, param); 1661 param->bufLen = 1; 1662 param->buf[0] = 0; 1663 param->cmdId = CMD_ID_MCC_STA_P2P_QUOTA_TIME; 1664 1665 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1666 if (ret == HDF_SUCCESS) { 1667 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, param); 1668 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret); 1669 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN); 1670 ASSERT_TRUE(flag); 1671 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1672 EXPECT_EQ(ret, HDF_SUCCESS); 1673 } 1674 OsalMemFree(param); 1675} 1676 1677/** 1678 * @tc.name: SetProjectionScreenParam010 1679 * @tc.desc: wifi hal config projection screen function test 1680 * @tc.type: FUNC 1681 * @tc.require: 1682 */ 1683HWTEST_F(WifiHalTest, SetProjectionScreenParam010, TestSize.Level1) 1684{ 1685 int32_t ret; 1686 bool flag; 1687 struct IWiFiSta *staFeature = nullptr; 1688 ProjectionScreenParam *param; 1689 1690 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 1691 EXPECT_NE(nullptr, param); 1692 param->bufLen = 1; 1693 param->buf[0] = 0; 1694 param->cmdId = CMD_ID_CTRL_ROAM_CHANNEL; 1695 1696 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1697 if (ret == HDF_SUCCESS) { 1698 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, param); 1699 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret); 1700 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN); 1701 ASSERT_TRUE(flag); 1702 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1703 EXPECT_EQ(ret, HDF_SUCCESS); 1704 } 1705 OsalMemFree(param); 1706} 1707 1708/** 1709 * @tc.name: SendCmdIoctl001 1710 * @tc.desc: wifi hal send ioctl command function test 1711 * @tc.type: FUNC 1712 * @tc.require: AR000HDUEE 1713 */ 1714HWTEST_F(WifiHalTest, SendCmdIoctl001, TestSize.Level1) 1715{ 1716 int32_t cmdId = 0; 1717 int32_t ret; 1718 bool flag; 1719 struct IWiFiAp *apFeature = nullptr; 1720 int8_t data[TEST_BUF_SIZE] = {0}; 1721 const char *ifName = "wlan0"; 1722 1723 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1724 if (ret == HDF_SUCCESS) { 1725 ret = g_wifi->sendCmdIoctl(nullptr, cmdId, nullptr, TEST_BUF_SIZE); 1726 EXPECT_NE(ret, HDF_SUCCESS); 1727 ret = g_wifi->sendCmdIoctl(ifName, cmdId, nullptr, TEST_BUF_SIZE); 1728 EXPECT_NE(ret, HDF_SUCCESS); 1729 ret = g_wifi->sendCmdIoctl(nullptr, cmdId, data, TEST_BUF_SIZE); 1730 EXPECT_NE(ret, HDF_SUCCESS); 1731 cmdId = CMD_HID2D_MODULE_INIT; 1732 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE); 1733 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret); 1734 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 1735 ASSERT_TRUE(flag); 1736 1737 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1738 EXPECT_EQ(ret, HDF_SUCCESS); 1739 } 1740} 1741 1742/** 1743 * @tc.name: SendCmdIoctl002 1744 * @tc.desc: wifi hal send ioctl command function test 1745 * @tc.type: FUNC 1746 * @tc.require: AR000HDUEE 1747 */ 1748HWTEST_F(WifiHalTest, SendCmdIoctl002, TestSize.Level1) 1749{ 1750 int32_t cmdId = 0; 1751 int32_t ret; 1752 bool flag; 1753 struct IWiFiAp *apFeature = nullptr; 1754 int8_t data[TEST_BUF_SIZE] = {0}; 1755 const char *ifName = "wlan0"; 1756 1757 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1758 if (ret == HDF_SUCCESS) { 1759 cmdId = CMD_SET_BATTERY_LEVEL; 1760 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE); 1761 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret); 1762 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 1763 ASSERT_TRUE(flag); 1764 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1765 EXPECT_EQ(ret, HDF_SUCCESS); 1766 } 1767} 1768 1769/** 1770 * @tc.name: SendCmdIoctl003 1771 * @tc.desc: wifi hal send ioctl command function test 1772 * @tc.type: FUNC 1773 * @tc.require: 1774 */ 1775HWTEST_F(WifiHalTest, SendCmdIoctl003, TestSize.Level1) 1776{ 1777 int32_t cmdId = 0; 1778 int32_t ret; 1779 bool flag; 1780 struct IWiFiAp *apFeature = nullptr; 1781 int8_t data[TEST_BUF_SIZE] = {0}; 1782 const char *ifName = "wlan0"; 1783 1784 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1785 if (ret == HDF_SUCCESS) { 1786 cmdId = CMD_SET_SUPP_COEX_CHAN_LIST; 1787 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE); 1788 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret); 1789 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN); 1790 ASSERT_TRUE(flag); 1791 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1792 EXPECT_EQ(ret, HDF_SUCCESS); 1793 } 1794} 1795 1796/** 1797 * @tc.name: SendCmdIoctl004 1798 * @tc.desc: wifi hal send ioctl command function test 1799 * @tc.type: FUNC 1800 * @tc.require: 1801 */ 1802HWTEST_F(WifiHalTest, SendCmdIoctl004, TestSize.Level1) 1803{ 1804 int32_t cmdId = 0; 1805 int32_t ret; 1806 bool flag; 1807 struct IWiFiAp *apFeature = nullptr; 1808 int8_t data[TEST_BUF_SIZE] = {0}; 1809 const char *ifName = "wlan0"; 1810 1811 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1812 if (ret == HDF_SUCCESS) { 1813 cmdId = CMD_SET_CHAN_ADJUST; 1814 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE); 1815 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret); 1816 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN); 1817 ASSERT_TRUE(flag); 1818 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1819 EXPECT_EQ(ret, HDF_SUCCESS); 1820 } 1821} 1822 1823/** 1824 * @tc.name: SendCmdIoctl005 1825 * @tc.desc: wifi hal send ioctl command function test 1826 * @tc.type: FUNC 1827 * @tc.require: 1828 */ 1829HWTEST_F(WifiHalTest, SendCmdIoctl005, TestSize.Level1) 1830{ 1831 int32_t cmdId = 0; 1832 int32_t ret; 1833 bool flag; 1834 struct IWiFiSta *staFeature = nullptr; 1835 int8_t data[TEST_BUF_SIZE] = {0}; 1836 const char *ifName = "wlan0"; 1837 1838 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1839 if (ret == HDF_SUCCESS) { 1840 ret = g_wifi->sendCmdIoctl(nullptr, cmdId, nullptr, TEST_BUF_SIZE); 1841 EXPECT_NE(ret, HDF_SUCCESS); 1842 ret = g_wifi->sendCmdIoctl(ifName, cmdId, nullptr, TEST_BUF_SIZE); 1843 EXPECT_NE(ret, HDF_SUCCESS); 1844 ret = g_wifi->sendCmdIoctl(nullptr, cmdId, data, TEST_BUF_SIZE); 1845 EXPECT_NE(ret, HDF_SUCCESS); 1846 1847 cmdId = CMD_HID2D_MODULE_INIT; 1848 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE); 1849 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret); 1850 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 1851 ASSERT_TRUE(flag); 1852 1853 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1854 EXPECT_EQ(ret, HDF_SUCCESS); 1855 } 1856} 1857 1858/** 1859 * @tc.name: SendCmdIoctl006 1860 * @tc.desc: wifi hal send ioctl command function test 1861 * @tc.type: FUNC 1862 * @tc.require: 1863 */ 1864HWTEST_F(WifiHalTest, SendCmdIoctl006, TestSize.Level1) 1865{ 1866 int32_t cmdId = 0; 1867 int32_t ret; 1868 bool flag; 1869 struct IWiFiSta *staFeature = nullptr; 1870 int8_t data[TEST_BUF_SIZE] = {0}; 1871 const char *ifName = "wlan0"; 1872 1873 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1874 if (ret == HDF_SUCCESS) { 1875 cmdId = CMD_SET_BATTERY_LEVEL; 1876 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE); 1877 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret); 1878 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 1879 ASSERT_TRUE(flag); 1880 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1881 EXPECT_EQ(ret, HDF_SUCCESS); 1882 } 1883} 1884 1885/** 1886 * @tc.name: SendCmdIoctl007 1887 * @tc.desc: wifi hal send ioctl command function test 1888 * @tc.type: FUNC 1889 * @tc.require: 1890 */ 1891HWTEST_F(WifiHalTest, SendCmdIoctl007, TestSize.Level1) 1892{ 1893 int32_t cmdId = 0; 1894 int32_t ret; 1895 bool flag; 1896 struct IWiFiSta *staFeature = nullptr; 1897 int8_t data[TEST_BUF_SIZE] = {0}; 1898 const char *ifName = "wlan0"; 1899 1900 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1901 if (ret == HDF_SUCCESS) { 1902 cmdId = CMD_SET_SUPP_COEX_CHAN_LIST; 1903 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE); 1904 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret); 1905 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN); 1906 ASSERT_TRUE(flag); 1907 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1908 EXPECT_EQ(ret, HDF_SUCCESS); 1909 } 1910} 1911 1912/** 1913 * @tc.name: SendCmdIoctl008 1914 * @tc.desc: wifi hal send ioctl command function test 1915 * @tc.type: FUNC 1916 * @tc.require: 1917 */ 1918HWTEST_F(WifiHalTest, SendCmdIoctl008, TestSize.Level1) 1919{ 1920 int32_t cmdId = 0; 1921 int32_t ret; 1922 bool flag; 1923 struct IWiFiSta *staFeature = nullptr; 1924 int8_t data[TEST_BUF_SIZE] = {0}; 1925 const char *ifName = "wlan0"; 1926 1927 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1928 if (ret == HDF_SUCCESS) { 1929 cmdId = CMD_SET_CHAN_ADJUST; 1930 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE); 1931 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret); 1932 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN); 1933 ASSERT_TRUE(flag); 1934 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1935 EXPECT_EQ(ret, HDF_SUCCESS); 1936 } 1937} 1938 1939/** 1940 * @tc.name: GetStationInfo001 1941 * @tc.desc: Wifi hdi get station information function test 1942 * @tc.type: FUNC 1943 * @tc.require: 1944 */ 1945HWTEST_F(WifiHalTest, GetStationInfo001, TestSize.Level1) 1946{ 1947 int32_t ret; 1948 StationInfo info; 1949 bool flag; 1950 uint8_t mac[ETH_ADDR_LEN] = {0}; 1951 struct IWiFiAp *apFeature = nullptr; 1952 const char *ifName = "wlan0"; 1953 const char *ifNameInvalid = "wlanTest"; 1954 1955 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1956 if (ret == HDF_SUCCESS) { 1957 ret = g_wifi->getStationInfo(nullptr, nullptr, nullptr, ETH_ADDR_LEN); 1958 EXPECT_NE(ret, HDF_SUCCESS); 1959 ret = g_wifi->getStationInfo(ifName, nullptr, nullptr, ETH_ADDR_LEN); 1960 EXPECT_NE(ret, HDF_SUCCESS); 1961 ret = g_wifi->getStationInfo(nullptr, &info, nullptr, ETH_ADDR_LEN); 1962 EXPECT_NE(ret, HDF_SUCCESS); 1963 ret = g_wifi->getStationInfo(nullptr, nullptr, mac, ETH_ADDR_LEN); 1964 EXPECT_NE(ret, HDF_SUCCESS); 1965 ret = g_wifi->getStationInfo(ifName, &info, nullptr, ETH_ADDR_LEN); 1966 EXPECT_NE(ret, HDF_SUCCESS); 1967 ret = g_wifi->getStationInfo(nullptr, &info, mac, ETH_ADDR_LEN); 1968 EXPECT_NE(ret, HDF_SUCCESS); 1969 ret = g_wifi->getStationInfo(ifName, nullptr, mac, ETH_ADDR_LEN); 1970 EXPECT_NE(ret, HDF_SUCCESS); 1971 ret = g_wifi->getStationInfo(ifNameInvalid, &info, mac, ETH_ADDR_LEN); 1972 EXPECT_NE(ret, HDF_SUCCESS); 1973 ret = g_wifi->getStationInfo(ifName, &info, mac, ETH_ADDR_LEN); 1974 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 1975 ASSERT_TRUE(flag); 1976 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1977 EXPECT_EQ(ret, HDF_SUCCESS); 1978 } 1979} 1980 1981/** 1982 * @tc.name: GetStationInfo002 1983 * @tc.desc: Wifi hdi get station information function test 1984 * @tc.type: FUNC 1985 * @tc.require: 1986 */ 1987HWTEST_F(WifiHalTest, GetStationInfo002, TestSize.Level1) 1988{ 1989 int32_t ret; 1990 StationInfo info; 1991 bool flag; 1992 uint8_t mac[ETH_ADDR_LEN] = {0}; 1993 struct IWiFiSta *staFeature = nullptr; 1994 const char *ifName = "wlan0"; 1995 1996 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&staFeature); 1997 if (ret == HDF_SUCCESS) { 1998 ret = g_wifi->getStationInfo(nullptr, nullptr, nullptr, ETH_ADDR_LEN); 1999 EXPECT_NE(ret, HDF_SUCCESS); 2000 ret = g_wifi->getStationInfo(ifName, nullptr, nullptr, ETH_ADDR_LEN); 2001 EXPECT_NE(ret, HDF_SUCCESS); 2002 ret = g_wifi->getStationInfo(nullptr, &info, nullptr, ETH_ADDR_LEN); 2003 EXPECT_NE(ret, HDF_SUCCESS); 2004 ret = g_wifi->getStationInfo(nullptr, nullptr, mac, ETH_ADDR_LEN); 2005 EXPECT_NE(ret, HDF_SUCCESS); 2006 ret = g_wifi->getStationInfo(ifName, &info, nullptr, ETH_ADDR_LEN); 2007 EXPECT_NE(ret, HDF_SUCCESS); 2008 ret = g_wifi->getStationInfo(nullptr, &info, mac, ETH_ADDR_LEN); 2009 EXPECT_NE(ret, HDF_SUCCESS); 2010 ret = g_wifi->getStationInfo(ifName, nullptr, mac, ETH_ADDR_LEN); 2011 EXPECT_NE(ret, HDF_SUCCESS); 2012 ret = g_wifi->getStationInfo(ifName, &info, mac, ETH_ADDR_LEN); 2013 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 2014 ASSERT_TRUE(flag); 2015 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2016 EXPECT_EQ(ret, HDF_SUCCESS); 2017 } 2018} 2019 2020/** 2021 * @tc.name: GetSignalPollInfo001 2022 * @tc.desc: wifi hal get signal information function test 2023 * @tc.type: FUNC 2024 * @tc.require: 2025 */ 2026HWTEST_F(WifiHalTest, GetSignalPollInfo001, TestSize.Level1) 2027{ 2028 int32_t ret; 2029 struct IWiFiSta *staFeature = nullptr; 2030 const char *interfaceName = "wlan0"; 2031 struct SignalResult signalResult; 2032 (void)memset_s(&signalResult, sizeof(signalResult), 0, sizeof(signalResult)); 2033 2034 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2035 if (ret == HDF_SUCCESS) { 2036 EXPECT_NE(nullptr, staFeature); 2037 ret = staFeature->getSignalPollInfo(interfaceName, &signalResult); 2038 printf("getSignalPollInfo ret = %d.\n", ret); 2039 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 2040 ASSERT_TRUE(flag); 2041 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2042 EXPECT_EQ(HDF_SUCCESS, ret); 2043 } 2044} 2045 2046/** 2047 * @tc.name: WifiStartChannelMeas001 2048 * @tc.desc: Wifi start channel meas and get meas result test 2049 * @tc.type: FUNC 2050 * @tc.require: 2051 */ 2052HWTEST_F(WifiHalTest, StartChannelMeasTest001, TestSize.Level1) 2053{ 2054 int32_t ret; 2055 const char *ifName = "wlan0"; 2056 struct MeasParam measChannelParam; 2057 struct MeasResult measChannelResult = {0}; 2058 measChannelParam.channelId = 1; 2059 measChannelParam.measTime = 15; 2060 2061 ret = g_wifi->startChannelMeas(nullptr, &measChannelParam); 2062 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 2063 ret = g_wifi->startChannelMeas(ifName, nullptr); 2064 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 2065 ret = g_wifi->startChannelMeas(ifName, &measChannelParam); 2066 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); 2067 2068 ret = g_wifi->getChannelMeasResult(nullptr, &measChannelResult); 2069 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 2070 ret = g_wifi->getChannelMeasResult(ifName, nullptr); 2071 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 2072 ret = g_wifi->getChannelMeasResult(ifName, &measChannelResult); 2073 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); 2074} 2075 2076/** 2077 * @tc.name: HalRegisterHid2dCallback001 2078 * @tc.desc: Hal register hid2d callback test 2079 * @tc.type: FUNC 2080 * @tc.require: 2081 */ 2082HWTEST_F(WifiHalTest, HalRegisterHid2dCallback001, TestSize.Level1) 2083{ 2084 int32_t ret; 2085 const char *ifName = "wlan0"; 2086 2087 ret = g_wifi->registerHid2dCallback(nullptr, ifName); 2088 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 2089 ret = g_wifi->registerHid2dCallback(Hid2dFunCb, nullptr); 2090 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 2091 ret = g_wifi->registerHid2dCallback(Hid2dFunCb, ifName); 2092 EXPECT_EQ(HDF_SUCCESS, ret); 2093} 2094 2095/** 2096 * @tc.name: HalUnregisterHid2dCallback001 2097 * @tc.desc: Hal unregister hid2d callback test 2098 * @tc.type: FUNC 2099 * @tc.require: 2100 */ 2101HWTEST_F(WifiHalTest, HalUnregisterHid2dCallback001, TestSize.Level1) 2102{ 2103 int32_t ret; 2104 const char *ifName = "wlan0"; 2105 2106 ret = g_wifi->unregisterHid2dCallback(nullptr, ifName); 2107 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 2108 ret = g_wifi->unregisterHid2dCallback(Hid2dFunCb, nullptr); 2109 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 2110 ret = g_wifi->unregisterHid2dCallback(Hid2dFunCb, ifName); 2111 EXPECT_EQ(HDF_SUCCESS, ret); 2112} 2113 2114/** 2115 * @tc.name: WifiHalStartPnoScan001 2116 * @tc.desc: Wifi hal Start Scan function test 2117 * @tc.type: FUNC 2118 * @tc.require: 2119 */ 2120HWTEST_F(WifiHalTest, WifiHalStartPnoScan001, TestSize.Level1) 2121{ 2122 int32_t ret; 2123 struct IWiFiSta *staFeature = nullptr; 2124 const char *ifName = "wlan0"; 2125 WifiPnoSettings pnoSettings; 2126 (void)memset_s(&pnoSettings, sizeof(pnoSettings), 0, sizeof(pnoSettings)); 2127 2128 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2129 if (ret == HDF_SUCCESS) { 2130 EXPECT_NE(staFeature, nullptr); 2131 ret = staFeature->startPnoScan(nullptr, &pnoSettings); 2132 EXPECT_NE(HDF_SUCCESS, ret); 2133 ret = staFeature->startPnoScan(ifName, nullptr); 2134 EXPECT_NE(HDF_SUCCESS, ret); 2135 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2136 EXPECT_EQ(HDF_SUCCESS, ret); 2137 } 2138} 2139/** 2140 * @tc.name: WifiHalStartPnoScan002 2141 * @tc.desc: Wifi hal Start Scan function test 2142 * @tc.type: FUNC 2143 * @tc.require: 2144 */ 2145HWTEST_F(WifiHalTest, WifiHalStartPnoScan002, TestSize.Level1) 2146{ 2147 int32_t ret; 2148 bool flag; 2149 struct IWiFiSta *staFeature = nullptr; 2150 const char *ifName = "wlan0"; 2151 string ssid1 = "xa-hw"; 2152 string ssid2 = "xa-hw-03"; 2153 WifiPnoSettings pnoSettings; 2154 (void)memset_s(&pnoSettings, sizeof(pnoSettings), 0, sizeof(pnoSettings)); 2155 pnoSettings.min2gRssi = -120; 2156 pnoSettings.min5gRssi = -130; 2157 pnoSettings.scanIntervalMs = 60000; 2158 pnoSettings.scanIterations = 3; 2159 2160 pnoSettings.pnoNetworksLen = 2; 2161 pnoSettings.pnoNetworks = (WifiPnoNetwork *)OsalMemCalloc(sizeof(WifiPnoNetwork) * 2); 2162 pnoSettings.pnoNetworks[0].isHidden = 1; 2163 memcpy_s(pnoSettings.pnoNetworks[0].ssid.ssid, MAX_SSID_LEN, ssid1.c_str(), ssid1.length()); 2164 pnoSettings.pnoNetworks[0].ssid.ssidLen = ssid1.length(); 2165 pnoSettings.pnoNetworks[1].isHidden = 0; 2166 memcpy_s(pnoSettings.pnoNetworks[1].ssid.ssid, MAX_SSID_LEN, ssid2.c_str(), ssid2.length()); 2167 pnoSettings.pnoNetworks[1].ssid.ssidLen = ssid2.length(); 2168 2169 ret = g_wifi->registerEventCallback(HalCallbackEvent, ifName); 2170 EXPECT_EQ(HDF_SUCCESS, ret); 2171 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2172 if (ret == HDF_SUCCESS) { 2173 EXPECT_NE(staFeature, nullptr); 2174 ret = staFeature->startPnoScan(ifName, &pnoSettings); 2175 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 2176 printf("ret = %d.\n", ret); 2177 ASSERT_TRUE(flag); 2178 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2179 EXPECT_EQ(HDF_SUCCESS, ret); 2180 } 2181 ret = g_wifi->unregisterEventCallback(HalCallbackEvent, ifName); 2182 EXPECT_EQ(HDF_SUCCESS, ret); 2183 OsalMemFree(pnoSettings.pnoNetworks); 2184} 2185 2186/** 2187 * @tc.name: WifiHalStopPnoScan001 2188 * @tc.desc: Wifi hal stop pno scan 2189 * @tc.type: FUNC 2190 * @tc.require: 2191 */ 2192HWTEST_F(WifiHalTest, WifiHalStopPnoScan001, TestSize.Level1) 2193{ 2194 int32_t ret; 2195 bool flag; 2196 struct IWiFiSta *staFeature = nullptr; 2197 const char *ifName = "wlan0"; 2198 2199 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2200 if (ret == HDF_SUCCESS) { 2201 EXPECT_NE(nullptr, staFeature); 2202 ret = staFeature->stopPnoScan(nullptr); 2203 EXPECT_NE(HDF_SUCCESS, ret); 2204 ret = staFeature->stopPnoScan(ifName); 2205 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 2206 ASSERT_TRUE(flag); 2207 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2208 EXPECT_EQ(HDF_SUCCESS, ret); 2209 } 2210} 2211 2212/** 2213 * @tc.name: WifiSendActionFrame001 2214 * @tc.desc: Wifi send action frame factiom test 2215 * @tc.type: FUNC 2216 * @tc.require: 2217 */ 2218HWTEST_F(WifiHalTest, WifiSendActionFrame001, TestSize.Level1) 2219{ 2220 int32_t freq = WLAN_TX_POWER; 2221 uint8_t frameData[IFNAME_MAX_NUM - 1] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd}; 2222 uint32_t frameDataLen = IFNAME_MAX_NUM; 2223 const char *ifName = "wlan0"; 2224 2225 int32_t rc = g_wifi->sendActionFrame(nullptr, freq, frameData, frameDataLen); 2226 ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM); 2227 rc = g_wifi->sendActionFrame(ifName, 0, frameData, frameDataLen); 2228 ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM); 2229 rc = g_wifi->sendActionFrame(ifName, freq, nullptr, frameDataLen); 2230 ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM); 2231 rc = g_wifi->sendActionFrame(ifName, freq, frameData, 0); 2232 ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM); 2233 g_wifi->sendActionFrame(ifName, freq, frameData, frameDataLen); 2234} 2235 2236/** 2237 * @tc.name: RegisterActionFrameReceiver001 2238 * @tc.desc: Wifi send action frame factiom test 2239 * @tc.type: FUNC 2240 * @tc.require: 2241 */ 2242HWTEST_F(WifiHalTest, RegisterActionFrameReceiver001, TestSize.Level1) 2243{ 2244 uint8_t match[IFNAME_MAX_NUM - 1] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd}; 2245 uint32_t matchLen = IFNAME_MAX_NUM; 2246 const char *ifName = "wlan0"; 2247 2248 int32_t rc = g_wifi->registerActionFrameReceiver(nullptr, match, matchLen); 2249 ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM); 2250 rc = g_wifi->registerActionFrameReceiver(ifName, nullptr, matchLen); 2251 ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM); 2252 rc = g_wifi->registerActionFrameReceiver(ifName, match, 0); 2253 ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM); 2254 g_wifi->registerActionFrameReceiver(ifName, match, matchLen); 2255} 2256 2257/** 2258 * @tc.name: WifiHalGetGetFeatureType001 2259 * @tc.desc: Wifi hal get feature type function test 2260 * @tc.type: FUNC 2261 * @tc.require: AR000F869G 2262 */ 2263HWTEST_F(WifiHalTest, InitFeatureByType001, TestSize.Level1) 2264{ 2265 int ret; 2266 struct IWiFiP2p *p2pFeature = nullptr; 2267 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_P2P_DEVICE, nullptr); 2268 EXPECT_EQ(ret, HDF_FAILURE); 2269 g_wifi->createFeature(PROTOCOL_80211_IFTYPE_P2P_DEVICE, (struct IWiFiBaseFeature **)&p2pFeature); 2270} 2271}; // namespace HalTest 2272