1/* 2 * Copyright (c) 2021-2022 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 26using namespace testing::ext; 27 28namespace HalTest { 29struct IWiFi *g_wifi = nullptr; 30const int32_t WLAN_TX_POWER = 160; 31const uint32_t IFNAME_MIN_NUM = 0; 32const uint32_t IFNAME_MAX_NUM = 32; 33const uint32_t MAX_IF_NAME_LENGTH = 16; 34const uint32_t TEST_PARAM_BUF_SIZE = 64; 35const uint32_t SIZE = 4; 36const int32_t TEST_CMD = 123; 37const uint32_t TEST_BUF_SIZE = 64; 38const uint32_t DEFAULT_COMBO_SIZE = 10; 39const uint32_t RESET_TIME = 20; 40 41class WifiHalTest : public testing::Test { 42public: 43 static void SetUpTestCase(); 44 static void TearDownTestCase(); 45 void SetUp(); 46 void TearDown(); 47}; 48 49void WifiHalTest::SetUpTestCase() 50{ 51 int ret; 52 53 ret = WifiConstruct(&g_wifi); 54 ASSERT_EQ(HDF_SUCCESS, ret); 55} 56 57void WifiHalTest::TearDownTestCase() 58{ 59 int ret; 60 61 ret = WifiDestruct(&g_wifi); 62 ASSERT_EQ(HDF_SUCCESS, ret); 63} 64 65void WifiHalTest::SetUp() 66{ 67 int ret; 68 69 ret = g_wifi->start(nullptr); 70 ASSERT_EQ(HDF_ERR_INVALID_PARAM, ret); 71 ret = g_wifi->start(g_wifi); 72 ASSERT_EQ(HDF_SUCCESS, ret); 73} 74 75void WifiHalTest::TearDown() 76{ 77 int ret; 78 79 ret = g_wifi->stop(nullptr); 80 ASSERT_EQ(HDF_ERR_INVALID_PARAM, ret); 81 ret = g_wifi->stop(g_wifi); 82 ASSERT_EQ(HDF_SUCCESS, ret); 83} 84 85static void ParseScanResult(WifiScanResult *scanResult) 86{ 87 printf("ParseScanResult: flags=%d, caps=%d, freq=%d, beaconInt=%d,\n", 88 scanResult->flags, scanResult->caps, scanResult->freq, scanResult->beaconInt); 89 printf("ParseScanResult: qual=%d, beaconIeLen=%d, level=%d, age=%d, ieLen=%d,\n", 90 scanResult->qual, scanResult->beaconIeLen, scanResult->level, scanResult->age, scanResult->ieLen); 91} 92 93static int32_t HalCallbackEvent(uint32_t event, void *respData, const char *ifName) 94{ 95 (void)event; 96 if (respData == nullptr) { 97 return HDF_FAILURE; 98 } 99 printf("HalCallbackEvent ifName = %s, event = %d\n", ifName, event); 100 switch (event) { 101 case WIFI_EVENT_SCAN_DONE: 102 printf("HalCallbackEvent WIFI_EVENT_SCAN_DONE Process\n"); 103 break; 104 case WIFI_EVENT_SCAN_RESULT: 105 ParseScanResult((WifiScanResult *)respData); 106 break; 107 default: 108 break; 109 } 110 return HDF_SUCCESS; 111} 112 113/** 114 * @tc.name: WifiHalCreateAndDestroyFeature001 115 * @tc.desc: Wifi hal create and destroy feature function test_01 116 * @tc.type: FUNC 117 */ 118 119HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_3700, Function | MediumTest | Level1) 120{ 121 int ret; 122 struct IWiFiAp *apFeature = nullptr; 123 124 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 125 EXPECT_EQ(HDF_SUCCESS, ret); 126 EXPECT_NE(nullptr, apFeature); 127 128 ret = g_wifi->destroyFeature(nullptr); 129 EXPECT_NE(HDF_SUCCESS, ret); 130} 131 132/** 133 * @tc.name: WifiHalCreateAndDestroyFeature002 134 * @tc.desc: Wifi hal create and destroy feature function test_02 135 * @tc.type: FUNC 136 */ 137 138HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_3800, Function | MediumTest | Level1) 139{ 140 int ret; 141 struct IWiFiAp *apFeature = nullptr; 142 143 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 144 EXPECT_EQ(HDF_SUCCESS, ret); 145 EXPECT_NE(nullptr, apFeature); 146 147 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 148 EXPECT_EQ(HDF_SUCCESS, ret); 149} 150 151/** 152 * @tc.name: WifiHalCreateAndDestroyFeature003 153 * @tc.desc: Wifi hal create and destroy feature function test_03 154 * @tc.type: FUNC 155 */ 156HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_3900, Function | MediumTest | Level1) 157{ 158 int ret; 159 struct IWiFiSta *staFeature = nullptr; 160 161 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 162 EXPECT_EQ(HDF_SUCCESS, ret); 163 EXPECT_NE(nullptr, staFeature); 164 165 ret = g_wifi->destroyFeature(nullptr); 166 EXPECT_NE(HDF_SUCCESS, ret); 167} 168 169/** 170 * @tc.name: WifiHalCreateAndDestroyFeature004 171 * @tc.desc: Wifi hal create and destroy feature function test_04 172 * @tc.type: FUNC 173 */ 174HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_4000, Function | MediumTest | Level1) 175{ 176 int ret; 177 struct IWiFiSta *staFeature = nullptr; 178 179 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 180 EXPECT_EQ(HDF_SUCCESS, ret); 181 EXPECT_NE(nullptr, staFeature); 182 183 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 184 EXPECT_EQ(HDF_SUCCESS, ret); 185} 186 187/** 188 * @tc.name: WifiHalCreateFeature001 189 * @tc.desc: Wifi hal create feature function test_01 190 * @tc.type: FUNC 191 */ 192HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_4100, Function | MediumTest | Level1) 193{ 194 int32_t ret; 195 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, nullptr); 196 EXPECT_EQ(ret, HDF_FAILURE); 197} 198 199/** 200 * @tc.name: WifiHalCreateFeature002 201 * @tc.desc: Wifi hal create feature function test_02 202 * @tc.type: FUNC 203 */ 204HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_4200, Function | MediumTest | Level1) 205{ 206 int32_t ret; 207 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, nullptr); 208 EXPECT_EQ(ret, HDF_FAILURE); 209} 210 211/** 212 * @tc.name: WifiHalCreateFeature003 213 * @tc.desc: Wifi hal create feature function test_03 214 * @tc.type: FUNC 215 */ 216HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_4300, Function | MediumTest | Level1) 217{ 218 int32_t ret; 219 struct IWiFiSta *staFeature = nullptr; 220 221 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_NUM, (struct IWiFiBaseFeature **)&staFeature); 222 EXPECT_NE(ret, HDF_SUCCESS); 223} 224 225/** 226 * @tc.name: WifiHalCreateFeature004 227 * @tc.desc: Wifi hal create feature function test_04 228 * @tc.type: FUNC 229 */ 230HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_4400, Function | MediumTest | Level1) 231{ 232 int32_t ret; 233 struct IWiFiSta *staFeature = nullptr; 234 235 ret = g_wifi->createFeature(-1, (struct IWiFiBaseFeature **)&staFeature); 236 EXPECT_NE(ret, HDF_SUCCESS); 237} 238 239/** 240 * @tc.name: WifiHalGetFeatureByIfName001 241 * @tc.desc: Wifi hal get feature by ifname function test_01 242 * @tc.type: FUNC 243 */ 244HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_4450, Function | MediumTest | Level1) 245{ 246 int ret; 247 struct IWiFiAp *apFeature = nullptr; 248 struct IWiFiAp *apFeatureGet = nullptr; 249 250 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 251 EXPECT_EQ(HDF_SUCCESS, ret); 252 EXPECT_NE(nullptr, apFeature); 253 ret = g_wifi->getFeatureByIfName(nullptr, (struct IWiFiBaseFeature **)&apFeatureGet); 254 EXPECT_NE(ret, HDF_SUCCESS); 255 256 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 257 EXPECT_EQ(HDF_SUCCESS, ret); 258} 259 260/** 261 * @tc.name: WifiHalGetFeatureByIfName002 262 * @tc.desc: Wifi hal get feature by ifname function test_02 263 * @tc.type: FUNC 264 */ 265HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_4550, Function | MediumTest | Level1) 266{ 267 int ret; 268 struct IWiFiAp *apFeature = nullptr; 269 struct IWiFiAp *apFeatureGet = nullptr; 270 const char *ifName0 = "wlanTest"; 271 272 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 273 EXPECT_EQ(HDF_SUCCESS, ret); 274 EXPECT_NE(nullptr, apFeature); 275 ret = g_wifi->getFeatureByIfName(ifName0, (struct IWiFiBaseFeature **)&apFeatureGet); 276 EXPECT_NE(HDF_SUCCESS, ret); 277 278 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 279 EXPECT_EQ(HDF_SUCCESS, ret); 280} 281 282/** 283 * @tc.name: WifiHalGetFeatureByIfName003 284 * @tc.desc: Wifi hal get feature by ifname function test_03 285 * @tc.type: FUNC 286 */ 287HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_4650, Function | MediumTest | Level1) 288{ 289 int ret; 290 struct IWiFiAp *apFeature = nullptr; 291 struct IWiFiAp *apFeatureGet = nullptr; 292 293 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 294 EXPECT_EQ(HDF_SUCCESS, ret); 295 EXPECT_NE(nullptr, apFeature); 296 ret = g_wifi->getFeatureByIfName(apFeature->baseFeature.ifName, (struct IWiFiBaseFeature **)&apFeatureGet); 297 EXPECT_EQ(HDF_SUCCESS, ret); 298 EXPECT_NE(nullptr, apFeatureGet); 299 300 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 301 EXPECT_EQ(HDF_SUCCESS, ret); 302} 303 304/** 305 * @tc.name: WifiHalGetFeatureByIfName004 306 * @tc.desc: Wifi hal get feature by ifname function test_04 307 * @tc.type: FUNC 308 */ 309HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_4750, Function | MediumTest | Level1) 310{ 311 int32_t ret; 312 struct IWiFiSta *staFeature = nullptr; 313 314 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 315 EXPECT_EQ(ret, HDF_SUCCESS); 316 EXPECT_NE(staFeature, nullptr); 317 ret = g_wifi->getFeatureByIfName(nullptr, (struct IWiFiBaseFeature **)&staFeature); 318 EXPECT_NE(ret, HDF_SUCCESS); 319 320 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 321 EXPECT_EQ(ret, HDF_SUCCESS); 322} 323 324/** 325 * @tc.name: WifiHalGetFeatureByIfName005 326 * @tc.desc: Wifi hal get feature by ifname function test_05 327 * @tc.type: FUNC 328 */ 329HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_4850, Function | MediumTest | Level1) 330{ 331 int32_t ret; 332 struct IWiFiSta *staFeature = nullptr; 333 const char *ifName0 = "wlanTest"; 334 335 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 336 EXPECT_EQ(ret, HDF_SUCCESS); 337 EXPECT_NE(staFeature, nullptr); 338 ret = g_wifi->getFeatureByIfName(ifName0, (struct IWiFiBaseFeature **)&staFeature); 339 EXPECT_NE(ret, HDF_SUCCESS); 340 341 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 342 EXPECT_EQ(ret, HDF_SUCCESS); 343} 344 345/** 346 * @tc.name: WifiHalGetFeatureByIfName006 347 * @tc.desc: Wifi hal get feature by ifname function test_06 348 * @tc.type: FUNC 349 */ 350HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_4950, Function | MediumTest | Level1) 351{ 352 int32_t ret; 353 struct IWiFiSta *staFeature = nullptr; 354 struct IWiFiSta *staFeatureGet = nullptr; 355 356 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 357 EXPECT_EQ(ret, HDF_SUCCESS); 358 EXPECT_NE(staFeature, nullptr); 359 ret = g_wifi->getFeatureByIfName(staFeature->baseFeature.ifName, (struct IWiFiBaseFeature **)&staFeatureGet); 360 EXPECT_EQ(ret, HDF_SUCCESS); 361 EXPECT_NE(staFeatureGet, nullptr); 362 363 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 364 EXPECT_EQ(ret, HDF_SUCCESS); 365} 366/** 367 * @tc.name: WifiHalRegisterEventCallback001 368 * @tc.desc: Wifi hal register callback function test_01 369 * @tc.type: FUNC 370 */ 371HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_7100, Function | MediumTest | Level1) 372{ 373 int ret; 374 375 ret = g_wifi->registerEventCallback(HalCallbackEvent, "wlan0"); 376 EXPECT_EQ(HDF_SUCCESS, ret); 377} 378 379/** 380 * @tc.name: WifiHalRegisterEventCallback002 381 * @tc.desc: Wifi hal register event callback test_02 382 * @tc.type: FUNC 383 */ 384HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_7200, Function | MediumTest | Level1) 385{ 386 int32_t ret; 387 388 ret = g_wifi->registerEventCallback(nullptr, "wlan0"); 389 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 390 391} 392 393/** 394 * @tc.name: WifiHalRegisterEventCallback003 395 * @tc.desc: Wifi hal register event callback test_03 396 * @tc.type: FUNC 397 */ 398HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_7300, Function | MediumTest | Level1) 399{ 400 int32_t ret; 401 402 ret = g_wifi->registerEventCallback(HalCallbackEvent, nullptr); 403 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 404} 405 406/** 407 * @tc.name: WifiHalUnRegisterEventCallback001 408 * @tc.desc: Wifi hal unregister callback function test_01 409 * @tc.type: FUNC 410 */ 411HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_9300, Function | MediumTest | Level1) 412{ 413 int ret; 414 415 ret = g_wifi->unregisterEventCallback(HalCallbackEvent, "wlan0"); 416 EXPECT_EQ(HDF_SUCCESS, ret); 417} 418 419/** 420 * @tc.name: WifiHalUnRegisterEventCallback002 421 * @tc.desc: Wifi hal unregister event callback test_02 422 * @tc.type: FUNC 423 */ 424HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_9400, Function | MediumTest | Level1) 425{ 426 int32_t ret; 427 428 ret = g_wifi->unregisterEventCallback(nullptr, "wlan0"); 429 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 430 431} 432 433/** 434 * @tc.name: WifiHalUnRegisterEventCallback003 435 * @tc.desc: Wifi hal unregister event callback test_03 436 * @tc.type: FUNC 437 */ 438HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_9500, Function | MediumTest | Level1) 439{ 440 int32_t ret; 441 442 ret = g_wifi->unregisterEventCallback(HalCallbackEvent, nullptr); 443 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 444} 445 446/** 447 * @tc.name: WifiHalGetNetworkIfaceName001 448 * @tc.desc: Wifi hal get network iface name function test_01 449 * @tc.type: FUNC 450 */ 451HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_6100, Function | MediumTest | Level1) 452{ 453 int ret; 454 struct IWiFiAp *apFeature = nullptr; 455 456 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 457 EXPECT_EQ(HDF_SUCCESS, ret); 458 EXPECT_NE(nullptr, apFeature); 459 const char *ifnameTest = apFeature->baseFeature.getNetworkIfaceName(nullptr); 460 EXPECT_EQ(ifnameTest, nullptr); 461 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 462 EXPECT_EQ(HDF_SUCCESS, ret); 463} 464 465/** 466 * @tc.name: WifiHalGetNetworkIfaceName002 467 * @tc.desc: Wifi hal get network iface name function test_02 468 * @tc.type: FUNC 469 */ 470HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_6200, Function | MediumTest | Level1) 471{ 472 int ret; 473 struct IWiFiAp *apFeature = nullptr; 474 475 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 476 EXPECT_EQ(HDF_SUCCESS, ret); 477 EXPECT_NE(nullptr, apFeature); 478 const char *ifName = apFeature->baseFeature.getNetworkIfaceName((const struct IWiFiBaseFeature *)apFeature); 479 EXPECT_NE(nullptr, ifName); 480 481 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 482 EXPECT_EQ(HDF_SUCCESS, ret); 483} 484 485/** 486 * @tc.name: WifiHalGetNetworkIfaceName003 487 * @tc.desc: Wifi hal get network iface name function test_03 488 * @tc.type: FUNC 489 */ 490HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_6300, Function | MediumTest | Level1) 491{ 492 int32_t ret; 493 struct IWiFiSta *staFeature = nullptr; 494 495 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 496 EXPECT_EQ(ret, HDF_SUCCESS); 497 EXPECT_NE(staFeature, nullptr); 498 const char *ifnameTest = staFeature->baseFeature.getNetworkIfaceName(nullptr); 499 EXPECT_EQ(ifnameTest, nullptr); 500 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 501 EXPECT_EQ(ret, HDF_SUCCESS); 502} 503 504/** 505 * @tc.name: WifiHalGetNetworkIfaceName004 506 * @tc.desc: Wifi hal get network iface name function test_04 507 * @tc.type: FUNC 508 */ 509HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_6400, Function | MediumTest | Level1) 510{ 511 int32_t ret; 512 struct IWiFiSta *staFeature = nullptr; 513 514 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 515 EXPECT_EQ(ret, HDF_SUCCESS); 516 EXPECT_NE(staFeature, nullptr); 517 518 const char *ifName = staFeature->baseFeature.getNetworkIfaceName((const struct IWiFiBaseFeature *)staFeature); 519 EXPECT_NE(ifName, nullptr); 520 if (strncmp(ifName, "wlan", 4) == 0 || strncmp(ifName, "nan", 3) == 0 || strncmp(ifName, "p2p", 3) == 0) { 521 ret = 0; 522 } else { 523 ret = -1; 524 } 525 EXPECT_EQ(ret, 0); 526 527 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 528 EXPECT_EQ(ret, HDF_SUCCESS); 529} 530 531/** 532 * @tc.name: WifiHalGetFeatureType001 533 * @tc.desc: Wifi hal get feature type function test_01 534 * @tc.type: FUNC 535 */ 536HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_5700, Function | MediumTest | Level1) 537{ 538 int ret; 539 struct IWiFiAp *apFeature = nullptr; 540 int32_t type; 541 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 542 EXPECT_EQ(HDF_SUCCESS, ret); 543 EXPECT_NE(nullptr, apFeature); 544 type = apFeature->baseFeature.getFeatureType(nullptr); 545 EXPECT_EQ(type, HDF_FAILURE); 546 547 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 548 EXPECT_EQ(HDF_SUCCESS, ret); 549} 550 551/** 552 * @tc.name: WifiHalGetFeatureType002 553 * @tc.desc: Wifi hal get feature type function test_02 554 * @tc.type: FUNC 555 */ 556HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_5800, Function | MediumTest | Level1) 557{ 558 int ret; 559 struct IWiFiAp *apFeature = nullptr; 560 int32_t type; 561 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 562 EXPECT_EQ(HDF_SUCCESS, ret); 563 EXPECT_NE(nullptr, apFeature); 564 type = apFeature->baseFeature.getFeatureType((struct IWiFiBaseFeature *)apFeature); 565 EXPECT_EQ(PROTOCOL_80211_IFTYPE_AP, type); 566 567 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 568 EXPECT_EQ(HDF_SUCCESS, ret); 569} 570 571/** 572 * @tc.name: WifiHalGetFeatureType003 573 * @tc.desc: Wifi hal get feature type function test_03 574 * @tc.type: FUNC 575 */ 576HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_5900, Function | MediumTest | Level1) 577{ 578 int32_t ret; 579 struct IWiFiSta *staFeature = nullptr; 580 int32_t type; 581 582 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 583 EXPECT_EQ(ret, HDF_SUCCESS); 584 EXPECT_NE(staFeature, nullptr); 585 type = staFeature->baseFeature.getFeatureType(nullptr); 586 EXPECT_EQ(type, HDF_FAILURE); 587 588 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 589 EXPECT_EQ(ret, HDF_SUCCESS); 590} 591 592/** 593 * @tc.name: WifiHalGetFeatureType004 594 * @tc.desc: Wifi hal get feature type function test_04 595 * @tc.type: FUNC 596 */ 597HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_6000, Function | MediumTest | Level1) 598{ 599 int32_t ret; 600 struct IWiFiSta *staFeature = nullptr; 601 int32_t type; 602 603 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 604 EXPECT_EQ(ret, HDF_SUCCESS); 605 EXPECT_NE(staFeature, nullptr); 606 type = staFeature->baseFeature.getFeatureType((struct IWiFiBaseFeature *)staFeature); 607 EXPECT_EQ(type, PROTOCOL_80211_IFTYPE_STATION); 608 609 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 610 EXPECT_EQ(ret, HDF_SUCCESS); 611} 612 613/** 614 * @tc.name: WifiHalSetMacAddress001 615 * @tc.desc: Wifi hal set Mac address function test_01 616 * @tc.type: FUNC 617 */ 618HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SetDeviceMACaddress_0500, Function | MediumTest | Level1) 619{ 620 int ret; 621 struct IWiFiAp *apFeature = nullptr; 622 unsigned char mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd}; 623 624 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 625 EXPECT_EQ(HDF_SUCCESS, ret); 626 EXPECT_NE(nullptr, apFeature); 627 ret = apFeature->baseFeature.setMacAddress(nullptr, mac, ETH_ADDR_LEN); 628 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 629 630 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 631 EXPECT_EQ(HDF_SUCCESS, ret); 632} 633 634/** 635 * @tc.name: WifiHalSetMacAddress002 636 * @tc.desc: Wifi hal set Mac address function test_02 637 * @tc.type: FUNC 638 */ 639HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SetDeviceMACaddress_0600, Function | MediumTest | Level1) 640{ 641 int ret; 642 struct IWiFiAp *apFeature = nullptr; 643 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 644 EXPECT_EQ(HDF_SUCCESS, ret); 645 EXPECT_NE(nullptr, apFeature); 646 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, nullptr, ETH_ADDR_LEN); 647 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 648 649 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 650 EXPECT_EQ(HDF_SUCCESS, ret); 651} 652 653/** 654 * @tc.name: WifiHalSetMacAddress003 655 * @tc.desc: Wifi hal set Mac address function test_03 656 * @tc.type: FUNC 657 */ 658HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SetDeviceMACaddress_0700, Function | MediumTest | Level1) 659{ 660 int ret; 661 struct IWiFiAp *apFeature = nullptr; 662 unsigned char mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd}; 663 664 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 665 EXPECT_EQ(HDF_SUCCESS, ret); 666 EXPECT_NE(nullptr, apFeature); 667 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, mac, 0); 668 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 669 670 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 671 EXPECT_EQ(HDF_SUCCESS, ret); 672} 673 674/** 675 * @tc.name: WifiHalSetMacAddress004 676 * @tc.desc: Wifi hal set Mac address function test_04 677 * @tc.type: FUNC 678 */ 679HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SetDeviceMACaddress_0800, Function | MediumTest | Level1) 680{ 681 int ret; 682 struct IWiFiAp *apFeature = nullptr; 683 unsigned char errorMac[ETH_ADDR_LEN] = {0x11, 0x34, 0x56, 0x78, 0xab, 0xcd}; 684 685 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 686 EXPECT_EQ(HDF_SUCCESS, ret); 687 EXPECT_NE(nullptr, apFeature); 688 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, errorMac, ETH_ADDR_LEN); 689 EXPECT_NE(ret, HDF_SUCCESS); 690 691 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 692 EXPECT_EQ(HDF_SUCCESS, ret); 693} 694 695/** 696 * @tc.name: WifiHalSetMacAddress005 697 * @tc.desc: Wifi hal set Mac address function test_05 698 * @tc.type: FUNC 699 */ 700HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SetDeviceMACaddress_0900, Function | MediumTest | Level1) 701{ 702 int ret; 703 struct IWiFiAp *apFeature = nullptr; 704 unsigned char mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd}; 705 706 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 707 EXPECT_EQ(HDF_SUCCESS, ret); 708 EXPECT_NE(nullptr, apFeature); 709 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, mac, ETH_ADDR_LEN); 710 printf("%s: ret = %d\n", __func__, ret); 711 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_DEVICE_BUSY); 712 ASSERT_TRUE(flag); 713 714 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 715 EXPECT_EQ(HDF_SUCCESS, ret); 716} 717 718/** 719 * @tc.name: WifiHalSetMacAddress006 720 * @tc.desc: Wifi hal set Mac address function test_06 721 * @tc.type: FUNC 722 */ 723HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SetDeviceMACaddress_1000, Function | MediumTest | Level1) 724{ 725 int ret; 726 struct IWiFiSta *staFeature = nullptr; 727 unsigned char mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd}; 728 729 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 730 EXPECT_EQ(HDF_SUCCESS, ret); 731 EXPECT_NE(nullptr, staFeature); 732 ret = staFeature->baseFeature.setMacAddress(nullptr, mac, ETH_ADDR_LEN); 733 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 734 735 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 736 EXPECT_EQ(HDF_SUCCESS, ret); 737} 738 739/** 740 * @tc.name: WifiHalSetMacAddress007 741 * @tc.desc: Wifi hal set Mac address function test_07 742 * @tc.type: FUNC 743 */ 744HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SetDeviceMACaddress_1100, Function | MediumTest | Level1) 745{ 746 int ret; 747 struct IWiFiSta *staFeature = nullptr; 748 749 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 750 EXPECT_EQ(HDF_SUCCESS, ret); 751 EXPECT_NE(nullptr, staFeature); 752 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, nullptr, ETH_ADDR_LEN); 753 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 754 755 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 756 EXPECT_EQ(HDF_SUCCESS, ret); 757} 758 759/** 760 * @tc.name: WifiHalSetMacAddress008 761 * @tc.desc: Wifi hal set Mac address function test_08 762 * @tc.type: FUNC 763 */ 764HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SetDeviceMACaddress_1200, Function | MediumTest | Level1) 765{ 766 int ret; 767 struct IWiFiSta *staFeature = nullptr; 768 unsigned char mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd}; 769 770 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 771 EXPECT_EQ(HDF_SUCCESS, ret); 772 EXPECT_NE(nullptr, staFeature); 773 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, mac, 0); 774 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 775 776 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 777 EXPECT_EQ(HDF_SUCCESS, ret); 778} 779 780/** 781 * @tc.name: WifiHalSetMacAddress009 782 * @tc.desc: Wifi hal set Mac address function test_09 783 * @tc.type: FUNC 784 */ 785HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SetDeviceMACaddress_1300, Function | MediumTest | Level1) 786{ 787 int ret; 788 struct IWiFiSta *staFeature = nullptr; 789 unsigned char errorMac[ETH_ADDR_LEN] = {0x11, 0x34, 0x56, 0x78, 0xab, 0xcd}; 790 791 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 792 EXPECT_EQ(HDF_SUCCESS, ret); 793 EXPECT_NE(nullptr, staFeature); 794 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, errorMac, ETH_ADDR_LEN); 795 EXPECT_NE(ret, HDF_SUCCESS); 796 797 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 798 EXPECT_EQ(HDF_SUCCESS, ret); 799} 800 801/** 802 * @tc.name: WifiHalSetMacAddress010 803 * @tc.desc: Wifi hal set Mac address function test_10 804 * @tc.type: FUNC 805 */ 806HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SetDeviceMACaddress_1400, Function | MediumTest | Level1) 807{ 808 int ret; 809 struct IWiFiSta *staFeature = nullptr; 810 unsigned char mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd}; 811 812 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 813 EXPECT_EQ(HDF_SUCCESS, ret); 814 EXPECT_NE(nullptr, staFeature); 815 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, mac, ETH_ADDR_LEN); 816 printf("%s: ret = %d\n", __func__, ret); 817 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_DEVICE_BUSY); 818 ASSERT_TRUE(flag); 819 820 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 821 EXPECT_EQ(HDF_SUCCESS, ret); 822} 823 824/** 825 * @tc.name: WifiHalSetTxPower001 826 * @tc.desc: Wifi hal set transmit power function test_01 827 * @tc.type: FUNC 828 */ 829HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_8700, Function | MediumTest | Level1) 830{ 831 int ret; 832 struct IWiFiAp *apFeature = nullptr; 833 834 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 835 EXPECT_EQ(HDF_SUCCESS, ret); 836 EXPECT_NE(nullptr, apFeature); 837 ret = apFeature->baseFeature.setTxPower(nullptr, WLAN_TX_POWER); 838 EXPECT_NE(ret, HDF_SUCCESS); 839 840 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 841 EXPECT_EQ(HDF_SUCCESS, ret); 842} 843 844/** 845 * @tc.name: WifiHalSetTxPower002 846 * @tc.desc: Wifi hal set transmit power function test_02 847 * @tc.type: FUNC 848 */ 849HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_8800, Function | MediumTest | Level1) 850{ 851 int ret; 852 struct IWiFiAp *apFeature = nullptr; 853 854 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 855 EXPECT_EQ(HDF_SUCCESS, ret); 856 EXPECT_NE(nullptr, apFeature); 857 ret = apFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)apFeature, 0); 858 EXPECT_NE(HDF_SUCCESS, ret); 859 860 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 861 EXPECT_EQ(HDF_SUCCESS, ret); 862} 863 864/** 865 * @tc.name: WifiHalSetTxPower003 866 * @tc.desc: Wifi hal set transmit power function test_03 867 * @tc.type: FUNC 868 */ 869HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_8900, Function | MediumTest | Level1) 870{ 871 int ret; 872 struct IWiFiAp *apFeature = nullptr; 873 874 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 875 EXPECT_EQ(HDF_SUCCESS, ret); 876 EXPECT_NE(nullptr, apFeature); 877 ret = apFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)apFeature, WLAN_TX_POWER); 878 EXPECT_EQ(HDF_SUCCESS, ret); 879 880 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 881 EXPECT_EQ(HDF_SUCCESS, ret); 882} 883 884/** 885 * @tc.name: WifiHalSetTxPower004 886 * @tc.desc: Wifi hal set transmit power function test_04 887 * @tc.type: FUNC 888 */ 889HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_9000, Function | MediumTest | Level1) 890{ 891 int32_t ret; 892 struct IWiFiSta *staFeature = nullptr; 893 894 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 895 EXPECT_EQ(ret, HDF_SUCCESS); 896 EXPECT_NE(staFeature, nullptr); 897 ret = staFeature->baseFeature.setTxPower(nullptr, WLAN_TX_POWER); 898 EXPECT_NE(ret, HDF_SUCCESS); 899 900 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 901 EXPECT_EQ(ret, HDF_SUCCESS); 902} 903 904/** 905 * @tc.name: WifiHalSetTxPower005 906 * @tc.desc: Wifi hal set transmit power function test_05 907 * @tc.type: FUNC 908 */ 909HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_9100, Function | MediumTest | Level1) 910{ 911 int32_t ret; 912 struct IWiFiSta *staFeature = nullptr; 913 914 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 915 EXPECT_EQ(ret, HDF_SUCCESS); 916 EXPECT_NE(staFeature, nullptr); 917 ret = staFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)staFeature, -1); 918 EXPECT_NE(ret, HDF_SUCCESS); 919 920 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 921 EXPECT_EQ(ret, HDF_SUCCESS); 922} 923 924/** 925 * @tc.name: WifiHalSetTxPower006 926 * @tc.desc: Wifi hal set transmit power function test_06 927 * @tc.type: FUNC 928 */ 929HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_9200, Function | MediumTest | Level1) 930{ 931 int32_t ret; 932 struct IWiFiSta *staFeature = nullptr; 933 934 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 935 EXPECT_EQ(ret, HDF_SUCCESS); 936 EXPECT_NE(staFeature, nullptr); 937 ret = staFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)staFeature, WLAN_TX_POWER); 938 EXPECT_EQ(ret, HDF_SUCCESS); 939 940 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 941 EXPECT_EQ(ret, HDF_SUCCESS); 942} 943 944/** 945 * @tc.name: WifiHalSetCountryCode001 946 * @tc.desc: Wifi hal set country code function test_01 947 * @tc.type: FUNC 948 */ 949HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_8200, Function | MediumTest | Level1) 950{ 951 int ret; 952 struct IWiFiAp *apFeature = nullptr; 953 954 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 955 EXPECT_EQ(HDF_SUCCESS, ret); 956 EXPECT_NE(nullptr, apFeature); 957 ret = apFeature->setCountryCode(apFeature, nullptr, 0); 958 EXPECT_NE(ret, HDF_SUCCESS); 959 960 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 961 EXPECT_EQ(HDF_SUCCESS, ret); 962} 963 964/** 965 * @tc.name: WifiHalSetCountryCode002 966 * @tc.desc: Wifi hal set country code function test_02 967 * @tc.type: FUNC 968 */ 969HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_8300, Function | MediumTest | Level1) 970{ 971 int ret; 972 struct IWiFiAp *apFeature = nullptr; 973 974 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 975 EXPECT_EQ(HDF_SUCCESS, ret); 976 EXPECT_NE(nullptr, apFeature); 977 ret = apFeature->setCountryCode(nullptr, "CN", 2); 978 EXPECT_NE(ret, HDF_SUCCESS); 979 980 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 981 EXPECT_EQ(HDF_SUCCESS, ret); 982} 983 984/** 985 * @tc.name: WifiHalSetCountryCode003 986 * @tc.desc: Wifi hal set country code function test_03 987 * @tc.type: FUNC 988 */ 989HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_8400, Function | MediumTest | Level1) 990{ 991 int ret; 992 struct IWiFiAp *apFeature = nullptr; 993 994 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 995 EXPECT_EQ(HDF_SUCCESS, ret); 996 EXPECT_NE(nullptr, apFeature); 997 ret = apFeature->setCountryCode(apFeature, "CN", 3); 998 EXPECT_NE(ret, HDF_SUCCESS); 999 1000 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1001 EXPECT_EQ(HDF_SUCCESS, ret); 1002} 1003 1004/** 1005 * @tc.name: WifiHalSetCountryCode004 1006 * @tc.desc: Wifi hal set country code function test_04 1007 * @tc.type: FUNC 1008 */ 1009HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_8500, Function | MediumTest | Level1) 1010{ 1011 int ret; 1012 struct IWiFiAp *apFeature = nullptr; 1013 1014 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1015 EXPECT_EQ(HDF_SUCCESS, ret); 1016 EXPECT_NE(nullptr, apFeature); 1017 ret = apFeature->setCountryCode(apFeature, "99", 2); 1018 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 1019 ASSERT_TRUE(flag); 1020 1021 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1022 EXPECT_EQ(HDF_SUCCESS, ret); 1023} 1024 1025/** 1026 * @tc.name: WifiHalSetCountryCode005 1027 * @tc.desc: Wifi hal set country code function test_05 1028 * @tc.type: FUNC 1029 */ 1030HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_8600, Function | MediumTest | Level1) 1031{ 1032 int ret; 1033 struct IWiFiAp *apFeature = nullptr; 1034 1035 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1036 EXPECT_EQ(HDF_SUCCESS, ret); 1037 EXPECT_NE(nullptr, apFeature); 1038 ret = apFeature->setCountryCode(apFeature, "CN", 2); 1039 EXPECT_EQ(HDF_SUCCESS, ret); 1040 1041 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1042 EXPECT_EQ(HDF_SUCCESS, ret); 1043} 1044 1045/** 1046 * @tc.name: WifiHalGetIfNamesByChipId001 1047 * @tc.desc: Obtain all ifNames and the number of the current chip_01 1048 * @tc.type: FUNC 1049 */ 1050HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_1600, Function | MediumTest | Level1) 1051{ 1052 int ret; 1053 struct IWiFiSta *staFeature = nullptr; 1054 char *ifNames = nullptr; 1055 unsigned int num = 0; 1056 unsigned char chipId = 0; 1057 uint8_t i; 1058 1059 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1060 EXPECT_EQ(HDF_SUCCESS, ret); 1061 EXPECT_NE(nullptr, staFeature); 1062 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId); 1063 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE); 1064 EXPECT_EQ(HDF_SUCCESS, ret); 1065 ret = staFeature->baseFeature.getIfNamesByChipId(chipId, nullptr, nullptr); 1066 EXPECT_NE(HDF_SUCCESS, ret); 1067 ASSERT_TRUE(num <= IFNAME_MAX_NUM && num >= IFNAME_MIN_NUM); 1068 for (i = 0; i < num; i++) { 1069 EXPECT_EQ(0, strncmp("wlan", ifNames + i * MAX_IF_NAME_LENGTH, SIZE)); 1070 } 1071 free(ifNames); 1072 1073 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1074 EXPECT_EQ(HDF_SUCCESS, ret); 1075} 1076 1077 1078/** 1079 * @tc.name: WifiHalGetIfNamesByChipId002 1080 * @tc.desc: Obtain all ifNames and the number of the current chip_02 1081 * @tc.type: FUNC 1082 */ 1083HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_1700, Function | MediumTest | Level1) 1084{ 1085 int ret; 1086 struct IWiFiSta *staFeature = nullptr; 1087 char *ifNames = nullptr; 1088 unsigned int num = 0; 1089 unsigned char chipId = 0; 1090 uint8_t i; 1091 1092 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1093 EXPECT_EQ(HDF_SUCCESS, ret); 1094 EXPECT_NE(nullptr, staFeature); 1095 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId); 1096 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE); 1097 EXPECT_EQ(HDF_SUCCESS, ret); 1098 ret = staFeature->baseFeature.getIfNamesByChipId(100, &ifNames, &num); 1099 EXPECT_NE(ret, HDF_SUCCESS); 1100 ASSERT_TRUE(num <= IFNAME_MAX_NUM && num >= IFNAME_MIN_NUM); 1101 for (i = 0; i < num; i++) { 1102 EXPECT_EQ(0, strncmp("wlan", ifNames + i * MAX_IF_NAME_LENGTH, SIZE)); 1103 } 1104 free(ifNames); 1105 1106 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1107 EXPECT_EQ(HDF_SUCCESS, ret); 1108} 1109 1110/** 1111 * @tc.name: WifiHalGetIfNamesByChipId003 1112 * @tc.desc: Obtain all ifNames and the number of the current chip_03 1113 * @tc.type: FUNC 1114 */ 1115HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_1800, Function | MediumTest | Level1) 1116{ 1117 int ret; 1118 struct IWiFiSta *staFeature = nullptr; 1119 char *ifNames = nullptr; 1120 unsigned int num = 0; 1121 unsigned char chipId = 0; 1122 uint8_t i; 1123 1124 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1125 EXPECT_EQ(HDF_SUCCESS, ret); 1126 EXPECT_NE(nullptr, staFeature); 1127 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId); 1128 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE); 1129 EXPECT_EQ(HDF_SUCCESS, ret); 1130 ret = staFeature->baseFeature.getIfNamesByChipId(chipId, &ifNames, &num); 1131 EXPECT_NE(nullptr, ifNames); 1132 EXPECT_EQ(HDF_SUCCESS, ret); 1133 ASSERT_TRUE(num <= IFNAME_MAX_NUM && num >= IFNAME_MIN_NUM); 1134 for (i = 0; i < num; i++) { 1135 EXPECT_EQ(0, strncmp("wlan", ifNames + i * MAX_IF_NAME_LENGTH, SIZE)); 1136 } 1137 free(ifNames); 1138 1139 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1140 EXPECT_EQ(HDF_SUCCESS, ret); 1141} 1142 1143/** 1144 * @tc.name: WifiHalGetIfNamesByChipId004 1145 * @tc.desc: Obtain all ifNames and the number of the current chip_04 1146 * @tc.type: FUNC 1147 */ 1148HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_1900, Function | MediumTest | Level1) 1149{ 1150 int32_t ret; 1151 struct IWiFiAp *apFeature = nullptr; 1152 char *ifNames = nullptr; 1153 unsigned int num = 0; 1154 unsigned char chipId = 0; 1155 uint8_t i; 1156 1157 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1158 EXPECT_EQ(ret, HDF_SUCCESS); 1159 EXPECT_NE(apFeature, nullptr); 1160 ret = apFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)apFeature, &chipId); 1161 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE); 1162 EXPECT_EQ(ret, HDF_SUCCESS); 1163 ret = apFeature->baseFeature.getIfNamesByChipId(chipId, nullptr, nullptr); 1164 EXPECT_NE(ret, HDF_SUCCESS); 1165 1166 bool flag = (num <= IFNAME_MAX_NUM && num >= IFNAME_MIN_NUM); 1167 ASSERT_TRUE(flag); 1168 for (i = 0; i < num; i++) { 1169 EXPECT_EQ(0, strncmp("wlan", ifNames + i * MAX_IF_NAME_LENGTH, SIZE)); 1170 } 1171 free(ifNames); 1172 1173 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1174 EXPECT_EQ(ret, HDF_SUCCESS); 1175} 1176 1177/** 1178 * @tc.name: WifiHalGetIfNamesByChipId005 1179 * @tc.desc: Obtain all ifNames and the number of the current chip_05 1180 * @tc.type: FUNC 1181 */ 1182HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_2000, Function | MediumTest | Level1) 1183{ 1184 int32_t ret; 1185 struct IWiFiAp *apFeature = nullptr; 1186 char *ifNames = nullptr; 1187 unsigned int num = 0; 1188 unsigned char chipId = 0; 1189 uint8_t i; 1190 1191 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1192 EXPECT_EQ(ret, HDF_SUCCESS); 1193 EXPECT_NE(apFeature, nullptr); 1194 ret = apFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)apFeature, &chipId); 1195 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE); 1196 EXPECT_EQ(ret, HDF_SUCCESS); 1197 ret = apFeature->baseFeature.getIfNamesByChipId(100, &ifNames, &num); 1198 EXPECT_NE(ret, HDF_SUCCESS); 1199 1200 bool flag = (num <= IFNAME_MAX_NUM && num >= IFNAME_MIN_NUM); 1201 ASSERT_TRUE(flag); 1202 for (i = 0; i < num; i++) { 1203 EXPECT_EQ(0, strncmp("wlan", ifNames + i * MAX_IF_NAME_LENGTH, SIZE)); 1204 } 1205 free(ifNames); 1206 1207 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1208 EXPECT_EQ(ret, HDF_SUCCESS); 1209} 1210 1211/** 1212 * @tc.name: WifiHalGetIfNamesByChipId006 1213 * @tc.desc: Obtain all ifNames and the number of the current chip_06 1214 * @tc.type: FUNC 1215 */ 1216HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_2100, Function | MediumTest | Level1) 1217{ 1218 int32_t ret; 1219 struct IWiFiAp *apFeature = nullptr; 1220 char *ifNames = nullptr; 1221 unsigned int num = 0; 1222 unsigned char chipId = 0; 1223 uint8_t i; 1224 1225 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1226 EXPECT_EQ(ret, HDF_SUCCESS); 1227 EXPECT_NE(apFeature, nullptr); 1228 ret = apFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)apFeature, &chipId); 1229 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE); 1230 EXPECT_EQ(ret, HDF_SUCCESS); 1231 1232 ret = apFeature->baseFeature.getIfNamesByChipId(chipId, &ifNames, &num); 1233 EXPECT_NE(ifNames, nullptr); 1234 EXPECT_EQ(ret, HDF_SUCCESS); 1235 bool flag = (num <= IFNAME_MAX_NUM && num >= IFNAME_MIN_NUM); 1236 ASSERT_TRUE(flag); 1237 for (i = 0; i < num; i++) { 1238 EXPECT_EQ(0, strncmp("wlan", ifNames + i * MAX_IF_NAME_LENGTH, SIZE)); 1239 } 1240 free(ifNames); 1241 1242 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1243 EXPECT_EQ(ret, HDF_SUCCESS); 1244} 1245 1246/** 1247 * @tc.name: WifiHalGetSupportFeature001 1248 * @tc.desc: Get supported features_01 1249 * @tc.type: FUNC 1250 */ 1251HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_1300, Function | MediumTest | Level1) 1252{ 1253 int32_t ret; 1254 ret = g_wifi->getSupportFeature(nullptr, PROTOCOL_80211_IFTYPE_NUM + 1); 1255 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 1256} 1257 1258/** 1259 * @tc.name: WifiHalGetSupportFeature002 1260 * @tc.desc: Get supported features_02 1261 * @tc.type: FUNC 1262 */ 1263HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_1400, Function | MediumTest | Level1) 1264{ 1265 int32_t ret; 1266 uint8_t supType[PROTOCOL_80211_IFTYPE_NUM + 1] = {0}; 1267 ret = g_wifi->getSupportFeature(supType, PROTOCOL_80211_IFTYPE_NUM); 1268 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 1269} 1270 1271/** 1272 * @tc.name: WifiHalGetSupportFeature003 1273 * @tc.desc: Get supported features_03 1274 * @tc.type: FUNC 1275 */ 1276HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_1500, Function | MediumTest | Level1) 1277{ 1278 int32_t ret; 1279 uint8_t supType[PROTOCOL_80211_IFTYPE_NUM + 1] = {0}; 1280 1281 ret = g_wifi->getSupportFeature(supType, PROTOCOL_80211_IFTYPE_NUM + 1); 1282 EXPECT_EQ(ret, RET_CODE_SUCCESS); 1283} 1284 1285/** 1286 * @tc.name: HalGetChipId001 1287 * @tc.desc: wifi hal get chip ID function test_01 1288 * @tc.type: FUNC 1289 */ 1290HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_5100, Function | MediumTest | Level1) 1291{ 1292 int32_t ret; 1293 struct IWiFiAp *apFeature = nullptr; 1294 unsigned char chipId = 0; 1295 1296 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1297 EXPECT_EQ(ret, HDF_SUCCESS); 1298 EXPECT_NE(apFeature, nullptr); 1299 ret = apFeature->baseFeature.getChipId(nullptr, &chipId); 1300 EXPECT_NE(ret, HDF_SUCCESS); 1301 1302 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1303 EXPECT_EQ(ret, HDF_SUCCESS); 1304} 1305 1306/** 1307 * @tc.name: HalGetChipId002 1308 * @tc.desc: wifi hal get chip ID function test_02 1309 * @tc.type: FUNC 1310 */ 1311HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_5200, Function | MediumTest | Level1) 1312{ 1313 int32_t ret; 1314 struct IWiFiAp *apFeature = nullptr; 1315 1316 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1317 EXPECT_EQ(ret, HDF_SUCCESS); 1318 EXPECT_NE(apFeature, nullptr); 1319 ret = apFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)apFeature, nullptr); 1320 EXPECT_NE(ret, HDF_SUCCESS); 1321 1322 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1323 EXPECT_EQ(ret, HDF_SUCCESS); 1324} 1325 1326/** 1327 * @tc.name: HalGetChipId003 1328 * @tc.desc: wifi hal get chip ID function test_03 1329 * @tc.type: FUNC 1330 */ 1331HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_5300, Function | MediumTest | Level1) 1332{ 1333 int32_t ret; 1334 struct IWiFiAp *apFeature = nullptr; 1335 unsigned char chipId = 0; 1336 1337 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1338 EXPECT_EQ(ret, HDF_SUCCESS); 1339 EXPECT_NE(apFeature, nullptr); 1340 ret = apFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)apFeature, &chipId); 1341 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE); 1342 EXPECT_EQ(ret, HDF_SUCCESS); 1343 1344 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1345 EXPECT_EQ(ret, HDF_SUCCESS); 1346} 1347 1348/** 1349 * @tc.name: HalGetChipId004 1350 * @tc.desc: wifi hal get chip ID function test_04 1351 * @tc.type: FUNC 1352 */ 1353HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_5400, Function | MediumTest | Level1) 1354{ 1355 int32_t ret; 1356 struct IWiFiSta *staFeature = nullptr; 1357 unsigned char chipId = 0; 1358 1359 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1360 EXPECT_EQ(ret, HDF_SUCCESS); 1361 EXPECT_NE(staFeature, nullptr); 1362 ret = staFeature->baseFeature.getChipId(nullptr, &chipId); 1363 EXPECT_NE(ret, HDF_SUCCESS); 1364 1365 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1366 EXPECT_EQ(ret, HDF_SUCCESS); 1367} 1368 1369/** 1370 * @tc.name: HalGetChipId005 1371 * @tc.desc: wifi hal get chip ID function test_05 1372 * @tc.type: FUNC 1373 */ 1374HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_5500, Function | MediumTest | Level1) 1375{ 1376 int32_t ret; 1377 struct IWiFiSta *staFeature = nullptr; 1378 1379 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1380 EXPECT_EQ(ret, HDF_SUCCESS); 1381 EXPECT_NE(staFeature, nullptr); 1382 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, nullptr); 1383 EXPECT_NE(ret, HDF_SUCCESS); 1384 1385 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1386 EXPECT_EQ(ret, HDF_SUCCESS); 1387} 1388 1389/** 1390 * @tc.name: HalGetChipId006 1391 * @tc.desc: wifi hal get chip ID function test_06 1392 * @tc.type: FUNC 1393 */ 1394HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_5600, Function | MediumTest | Level1) 1395{ 1396 int32_t ret; 1397 struct IWiFiSta *staFeature = nullptr; 1398 unsigned char chipId = 0; 1399 1400 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1401 EXPECT_EQ(ret, HDF_SUCCESS); 1402 EXPECT_NE(staFeature, nullptr); 1403 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId); 1404 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE); 1405 EXPECT_EQ(ret, HDF_SUCCESS); 1406 1407 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1408 EXPECT_EQ(ret, HDF_SUCCESS); 1409} 1410 1411/** 1412 * @tc.name: WifiHalGetDeviceMacAddress001 1413 * @tc.desc: Get device Mac address for ap mode_01 1414 * @tc.type: FUNC 1415 */ 1416HWTEST_F(WifiHalTest, SUB_Driver_Wlan_GetDeviceMACaddress_0100, Function | MediumTest | Level1) 1417{ 1418 int32_t ret; 1419 struct IWiFiAp *apFeature = nullptr; 1420 1421 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1422 EXPECT_EQ(ret, HDF_SUCCESS); 1423 EXPECT_NE(apFeature, nullptr); 1424 1425 unsigned char readMac[ETH_ADDR_LEN] = {0}; 1426 ret = apFeature->baseFeature.getDeviceMacAddress(nullptr, readMac, ETH_ADDR_LEN); 1427 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 1428 1429 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1430 EXPECT_EQ(ret, HDF_SUCCESS); 1431} 1432 1433/** 1434 * @tc.name: WifiHalGetDeviceMacAddress002 1435 * @tc.desc: Get device Mac address for ap mode_02 1436 * @tc.type: FUNC 1437 */ 1438HWTEST_F(WifiHalTest, SUB_Driver_Wlan_GetDeviceMACaddress_0200, Function | MediumTest | Level1) 1439{ 1440 int32_t ret; 1441 struct IWiFiAp *apFeature = nullptr; 1442 1443 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1444 EXPECT_EQ(ret, HDF_SUCCESS); 1445 EXPECT_NE(apFeature, nullptr); 1446 1447 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, nullptr, 0); 1448 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 1449 1450 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1451 EXPECT_EQ(ret, HDF_SUCCESS); 1452} 1453 1454/** 1455 * @tc.name: WifiHalGetDeviceMacAddress003 1456 * @tc.desc: Get device Mac address for ap mode_03 1457 * @tc.type: FUNC 1458 */ 1459HWTEST_F(WifiHalTest, SUB_Driver_Wlan_GetDeviceMACaddress_0300, Function | MediumTest | Level1) 1460{ 1461 int32_t ret; 1462 struct IWiFiAp *apFeature = nullptr; 1463 1464 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1465 EXPECT_EQ(ret, HDF_SUCCESS); 1466 EXPECT_NE(apFeature, nullptr); 1467 1468 unsigned char readMac[ETH_ADDR_LEN] = {0}; 1469 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, readMac, 0); 1470 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 1471 1472 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1473 EXPECT_EQ(ret, HDF_SUCCESS); 1474} 1475 1476/** 1477 * @tc.name: WifiHalGetDeviceMacAddress004 1478 * @tc.desc: Get device Mac address for ap mode_04 1479 * @tc.type: FUNC 1480 */ 1481HWTEST_F(WifiHalTest, SUB_Driver_Wlan_GetDeviceMACaddress_0400, Function | MediumTest | Level1) 1482{ 1483 int32_t ret; 1484 struct IWiFiAp *apFeature = nullptr; 1485 1486 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1487 EXPECT_EQ(ret, HDF_SUCCESS); 1488 EXPECT_NE(apFeature, nullptr); 1489 1490 unsigned char readMac[ETH_ADDR_LEN] = {0}; 1491 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, readMac, ETH_ADDR_LEN); 1492 EXPECT_EQ(ret, HDF_SUCCESS); 1493 1494 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1495 EXPECT_EQ(ret, HDF_SUCCESS); 1496} 1497 1498/** 1499 * @tc.name: WifiHalGetDeviceMacAddress005 1500 * @tc.desc: Get device Mac address for sta mode_05 1501 * @tc.type: FUNC 1502 */ 1503HWTEST_F(WifiHalTest, SUB_Driver_Wlan_GetDeviceMACaddress_0500, Function | MediumTest | Level1) 1504{ 1505 int32_t ret; 1506 struct IWiFiSta *staFeature = nullptr; 1507 1508 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1509 EXPECT_EQ(ret, HDF_SUCCESS); 1510 EXPECT_NE(staFeature, nullptr); 1511 1512 unsigned char readMac[ETH_ADDR_LEN] = {0}; 1513 ret = staFeature->baseFeature.getDeviceMacAddress(nullptr, readMac, ETH_ADDR_LEN); 1514 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 1515 1516 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1517 EXPECT_EQ(ret, HDF_SUCCESS); 1518} 1519 1520/** 1521 * @tc.name: WifiHalGetDeviceMacAddress006 1522 * @tc.desc: Get device Mac address for sta mode_06 1523 * @tc.type: FUNC 1524 */ 1525HWTEST_F(WifiHalTest, SUB_Driver_Wlan_GetDeviceMACaddress_0600, Function | MediumTest | Level1) 1526{ 1527 int32_t ret; 1528 struct IWiFiSta *staFeature = nullptr; 1529 1530 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1531 EXPECT_EQ(ret, HDF_SUCCESS); 1532 EXPECT_NE(staFeature, nullptr); 1533 1534 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, nullptr, 0); 1535 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 1536 1537 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1538 EXPECT_EQ(ret, HDF_SUCCESS); 1539} 1540 1541/** 1542 * @tc.name: WifiHalGetDeviceMacAddress007 1543 * @tc.desc: Get device Mac address for sta mode_07 1544 * @tc.type: FUNC 1545 */ 1546HWTEST_F(WifiHalTest, SUB_Driver_Wlan_GetDeviceMACaddress_0700, Function | MediumTest | Level1) 1547{ 1548 int32_t ret; 1549 struct IWiFiSta *staFeature = nullptr; 1550 1551 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1552 EXPECT_EQ(ret, HDF_SUCCESS); 1553 EXPECT_NE(staFeature, nullptr); 1554 1555 unsigned char readMac[ETH_ADDR_LEN] = {0}; 1556 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, readMac, 0); 1557 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 1558 1559 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1560 EXPECT_EQ(ret, HDF_SUCCESS); 1561} 1562 1563/** 1564 * @tc.name: WifiHalGetDeviceMacAddress008 1565 * @tc.desc: Get device Mac address for sta mode_08 1566 * @tc.type: FUNC 1567 */ 1568HWTEST_F(WifiHalTest, SUB_Driver_Wlan_GetDeviceMACaddress_0800, Function | MediumTest | Level1) 1569{ 1570 int32_t ret; 1571 struct IWiFiSta *staFeature = nullptr; 1572 1573 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1574 EXPECT_EQ(ret, HDF_SUCCESS); 1575 EXPECT_NE(staFeature, nullptr); 1576 1577 unsigned char readMac[ETH_ADDR_LEN] = {0}; 1578 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, readMac, ETH_ADDR_LEN); 1579 EXPECT_EQ(ret, HDF_SUCCESS); 1580 1581 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1582 EXPECT_EQ(ret, HDF_SUCCESS); 1583} 1584 1585/** 1586 * @tc.name: WifiHaGetValidFreqsWithBand001 1587 * @tc.desc: Get available frequencies_01 1588 * @tc.type: FUNC 1589 */ 1590HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_0600, Function | MediumTest | Level1) 1591{ 1592 int32_t ret; 1593 struct IWiFiSta *staFeature = nullptr; 1594 int32_t band = IEEE80211_BAND_2GHZ; 1595 int32_t freqs[MAX_CHANNEL_NUM] = {0}; 1596 uint32_t size = MAX_CHANNEL_NUM; 1597 uint32_t num = 0; 1598 1599 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1600 EXPECT_EQ(ret, HDF_SUCCESS); 1601 EXPECT_NE(staFeature, nullptr); 1602 ret = staFeature->baseFeature.getValidFreqsWithBand(nullptr, band, freqs, size, &num); 1603 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 1604 1605 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1606 EXPECT_EQ(ret, HDF_SUCCESS); 1607} 1608 1609/** 1610 * @tc.name: WifiHaGetValidFreqsWithBand002 1611 * @tc.desc: Get available frequencies_02 1612 * @tc.type: FUNC 1613 */ 1614HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_0700, Function | MediumTest | Level1) 1615{ 1616 int32_t ret; 1617 struct IWiFiSta *staFeature = nullptr; 1618 int32_t band = IEEE80211_BAND_2GHZ; 1619 int32_t freqs[MAX_CHANNEL_NUM] = {0}; 1620 uint32_t size = MAX_CHANNEL_NUM; 1621 uint32_t num = 0; 1622 1623 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1624 EXPECT_EQ(ret, HDF_SUCCESS); 1625 EXPECT_NE(staFeature, nullptr); 1626 ret = staFeature->baseFeature.getValidFreqsWithBand(nullptr, band, freqs, size, &num); 1627 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 1628 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature, 1629 band, nullptr, size, &num); 1630 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 1631 1632 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1633 EXPECT_EQ(ret, HDF_SUCCESS); 1634} 1635 1636/** 1637 * @tc.name: WifiHaGetValidFreqsWithBand003 1638 * @tc.desc: Get available frequencies_03 1639 * @tc.type: FUNC 1640 */ 1641HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_0800, Function | MediumTest | Level1) 1642{ 1643 int32_t ret; 1644 struct IWiFiSta *staFeature = nullptr; 1645 int32_t band = IEEE80211_BAND_2GHZ; 1646 int32_t freqs[MAX_CHANNEL_NUM] = {0}; 1647 uint32_t num = 0; 1648 1649 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1650 EXPECT_EQ(ret, HDF_SUCCESS); 1651 EXPECT_NE(staFeature, nullptr); 1652 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature, band, freqs, 10, &num); 1653 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 1654 1655 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1656 EXPECT_EQ(ret, HDF_SUCCESS); 1657} 1658 1659/** 1660 * @tc.name: WifiHaGetValidFreqsWithBand004 1661 * @tc.desc: Get available frequencies_04 1662 * @tc.type: FUNC 1663 */ 1664HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_0900, Function | MediumTest | Level1) 1665{ 1666 int32_t ret; 1667 struct IWiFiSta *staFeature = nullptr; 1668 int32_t band = IEEE80211_BAND_2GHZ; 1669 int32_t freqs[MAX_CHANNEL_NUM] = {0}; 1670 uint32_t size = MAX_CHANNEL_NUM; 1671 1672 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1673 EXPECT_EQ(ret, HDF_SUCCESS); 1674 EXPECT_NE(staFeature, nullptr); 1675 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature, 1676 band, freqs, size, nullptr); 1677 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 1678 1679 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1680 EXPECT_EQ(ret, HDF_SUCCESS); 1681} 1682 1683/** 1684 * @tc.name: WifiHaGetValidFreqsWithBand005 1685 * @tc.desc: Get available frequencies_05 1686 * @tc.type: FUNC 1687 */ 1688HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_1000, Function | MediumTest | Level1) 1689{ 1690 int32_t ret; 1691 struct IWiFiSta *staFeature = nullptr; 1692 int32_t bandNotSupport = IEEE80211_NUM_BANDS; 1693 int32_t freqs[MAX_CHANNEL_NUM] = {0}; 1694 uint32_t size = MAX_CHANNEL_NUM; 1695 uint32_t num = 0; 1696 1697 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1698 EXPECT_EQ(ret, HDF_SUCCESS); 1699 EXPECT_NE(staFeature, nullptr); 1700 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature, 1701 bandNotSupport, freqs, size, &num); 1702 EXPECT_NE(ret, HDF_SUCCESS); 1703 1704 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1705 EXPECT_EQ(ret, HDF_SUCCESS); 1706} 1707 1708/** 1709 * @tc.name: WifiHaGetValidFreqsWithBand006 1710 * @tc.desc: Get available frequencies_06 1711 * @tc.type: FUNC 1712 */ 1713HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_1100, Function | MediumTest | Level1) 1714{ 1715 int32_t ret; 1716 struct IWiFiSta *staFeature = nullptr; 1717 int32_t band = IEEE80211_BAND_2GHZ; 1718 int32_t freqs[MAX_CHANNEL_NUM] = {0}; 1719 uint32_t size = MAX_CHANNEL_NUM; 1720 uint32_t num = 0; 1721 1722 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1723 EXPECT_EQ(ret, HDF_SUCCESS); 1724 EXPECT_NE(staFeature, nullptr); 1725 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature, 1726 band, freqs, size, &num); 1727 EXPECT_EQ(ret, HDF_SUCCESS); 1728 1729 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1730 EXPECT_EQ(ret, HDF_SUCCESS); 1731} 1732 1733/** 1734 * @tc.name: GetValidFreqsWithBand007 1735 * @tc.desc: Wifi hal get valid frequency with specific band test_07 1736 * @tc.type: FUNC 1737 */ 1738HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_6500, Function | MediumTest | Level1) 1739{ 1740 int32_t ret; 1741 struct IWiFiAp *apFeature = nullptr; 1742 int32_t band = IEEE80211_BAND_2GHZ; 1743 int32_t freqs[MAX_CHANNEL_NUM] = {0}; 1744 uint32_t size = MAX_CHANNEL_NUM; 1745 uint32_t num = 0; 1746 1747 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1748 EXPECT_EQ(ret, HDF_SUCCESS); 1749 EXPECT_NE(apFeature, nullptr); 1750 ret = apFeature->baseFeature.getValidFreqsWithBand(nullptr, band, freqs, size, &num); 1751 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 1752 1753 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1754 EXPECT_EQ(ret, HDF_SUCCESS); 1755} 1756 1757/** 1758 * @tc.name: GetValidFreqsWithBand008 1759 * @tc.desc: Wifi hal get valid frequency with specific band test_08 1760 * @tc.type: FUNC 1761 */ 1762HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_6600, Function | MediumTest | Level1) 1763{ 1764 int32_t ret; 1765 struct IWiFiAp *apFeature = nullptr; 1766 int32_t band = IEEE80211_BAND_2GHZ; 1767 uint32_t size = MAX_CHANNEL_NUM; 1768 uint32_t num = 0; 1769 1770 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1771 EXPECT_EQ(ret, HDF_SUCCESS); 1772 EXPECT_NE(apFeature, nullptr); 1773 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature, band, nullptr, size, &num); 1774 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 1775 1776 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1777 EXPECT_EQ(ret, HDF_SUCCESS); 1778} 1779 1780/** 1781 * @tc.name: GetValidFreqsWithBand009 1782 * @tc.desc: Wifi hal get valid frequency with specific band test_09 1783 * @tc.type: FUNC 1784 */ 1785HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_6700, Function | MediumTest | Level1) 1786{ 1787 int32_t ret; 1788 struct IWiFiAp *apFeature = nullptr; 1789 int32_t band = IEEE80211_BAND_2GHZ; 1790 int32_t freqs[MAX_CHANNEL_NUM] = {0}; 1791 uint32_t num = 0; 1792 1793 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1794 EXPECT_EQ(ret, HDF_SUCCESS); 1795 EXPECT_NE(apFeature, nullptr); 1796 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature, band, freqs, 10, &num); 1797 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 1798 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1799 EXPECT_EQ(ret, HDF_SUCCESS); 1800} 1801 1802/** 1803 * @tc.name: GetValidFreqsWithBand010 1804 * @tc.desc: Wifi hal get valid frequency with specific band test_10 1805 * @tc.type: FUNC 1806 */ 1807HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_6800, Function | MediumTest | Level1) 1808{ 1809 int32_t ret; 1810 struct IWiFiAp *apFeature = nullptr; 1811 int32_t band = IEEE80211_BAND_2GHZ; 1812 int32_t freqs[MAX_CHANNEL_NUM] = {0}; 1813 uint32_t size = MAX_CHANNEL_NUM; 1814 1815 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1816 EXPECT_EQ(ret, HDF_SUCCESS); 1817 EXPECT_NE(apFeature, nullptr); 1818 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature, 1819 band, freqs, size, nullptr); 1820 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 1821 1822 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1823 EXPECT_EQ(ret, HDF_SUCCESS); 1824} 1825 1826/** 1827 * @tc.name: GetValidFreqsWithBand011 1828 * @tc.desc: Wifi hal get valid frequency with specific band test_11 1829 * @tc.type: FUNC 1830 */ 1831HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_6900, Function | MediumTest | Level1) 1832{ 1833 int32_t ret; 1834 struct IWiFiAp *apFeature = nullptr; 1835 int32_t bandNotSupport = IEEE80211_NUM_BANDS; 1836 int32_t freqs[MAX_CHANNEL_NUM] = {0}; 1837 uint32_t size = MAX_CHANNEL_NUM; 1838 uint32_t num = 0; 1839 1840 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1841 EXPECT_EQ(ret, HDF_SUCCESS); 1842 EXPECT_NE(apFeature, nullptr); 1843 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature, 1844 bandNotSupport, freqs, size, &num); 1845 EXPECT_NE(ret, HDF_SUCCESS); 1846 1847 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1848 EXPECT_EQ(ret, HDF_SUCCESS); 1849} 1850 1851/** 1852 * @tc.name: GetValidFreqsWithBand012 1853 * @tc.desc: Wifi hal get valid frequency with specific band test_12 1854 * @tc.type: FUNC 1855 */ 1856HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_7000, Function | MediumTest | Level1) 1857{ 1858 int32_t ret; 1859 struct IWiFiAp *apFeature = nullptr; 1860 int32_t band = IEEE80211_BAND_2GHZ; 1861 int32_t freqs[MAX_CHANNEL_NUM] = {0}; 1862 uint32_t size = MAX_CHANNEL_NUM; 1863 uint32_t num = 0; 1864 1865 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1866 EXPECT_EQ(ret, HDF_SUCCESS); 1867 EXPECT_NE(apFeature, nullptr); 1868 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature, band, freqs, size, &num); 1869 EXPECT_EQ(ret, HDF_SUCCESS); 1870 1871 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1872 EXPECT_EQ(ret, HDF_SUCCESS); 1873} 1874 1875/** 1876 * @tc.name: WifiHalGetAssociatedStas001 1877 * @tc.desc: Get asscociated STA info_01 1878 * @tc.type: FUNC 1879 */ 1880HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_0100, Function | MediumTest | Level1) 1881{ 1882 int32_t ret; 1883 struct IWiFiAp *apFeature = nullptr; 1884 struct StaInfo staInfo[MAX_ASSOC_STA_NUM]; 1885 (void)memset_s(staInfo, sizeof(StaInfo) * MAX_ASSOC_STA_NUM, 0, sizeof(StaInfo) * MAX_ASSOC_STA_NUM); 1886 uint32_t num = 0; 1887 1888 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1889 EXPECT_EQ(ret, HDF_SUCCESS); 1890 EXPECT_NE(apFeature, nullptr); 1891 ret = apFeature->getAssociatedStas(nullptr, staInfo, MAX_ASSOC_STA_NUM, &num); 1892 EXPECT_NE(ret, HDF_SUCCESS); 1893 1894 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1895 EXPECT_EQ(ret, HDF_SUCCESS); 1896} 1897 1898/** 1899 * @tc.name: WifiHalGetAssociatedStas002 1900 * @tc.desc: Get asscociated STA info_02 1901 * @tc.type: FUNC 1902 */ 1903HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_0200, Function | MediumTest | Level1) 1904{ 1905 int32_t ret; 1906 struct IWiFiAp *apFeature = nullptr; 1907 struct StaInfo staInfo[MAX_ASSOC_STA_NUM]; 1908 (void)memset_s(staInfo, sizeof(StaInfo) * MAX_ASSOC_STA_NUM, 0, sizeof(StaInfo) * MAX_ASSOC_STA_NUM); 1909 uint32_t num = 0; 1910 1911 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1912 EXPECT_EQ(ret, HDF_SUCCESS); 1913 EXPECT_NE(apFeature, nullptr); 1914 ret = apFeature->getAssociatedStas(apFeature, nullptr, MAX_ASSOC_STA_NUM, &num); 1915 EXPECT_NE(ret, HDF_SUCCESS); 1916 1917 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1918 EXPECT_EQ(ret, HDF_SUCCESS); 1919} 1920 1921/** 1922 * @tc.name: WifiHalGetAssociatedStas003 1923 * @tc.desc: Get asscociated STA info_03 1924 * @tc.type: FUNC 1925 */ 1926HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_0300, Function | MediumTest | Level1) 1927{ 1928 int32_t ret; 1929 struct IWiFiAp *apFeature = nullptr; 1930 struct StaInfo staInfo[MAX_ASSOC_STA_NUM]; 1931 (void)memset_s(staInfo, sizeof(StaInfo) * MAX_ASSOC_STA_NUM, 0, sizeof(StaInfo) * MAX_ASSOC_STA_NUM); 1932 uint32_t num = 0; 1933 1934 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1935 EXPECT_EQ(ret, HDF_SUCCESS); 1936 EXPECT_NE(apFeature, nullptr); 1937 ret = apFeature->getAssociatedStas(apFeature, staInfo, 0, &num); 1938 EXPECT_NE(ret, HDF_SUCCESS); 1939 1940 1941 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1942 EXPECT_EQ(ret, HDF_SUCCESS); 1943} 1944 1945/** 1946 * @tc.name: WifiHalGetAssociatedStas004 1947 * @tc.desc: Get asscociated STA info_04 1948 * @tc.type: FUNC 1949 */ 1950HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_0400, Function | MediumTest | Level1) 1951{ 1952 int32_t ret; 1953 struct IWiFiAp *apFeature = nullptr; 1954 struct StaInfo staInfo[MAX_ASSOC_STA_NUM]; 1955 (void)memset_s(staInfo, sizeof(StaInfo) * MAX_ASSOC_STA_NUM, 0, sizeof(StaInfo) * MAX_ASSOC_STA_NUM); 1956 1957 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1958 EXPECT_EQ(ret, HDF_SUCCESS); 1959 EXPECT_NE(apFeature, nullptr); 1960 ret = apFeature->getAssociatedStas(apFeature, staInfo, MAX_ASSOC_STA_NUM, nullptr); 1961 EXPECT_NE(ret, HDF_SUCCESS); 1962 1963 1964 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1965 EXPECT_EQ(ret, HDF_SUCCESS); 1966} 1967 1968/** 1969 * @tc.name: WifiHalGetAssociatedStas005 1970 * @tc.desc: Get asscociated STA info_05 1971 * @tc.type: FUNC 1972 */ 1973HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_0500, Function | MediumTest | Level1) 1974{ 1975 int32_t ret; 1976 struct IWiFiAp *apFeature = nullptr; 1977 struct StaInfo staInfo[MAX_ASSOC_STA_NUM]; 1978 (void)memset_s(staInfo, sizeof(StaInfo) * MAX_ASSOC_STA_NUM, 0, sizeof(StaInfo) * MAX_ASSOC_STA_NUM); 1979 uint32_t num = 0; 1980 1981 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 1982 EXPECT_EQ(ret, HDF_SUCCESS); 1983 EXPECT_NE(apFeature, nullptr); 1984 ret = apFeature->getAssociatedStas(apFeature, staInfo, MAX_ASSOC_STA_NUM, &num); 1985 EXPECT_EQ(ret, HDF_SUCCESS); 1986 1987 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 1988 EXPECT_EQ(ret, HDF_SUCCESS); 1989} 1990 1991/** 1992 * @tc.name: WifiHalSetScanningMacAddress001 1993 * @tc.desc: Set Mac address scanning_01 1994 * @tc.type: FUNC 1995 */ 1996HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SetDeviceMACaddress_0100, Function | MediumTest | Level1) 1997{ 1998 int32_t ret; 1999 struct IWiFiSta *staFeature = nullptr; 2000 unsigned char scanMac[WIFI_MAC_ADDR_LENGTH] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd}; 2001 2002 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2003 EXPECT_EQ(ret, HDF_SUCCESS); 2004 EXPECT_NE(staFeature, nullptr); 2005 ret = staFeature->setScanningMacAddress(nullptr, scanMac, WIFI_MAC_ADDR_LENGTH); 2006 EXPECT_NE(ret, HDF_SUCCESS); 2007 2008 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2009 EXPECT_EQ(ret, HDF_SUCCESS); 2010} 2011 2012/** 2013 * @tc.name: WifiHalSetScanningMacAddress002 2014 * @tc.desc: Set Mac address scanning_02 2015 * @tc.type: FUNC 2016 */ 2017HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SetDeviceMACaddress_0200, Function | MediumTest | Level1) 2018{ 2019 int32_t ret; 2020 struct IWiFiSta *staFeature = nullptr; 2021 2022 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2023 EXPECT_EQ(ret, HDF_SUCCESS); 2024 EXPECT_NE(staFeature, nullptr); 2025 ret = staFeature->setScanningMacAddress(staFeature, nullptr, WIFI_MAC_ADDR_LENGTH); 2026 EXPECT_NE(ret, HDF_SUCCESS); 2027 2028 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2029 EXPECT_EQ(ret, HDF_SUCCESS); 2030} 2031 2032/** 2033 * @tc.name: WifiHalSetScanningMacAddress003 2034 * @tc.desc: Set Mac address scanning_03 2035 * @tc.type: FUNC 2036 */ 2037HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SetDeviceMACaddress_0300, Function | MediumTest | Level1) 2038{ 2039 int32_t ret; 2040 struct IWiFiSta *staFeature = nullptr; 2041 unsigned char scanMac[WIFI_MAC_ADDR_LENGTH] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd}; 2042 2043 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2044 EXPECT_EQ(ret, HDF_SUCCESS); 2045 EXPECT_NE(staFeature, nullptr); 2046 ret = staFeature->setScanningMacAddress(staFeature, scanMac, 0); 2047 EXPECT_NE(ret, HDF_SUCCESS); 2048 2049 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2050 EXPECT_EQ(ret, HDF_SUCCESS); 2051} 2052 2053/** 2054 * @tc.name: WifiHalSetScanningMacAddress004 2055 * @tc.desc: Set Mac address scanning_04 2056 * @tc.type: FUNC 2057 */ 2058HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SetDeviceMACaddress_0400, Function | MediumTest | Level1) 2059{ 2060 int32_t ret; 2061 struct IWiFiSta *staFeature = nullptr; 2062 unsigned char scanMac[WIFI_MAC_ADDR_LENGTH] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd}; 2063 2064 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2065 EXPECT_EQ(ret, HDF_SUCCESS); 2066 EXPECT_NE(staFeature, nullptr); 2067 ret = staFeature->setScanningMacAddress(staFeature, scanMac, WIFI_MAC_ADDR_LENGTH); 2068 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 2069 ASSERT_TRUE(flag); 2070 2071 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2072 EXPECT_EQ(ret, HDF_SUCCESS); 2073} 2074 2075/** 2076 * @tc.name: WifiHalGetNetDevInfo001 2077 * @tc.desc: Wifi hdi get netdev info function test_01 2078 * @tc.type: FUNC 2079 */ 2080HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_9600, Function | MediumTest | Level1) 2081{ 2082 int ret; 2083 struct IWiFiAp *apFeature = nullptr; 2084 2085 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2086 EXPECT_EQ(HDF_SUCCESS, ret); 2087 EXPECT_NE(nullptr, apFeature); 2088 ret = g_wifi->getNetDevInfo(nullptr); 2089 EXPECT_NE(HDF_SUCCESS, ret); 2090 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2091 EXPECT_EQ(HDF_SUCCESS, ret); 2092} 2093 2094/** 2095 * @tc.name: WifiHalGetNetDevInfo002 2096 * @tc.desc: Wifi hdi get netdev info function test_02 2097 * @tc.type: FUNC 2098 */ 2099HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_9700, Function | MediumTest | Level1) 2100{ 2101 int ret; 2102 struct IWiFiAp *apFeature = nullptr; 2103 struct NetDeviceInfoResult netDeviceInfoResult; 2104 2105 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2106 EXPECT_EQ(HDF_SUCCESS, ret); 2107 EXPECT_NE(nullptr, apFeature); 2108 ret = g_wifi->getNetDevInfo(&netDeviceInfoResult); 2109 EXPECT_EQ(HDF_SUCCESS, ret); 2110 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2111 EXPECT_EQ(HDF_SUCCESS, ret); 2112} 2113 2114/** 2115 * @tc.name: WifiHalStartScan001 2116 * @tc.desc: start scan is successfully_01 2117 * @tc.type: FUNC 2118 */ 2119HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_2400, Function | MediumTest | Level3) 2120{ 2121 int ret; 2122 struct IWiFiSta *staFeature = nullptr; 2123 const char *ifName = "wlan0"; 2124 WifiScan scan = {0}; 2125 2126 ret = g_wifi->registerEventCallback(HalCallbackEvent, ifName); 2127 EXPECT_EQ(HDF_SUCCESS, ret); 2128 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2129 EXPECT_EQ(HDF_SUCCESS, ret); 2130 EXPECT_NE(nullptr, staFeature); 2131 ret = staFeature->startScan(nullptr, &scan); 2132 EXPECT_NE(ret, HDF_SUCCESS); 2133 sleep(10); 2134} 2135 2136/** 2137 * @tc.name: WifiHalStartScan002 2138 * @tc.desc: start scan is successfully_02 2139 * @tc.type: FUNC 2140 */ 2141HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_2500, Function | MediumTest | Level3) 2142{ 2143 int ret; 2144 struct IWiFiSta *staFeature = nullptr; 2145 const char *ifName = "wlan0"; 2146 2147 ret = g_wifi->registerEventCallback(HalCallbackEvent, ifName); 2148 EXPECT_EQ(HDF_SUCCESS, ret); 2149 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2150 EXPECT_EQ(HDF_SUCCESS, ret); 2151 EXPECT_NE(nullptr, staFeature); 2152 ret = staFeature->startScan(ifName, nullptr); 2153 EXPECT_NE(ret, HDF_SUCCESS); 2154 sleep(10); 2155} 2156 2157/** 2158 * @tc.name: WifiHalStartScan003 2159 * @tc.desc: start scan is successfully_03 2160 * @tc.type: FUNC 2161 */ 2162HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_2600, Function | MediumTest | Level3) 2163{ 2164 int ret; 2165 struct IWiFiSta *staFeature = nullptr; 2166 const char *ifName = "wlan0"; 2167 WifiScan scan = {0}; 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 EXPECT_EQ(HDF_SUCCESS, ret); 2173 EXPECT_NE(nullptr, staFeature); 2174 ret = staFeature->startScan(ifName, &scan); 2175 EXPECT_EQ(HDF_SUCCESS, ret); 2176 sleep(10); 2177} 2178 2179/** 2180 * @tc.name: GetPowerModeTest_001 2181 * @tc.desc: Wifi hdi get power mode function test_01 2182 * @tc.type: FUNC 2183 */ 2184HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SgetPowerMode_0100, Function | MediumTest | Level1) 2185{ 2186 int32_t ret; 2187 struct IWiFiAp *apFeature = nullptr; 2188 uint8_t mode; 2189 2190 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2191 EXPECT_EQ(ret, HDF_SUCCESS); 2192 EXPECT_NE(apFeature, nullptr); 2193 printf("GetPowerMode001: ifname is %s\n", apFeature->baseFeature.ifName); 2194 ret = g_wifi->getPowerMode(nullptr, &mode); 2195 EXPECT_NE(ret, HDF_SUCCESS); 2196 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2197 EXPECT_EQ(ret, HDF_SUCCESS); 2198} 2199 2200/** 2201 * @tc.name: GetPowerModeTest_002 2202 * @tc.desc: Wifi hdi get power mode function test_02 2203 * @tc.type: FUNC 2204 */ 2205HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SgetPowerMode_0200, Function | MediumTest | Level1) 2206{ 2207 int32_t ret; 2208 struct IWiFiAp *apFeature = nullptr; 2209 const char *ifName = "eth0"; 2210 2211 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2212 EXPECT_EQ(ret, HDF_SUCCESS); 2213 EXPECT_NE(apFeature, nullptr); 2214 printf("GetPowerMode001: ifname is %s\n", apFeature->baseFeature.ifName); 2215 ret = g_wifi->getPowerMode(ifName, nullptr); 2216 EXPECT_NE(ret, HDF_SUCCESS); 2217 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2218 EXPECT_EQ(ret, HDF_SUCCESS); 2219} 2220 2221/** 2222 * @tc.name: GetPowerModeTest_003 2223 * @tc.desc: Wifi hdi get power mode function test_03 2224 * @tc.type: FUNC 2225 */ 2226HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SgetPowerMode_0300, Function | MediumTest | Level1) 2227{ 2228 int32_t ret; 2229 struct IWiFiAp *apFeature = nullptr; 2230 const char *ifName = "eth0"; 2231 uint8_t mode; 2232 2233 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2234 EXPECT_EQ(ret, HDF_SUCCESS); 2235 EXPECT_NE(apFeature, nullptr); 2236 printf("GetPowerMode001: ifname is %s\n", apFeature->baseFeature.ifName); 2237 ret = g_wifi->getPowerMode(ifName, &mode); 2238 EXPECT_NE(ret, HDF_SUCCESS); 2239 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2240 EXPECT_EQ(ret, HDF_SUCCESS); 2241} 2242 2243/** 2244 * @tc.name: GetPowerModeTest_004 2245 * @tc.desc: Wifi hdi get power mode function test_04 2246 * @tc.type: FUNC 2247 */ 2248HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SgetPowerMode_0400, Function | MediumTest | Level1) 2249{ 2250 int32_t ret; 2251 struct IWiFiAp *apFeature = nullptr; 2252 2253 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2254 EXPECT_EQ(ret, HDF_SUCCESS); 2255 EXPECT_NE(apFeature, nullptr); 2256 printf("GetPowerMode001: ifname is %s\n", apFeature->baseFeature.ifName); 2257 ret = g_wifi->getPowerMode(apFeature->baseFeature.ifName, nullptr); 2258 EXPECT_NE(ret, HDF_SUCCESS); 2259 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2260 EXPECT_EQ(ret, HDF_SUCCESS); 2261} 2262 2263/** 2264 * @tc.name: GetPowerModeTest_005 2265 * @tc.desc: Wifi hdi get power mode function test_05 2266 * @tc.type: FUNC 2267 */ 2268HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SgetPowerMode_0500, Function | MediumTest | Level1) 2269{ 2270 int32_t ret; 2271 struct IWiFiAp *apFeature = nullptr; 2272 uint8_t mode; 2273 2274 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2275 EXPECT_EQ(ret, HDF_SUCCESS); 2276 EXPECT_NE(apFeature, nullptr); 2277 printf("GetPowerMode001: ifname is %s\n", apFeature->baseFeature.ifName); 2278 ret = g_wifi->getPowerMode(apFeature->baseFeature.ifName, &mode); 2279 printf("%s: ret = %d\n", __func__, ret); 2280 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 2281 ASSERT_TRUE(flag); 2282 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2283 EXPECT_EQ(ret, HDF_SUCCESS); 2284} 2285 2286/** 2287 * @tc.name: GetPowerModeTest_006 2288 * @tc.desc: Wifi hdi get power mode function test_06 2289 * @tc.type: FUNC 2290 */ 2291HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SgetPowerMode_0600, Function | MediumTest | Level1) 2292{ 2293 int32_t ret; 2294 struct IWiFiSta *staFeature = nullptr; 2295 uint8_t mode; 2296 2297 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2298 EXPECT_EQ(ret, HDF_SUCCESS); 2299 EXPECT_NE(staFeature, nullptr); 2300 printf("GetPowerMode002: ifname is %s\n", staFeature->baseFeature.ifName); 2301 ret = g_wifi->getPowerMode(nullptr, &mode); 2302 EXPECT_NE(ret, HDF_SUCCESS); 2303 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2304 EXPECT_EQ(ret, HDF_SUCCESS); 2305} 2306 2307/** 2308 * @tc.name: GetPowerModeTest_007 2309 * @tc.desc: Wifi hdi get power mode function test_07 2310 * @tc.type: FUNC 2311 */ 2312HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SgetPowerMode_0700, Function | MediumTest | Level1) 2313{ 2314 int32_t ret; 2315 struct IWiFiSta *staFeature = nullptr; 2316 const char *ifName = "eth0"; 2317 2318 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2319 EXPECT_EQ(ret, HDF_SUCCESS); 2320 EXPECT_NE(staFeature, nullptr); 2321 printf("GetPowerMode002: ifname is %s\n", staFeature->baseFeature.ifName); 2322 ret = g_wifi->getPowerMode(ifName, nullptr); 2323 EXPECT_NE(ret, HDF_SUCCESS); 2324 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2325 EXPECT_EQ(ret, HDF_SUCCESS); 2326} 2327 2328/** 2329 * @tc.name: GetPowerModeTest_008 2330 * @tc.desc: Wifi hdi get power mode function test_08 2331 * @tc.type: FUNC 2332 */ 2333HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SgetPowerMode_0800, Function | MediumTest | Level1) 2334{ 2335 int32_t ret; 2336 struct IWiFiSta *staFeature = nullptr; 2337 const char *ifName = "eth0"; 2338 uint8_t mode; 2339 2340 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2341 EXPECT_EQ(ret, HDF_SUCCESS); 2342 EXPECT_NE(staFeature, nullptr); 2343 printf("GetPowerMode002: ifname is %s\n", staFeature->baseFeature.ifName); 2344 ret = g_wifi->getPowerMode(ifName, &mode); 2345 EXPECT_NE(ret, HDF_SUCCESS); 2346 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2347 EXPECT_EQ(ret, HDF_SUCCESS); 2348} 2349 2350/** 2351 * @tc.name: GetPowerModeTest_009 2352 * @tc.desc: Wifi hdi get power mode function test_09 2353 * @tc.type: FUNC 2354 */ 2355HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SgetPowerMode_0900, Function | MediumTest | Level1) 2356{ 2357 int32_t ret; 2358 struct IWiFiSta *staFeature = nullptr; 2359 2360 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2361 EXPECT_EQ(ret, HDF_SUCCESS); 2362 EXPECT_NE(staFeature, nullptr); 2363 printf("GetPowerMode002: ifname is %s\n", staFeature->baseFeature.ifName); 2364 ret = g_wifi->getPowerMode(staFeature->baseFeature.ifName, nullptr); 2365 EXPECT_NE(ret, HDF_SUCCESS); 2366 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2367 EXPECT_EQ(ret, HDF_SUCCESS); 2368} 2369 2370/** 2371 * @tc.name: GetPowerModeTest_010 2372 * @tc.desc: Wifi hdi get power mode function test_10 2373 * @tc.type: FUNC 2374 */ 2375HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SgetPowerMode_1000, Function | MediumTest | Level1) 2376{ 2377 int32_t ret; 2378 struct IWiFiSta *staFeature = nullptr; 2379 uint8_t mode; 2380 2381 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2382 EXPECT_EQ(ret, HDF_SUCCESS); 2383 EXPECT_NE(staFeature, nullptr); 2384 printf("GetPowerMode002: ifname is %s\n", staFeature->baseFeature.ifName); 2385 ret = g_wifi->getPowerMode(staFeature->baseFeature.ifName, &mode); 2386 printf("%s: ret = %d\n", __func__, ret); 2387 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 2388 ASSERT_TRUE(flag); 2389 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2390 EXPECT_EQ(ret, HDF_SUCCESS); 2391} 2392 2393/** 2394 * @tc.name: SetPowerModeTest_001 2395 * @tc.desc: Wifi hdi set power mode function test_01 2396 * @tc.type: FUNC 2397 */ 2398HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SgetPowerMode_1100, Function | MediumTest | Level1) 2399{ 2400 int32_t ret; 2401 struct IWiFiAp *apFeature = nullptr; 2402 const char *ifName = "eth0"; 2403 2404 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2405 EXPECT_EQ(ret, HDF_SUCCESS); 2406 EXPECT_NE(apFeature, nullptr); 2407 printf("SetPowerMode001: ifname is %s\n", apFeature->baseFeature.ifName); 2408 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_NUM); 2409 EXPECT_NE(ret, HDF_SUCCESS); 2410 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_NUM); 2411 EXPECT_NE(ret, HDF_SUCCESS); 2412 ret = g_wifi->setPowerMode(apFeature->baseFeature.ifName, WIFI_POWER_MODE_NUM); 2413 EXPECT_NE(ret, HDF_SUCCESS); 2414 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2415 EXPECT_EQ(ret, HDF_SUCCESS); 2416} 2417 2418/** 2419 * @tc.name: SetPowerModeTest_002 2420 * @tc.desc: Wifi hdi set power mode function test_02 2421 * @tc.type: FUNC 2422 */ 2423HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SgetPowerMode_1200, Function | MediumTest | Level1) 2424{ 2425 int32_t ret; 2426 struct IWiFiAp *apFeature = nullptr; 2427 const char *ifName = "eth0"; 2428 2429 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2430 EXPECT_EQ(ret, HDF_SUCCESS); 2431 EXPECT_NE(apFeature, nullptr); 2432 printf("SetPowerMode002: ifname is %s\n", apFeature->baseFeature.ifName); 2433 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_SLEEPING); 2434 EXPECT_NE(ret, HDF_SUCCESS); 2435 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_SLEEPING); 2436 EXPECT_NE(ret, HDF_SUCCESS); 2437 ret = g_wifi->setPowerMode(apFeature->baseFeature.ifName, WIFI_POWER_MODE_SLEEPING); 2438 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 2439 ASSERT_TRUE(flag); 2440 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2441 EXPECT_EQ(ret, HDF_SUCCESS); 2442} 2443 2444/** 2445 * @tc.name: SetPowerModeTest_003 2446 * @tc.desc: Wifi hdi set power mode function test_03 2447 * @tc.type: FUNC 2448 */ 2449HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SgetPowerMode_1300, Function | MediumTest | Level1) 2450{ 2451 int32_t ret; 2452 struct IWiFiAp *apFeature = nullptr; 2453 const char *ifName = "eth0"; 2454 2455 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2456 EXPECT_EQ(ret, HDF_SUCCESS); 2457 EXPECT_NE(apFeature, nullptr); 2458 printf("SetPowerMode003: ifname is %s\n", apFeature->baseFeature.ifName); 2459 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_GENERAL); 2460 EXPECT_NE(ret, HDF_SUCCESS); 2461 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_GENERAL); 2462 EXPECT_NE(ret, HDF_SUCCESS); 2463 ret = g_wifi->setPowerMode(apFeature->baseFeature.ifName, WIFI_POWER_MODE_GENERAL); 2464 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 2465 ASSERT_TRUE(flag); 2466 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2467 EXPECT_EQ(ret, HDF_SUCCESS); 2468} 2469 2470/** 2471 * @tc.name: SetPowerModeTest_004 2472 * @tc.desc: Wifi hdi set power mode function test_04 2473 * @tc.type: FUNC 2474 */ 2475HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SgetPowerMode_1400, Function | MediumTest | Level1) 2476{ 2477 int32_t ret; 2478 struct IWiFiAp *apFeature = nullptr; 2479 const char *ifName = "eth0"; 2480 2481 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2482 EXPECT_EQ(ret, HDF_SUCCESS); 2483 EXPECT_NE(apFeature, nullptr); 2484 printf("SetPowerMode004: ifname is %s\n", apFeature->baseFeature.ifName); 2485 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_THROUGH_WALL); 2486 EXPECT_NE(ret, HDF_SUCCESS); 2487 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_THROUGH_WALL); 2488 EXPECT_NE(ret, HDF_SUCCESS); 2489 ret = g_wifi->setPowerMode(apFeature->baseFeature.ifName, WIFI_POWER_MODE_THROUGH_WALL); 2490 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 2491 ASSERT_TRUE(flag); 2492 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2493 EXPECT_EQ(ret, HDF_SUCCESS); 2494} 2495 2496/** 2497 * @tc.name: SetPowerModeTest_005 2498 * @tc.desc: Wifi hdi set power mode function test_05 2499 * @tc.type: FUNC 2500 */ 2501HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SgetPowerMode_1500, Function | MediumTest | Level1) 2502{ 2503 int32_t ret; 2504 struct IWiFiSta *staFeature = nullptr; 2505 const char *ifName = "eth0"; 2506 2507 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2508 EXPECT_EQ(ret, HDF_SUCCESS); 2509 EXPECT_NE(staFeature, nullptr); 2510 printf("SetPowerMode005: ifname is %s\n", staFeature->baseFeature.ifName); 2511 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_NUM); 2512 EXPECT_NE(ret, HDF_SUCCESS); 2513 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_NUM); 2514 EXPECT_NE(ret, HDF_SUCCESS); 2515 ret = g_wifi->setPowerMode(staFeature->baseFeature.ifName, WIFI_POWER_MODE_NUM); 2516 EXPECT_NE(ret, HDF_SUCCESS); 2517 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2518 EXPECT_EQ(ret, HDF_SUCCESS); 2519} 2520 2521/** 2522 * @tc.name: SetPowerModeTest_006 2523 * @tc.desc: Wifi hdi set power mode function test_06 2524 * @tc.type: FUNC 2525 */ 2526HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SgetPowerMode_1600, Function | MediumTest | Level1) 2527{ 2528 int32_t ret; 2529 struct IWiFiSta *staFeature = nullptr; 2530 const char *ifName = "eth0"; 2531 2532 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2533 EXPECT_EQ(ret, HDF_SUCCESS); 2534 EXPECT_NE(staFeature, nullptr); 2535 printf("SetPowerMode005: ifname is %s\n", staFeature->baseFeature.ifName); 2536 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_SLEEPING); 2537 EXPECT_NE(ret, HDF_SUCCESS); 2538 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_SLEEPING); 2539 EXPECT_NE(ret, HDF_SUCCESS); 2540 ret = g_wifi->setPowerMode(staFeature->baseFeature.ifName, WIFI_POWER_MODE_SLEEPING); 2541 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 2542 ASSERT_TRUE(flag); 2543 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2544 EXPECT_EQ(ret, HDF_SUCCESS); 2545} 2546 2547/** 2548 * @tc.name: SetPowerModeTest_007 2549 * @tc.desc: Wifi hdi set power mode function test_07 2550 * @tc.type: FUNC 2551 */ 2552HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SgetPowerMode_1700, Function | MediumTest | Level1) 2553{ 2554 int32_t ret; 2555 struct IWiFiSta *staFeature = nullptr; 2556 const char *ifName = "eth0"; 2557 2558 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2559 EXPECT_EQ(ret, HDF_SUCCESS); 2560 EXPECT_NE(staFeature, nullptr); 2561 printf("SetPowerMode005: ifname is %s\n", staFeature->baseFeature.ifName); 2562 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_GENERAL); 2563 EXPECT_NE(ret, HDF_SUCCESS); 2564 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_GENERAL); 2565 EXPECT_NE(ret, HDF_SUCCESS); 2566 ret = g_wifi->setPowerMode(staFeature->baseFeature.ifName, WIFI_POWER_MODE_GENERAL); 2567 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 2568 ASSERT_TRUE(flag); 2569 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2570 EXPECT_EQ(ret, HDF_SUCCESS); 2571} 2572 2573/** 2574 * @tc.name: SetPowerModeTest_008 2575 * @tc.desc: Wifi hdi set power mode function test_08 2576 * @tc.type: FUNC 2577 */ 2578HWTEST_F(WifiHalTest, SUB_Driver_Wlan_SgetPowerMode_1800, Function | MediumTest | Level1) 2579{ 2580 int32_t ret; 2581 struct IWiFiSta *staFeature = nullptr; 2582 const char *ifName = "eth0"; 2583 2584 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2585 EXPECT_EQ(ret, HDF_SUCCESS); 2586 EXPECT_NE(staFeature, nullptr); 2587 printf("SetPowerMode005: ifname is %s\n", staFeature->baseFeature.ifName); 2588 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_THROUGH_WALL); 2589 EXPECT_NE(ret, HDF_SUCCESS); 2590 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_THROUGH_WALL); 2591 EXPECT_NE(ret, HDF_SUCCESS); 2592 ret = g_wifi->setPowerMode(staFeature->baseFeature.ifName, WIFI_POWER_MODE_THROUGH_WALL); 2593 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 2594 ASSERT_TRUE(flag); 2595 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2596 EXPECT_EQ(ret, HDF_SUCCESS); 2597} 2598 2599/** 2600 * @tc.name: WifiHalGetSupportCombo001 2601 * @tc.desc: Get supported combo_01 2602 * @tc.type: FUNC 2603 */ 2604HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_1200, Function | MediumTest | Level1) 2605{ 2606 int ret; 2607 uint8_t support[PROTOCOL_80211_IFTYPE_NUM + 1] = {0}; 2608 2609 ret = g_wifi->getSupportFeature(support, PROTOCOL_80211_IFTYPE_NUM + 1); 2610 EXPECT_EQ(HDF_SUCCESS, ret); 2611 ret = g_wifi->getSupportCombo(nullptr, 0); 2612 EXPECT_NE(HDF_SUCCESS, ret); 2613} 2614 2615/** 2616 * @tc.name: WifiHalGetSupportCombo002 2617 * @tc.desc: Get supported combo_02 2618 * @tc.type: FUNC 2619 */ 2620HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_1250, Function | MediumTest | Level1) 2621{ 2622 int ret; 2623 uint8_t support[PROTOCOL_80211_IFTYPE_NUM + 1] = {0}; 2624 uint64_t combo[DEFAULT_COMBO_SIZE] = {0}; 2625 2626 ret = g_wifi->getSupportFeature(support, PROTOCOL_80211_IFTYPE_NUM + 1); 2627 EXPECT_EQ(HDF_SUCCESS, ret); 2628 ret = g_wifi->getSupportCombo(combo, DEFAULT_COMBO_SIZE); 2629 if (support[PROTOCOL_80211_IFTYPE_NUM] == 0) { 2630 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); 2631} else { 2632 EXPECT_EQ(ret, HDF_SUCCESS); 2633} 2634} 2635 2636/** 2637 * @tc.name: SetProjectionScreenParam001 2638 * @tc.desc: wifi hal config projection screen function test_01 2639 * @tc.type: FUNC 2640 */ 2641HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_2700, Function | MediumTest | Level1) 2642{ 2643 int32_t ret; 2644 struct IWiFiAp *apFeature = nullptr; 2645 ProjectionScreenParam *param; 2646 2647 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 2648 EXPECT_NE(nullptr, param); 2649 param->cmdId = TEST_CMD; 2650 param->bufLen = 1; 2651 param->buf[0] = 0; 2652 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2653 EXPECT_EQ(ret, HDF_SUCCESS); 2654 ret = g_wifi->setProjectionScreenParam(nullptr, nullptr); 2655 EXPECT_NE(ret, HDF_SUCCESS); 2656 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2657 EXPECT_EQ(ret, HDF_SUCCESS); 2658 OsalMemFree(param); 2659} 2660 2661/** 2662 * @tc.name: SetProjectionScreenParam002 2663 * @tc.desc: wifi hal config projection screen function test_02 2664 * @tc.type: FUNC 2665 */ 2666HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_2800, Function | MediumTest | Level1) 2667{ 2668 int32_t ret; 2669 struct IWiFiAp *apFeature = nullptr; 2670 ProjectionScreenParam *param; 2671 2672 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 2673 EXPECT_NE(nullptr, param); 2674 param->cmdId = TEST_CMD; 2675 param->bufLen = 1; 2676 param->buf[0] = 0; 2677 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2678 EXPECT_EQ(ret, HDF_SUCCESS); 2679 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, nullptr); 2680 EXPECT_NE(ret, HDF_SUCCESS); 2681 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2682 EXPECT_EQ(ret, HDF_SUCCESS); 2683 OsalMemFree(param); 2684} 2685 2686/** 2687 * @tc.name: SetProjectionScreenParam003 2688 * @tc.desc: wifi hal config projection screen function test_03 2689 * @tc.type: FUNC 2690 */ 2691HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_2900, Function | MediumTest | Level1) 2692{ 2693 int32_t ret; 2694 struct IWiFiAp *apFeature = nullptr; 2695 ProjectionScreenParam *param; 2696 2697 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 2698 EXPECT_NE(nullptr, param); 2699 param->cmdId = TEST_CMD; 2700 param->bufLen = 1; 2701 param->buf[0] = 0; 2702 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2703 EXPECT_EQ(ret, HDF_SUCCESS); 2704 ret = g_wifi->setProjectionScreenParam(nullptr, param); 2705 EXPECT_NE(ret, HDF_SUCCESS); 2706 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2707 EXPECT_EQ(ret, HDF_SUCCESS); 2708 OsalMemFree(param); 2709} 2710 2711/** 2712 * @tc.name: SetProjectionScreenParam004 2713 * @tc.desc: wifi hal config projection screen function test_04 2714 * @tc.type: FUNC 2715 */ 2716HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_3000, Function | MediumTest | Level1) 2717{ 2718 int32_t ret; 2719 struct IWiFiAp *apFeature = nullptr; 2720 ProjectionScreenParam *param; 2721 2722 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 2723 EXPECT_NE(nullptr, param); 2724 param->cmdId = TEST_CMD; 2725 param->bufLen = 1; 2726 param->buf[0] = 0; 2727 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2728 EXPECT_EQ(ret, HDF_SUCCESS); 2729 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, param); 2730 EXPECT_NE(ret, HDF_SUCCESS); 2731 2732 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2733 EXPECT_EQ(ret, HDF_SUCCESS); 2734 OsalMemFree(param); 2735} 2736 2737/** 2738 * @tc.name: SetProjectionScreenParam005 2739 * @tc.desc: wifi hal config projection screen function test_05 2740 * @tc.type: FUNC 2741 */ 2742HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_3100, Function | MediumTest | Level1) 2743{ 2744 int32_t ret; 2745 bool flag; 2746 struct IWiFiAp *apFeature = nullptr; 2747 ProjectionScreenParam *param; 2748 2749 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 2750 EXPECT_NE(nullptr, param); 2751 param->cmdId = TEST_CMD; 2752 param->bufLen = 1; 2753 param->buf[0] = 0; 2754 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2755 EXPECT_EQ(ret, HDF_SUCCESS); 2756 for (int i = CMD_CLOSE_GO_CAC; i <= CMD_ID_CTRL_ROAM_CHANNEL; i++) { 2757 param->cmdId = i; 2758 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, param); 2759 printf("SetProjectionScreenParam001_%d: ret = %d\n", __LINE__, ret); 2760 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 2761 ASSERT_TRUE(flag); 2762 } 2763 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2764 EXPECT_EQ(ret, HDF_SUCCESS); 2765 OsalMemFree(param); 2766} 2767 2768/** 2769 * @tc.name: SetProjectionScreenParam006 2770 * @tc.desc: wifi hal config projection screen function test_06 2771 * @tc.type: FUNC 2772 */ 2773HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_3200, Function | MediumTest | Level1) 2774{ 2775 int32_t ret; 2776 struct IWiFiSta *staFeature = nullptr; 2777 ProjectionScreenParam *param; 2778 2779 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 2780 EXPECT_NE(nullptr, param); 2781 param->cmdId = TEST_CMD; 2782 param->bufLen = 1; 2783 param->buf[0] = 0; 2784 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2785 EXPECT_EQ(ret, HDF_SUCCESS); 2786 ret = g_wifi->setProjectionScreenParam(nullptr, nullptr); 2787 EXPECT_NE(ret, HDF_SUCCESS); 2788 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2789 EXPECT_EQ(ret, HDF_SUCCESS); 2790 OsalMemFree(param); 2791} 2792 2793/** 2794 * @tc.name: SetProjectionScreenParam007 2795 * @tc.desc: wifi hal config projection screen function test_07 2796 * @tc.type: FUNC 2797 */ 2798HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_3300, Function | MediumTest | Level1) 2799{ 2800 int32_t ret; 2801 struct IWiFiSta *staFeature = nullptr; 2802 ProjectionScreenParam *param; 2803 2804 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 2805 EXPECT_NE(nullptr, param); 2806 param->cmdId = TEST_CMD; 2807 param->bufLen = 1; 2808 param->buf[0] = 0; 2809 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2810 EXPECT_EQ(ret, HDF_SUCCESS); 2811 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, nullptr); 2812 EXPECT_NE(ret, HDF_SUCCESS); 2813 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2814 EXPECT_EQ(ret, HDF_SUCCESS); 2815 OsalMemFree(param); 2816} 2817 2818/** 2819 * @tc.name: SetProjectionScreenParam008 2820 * @tc.desc: wifi hal config projection screen function test_08 2821 * @tc.type: FUNC 2822 */ 2823HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_3400, Function | MediumTest | Level1) 2824{ 2825 int32_t ret; 2826 struct IWiFiSta *staFeature = nullptr; 2827 ProjectionScreenParam *param; 2828 2829 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 2830 EXPECT_NE(nullptr, param); 2831 param->cmdId = TEST_CMD; 2832 param->bufLen = 1; 2833 param->buf[0] = 0; 2834 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2835 EXPECT_EQ(ret, HDF_SUCCESS); 2836 ret = g_wifi->setProjectionScreenParam(nullptr, param); 2837 EXPECT_NE(ret, HDF_SUCCESS); 2838 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2839 EXPECT_EQ(ret, HDF_SUCCESS); 2840 OsalMemFree(param); 2841} 2842 2843/** 2844 * @tc.name: SetProjectionScreenParam009 2845 * @tc.desc: wifi hal config projection screen function test_09 2846 * @tc.type: FUNC 2847 */ 2848HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_3500, Function | MediumTest | Level1) 2849{ 2850 int32_t ret; 2851 struct IWiFiSta *staFeature = nullptr; 2852 ProjectionScreenParam *param; 2853 2854 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 2855 EXPECT_NE(nullptr, param); 2856 param->cmdId = TEST_CMD; 2857 param->bufLen = 1; 2858 param->buf[0] = 0; 2859 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2860 EXPECT_EQ(ret, HDF_SUCCESS); 2861 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, param); 2862 EXPECT_NE(ret, HDF_SUCCESS); 2863 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2864 EXPECT_EQ(ret, HDF_SUCCESS); 2865 OsalMemFree(param); 2866} 2867 2868/** 2869 * @tc.name: SetProjectionScreenParam010 2870 * @tc.desc: wifi hal config projection screen function test_10 2871 * @tc.type: FUNC 2872 */ 2873HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_3600, Function | MediumTest | Level1) 2874{ 2875 int32_t ret; 2876 bool flag; 2877 struct IWiFiSta *staFeature = nullptr; 2878 ProjectionScreenParam *param; 2879 2880 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 2881 EXPECT_NE(nullptr, param); 2882 param->cmdId = TEST_CMD; 2883 param->bufLen = 1; 2884 param->buf[0] = 0; 2885 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2886 EXPECT_EQ(ret, HDF_SUCCESS); 2887 for (int i = CMD_CLOSE_GO_CAC; i <= CMD_ID_CTRL_ROAM_CHANNEL; i++) { 2888 param->cmdId = i; 2889 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, param); 2890 printf("SetProjectionScreenParam001_%d: ret = %d\n", __LINE__, ret); 2891 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 2892 ASSERT_TRUE(flag); 2893 } 2894 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 2895 EXPECT_EQ(ret, HDF_SUCCESS); 2896 OsalMemFree(param); 2897} 2898 2899/** 2900 * @tc.name: SendCmdIoctl001 2901 * @tc.desc: wifi hal send ioctl command function test_01 2902 * @tc.type: FUNC 2903 */ 2904HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_7400, Function | MediumTest | Level1) 2905{ 2906 int32_t cmdId = 0; 2907 int32_t ret; 2908 struct IWiFiAp *apFeature = nullptr; 2909 2910 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2911 EXPECT_EQ(ret, HDF_SUCCESS); 2912 ret = g_wifi->sendCmdIoctl(nullptr, cmdId, nullptr, TEST_BUF_SIZE); 2913 EXPECT_NE(ret, HDF_SUCCESS); 2914 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2915 EXPECT_EQ(ret, HDF_SUCCESS); 2916} 2917 2918/** 2919 * @tc.name: SendCmdIoctl002 2920 * @tc.desc: wifi hal send ioctl command function test_02 2921 * @tc.type: FUNC 2922 */ 2923HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_7500, Function | MediumTest | Level1) 2924{ 2925 int32_t cmdId = 0; 2926 int32_t ret; 2927 struct IWiFiAp *apFeature = nullptr; 2928 const char *ifName = "wlan0"; 2929 2930 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2931 EXPECT_EQ(ret, HDF_SUCCESS); 2932 ret = g_wifi->sendCmdIoctl(ifName, cmdId, nullptr, TEST_BUF_SIZE); 2933 EXPECT_NE(ret, HDF_SUCCESS); 2934 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2935 EXPECT_EQ(ret, HDF_SUCCESS); 2936} 2937 2938/** 2939 * @tc.name: SendCmdIoctl003 2940 * @tc.desc: wifi hal send ioctl command function test_03 2941 * @tc.type: FUNC 2942 */ 2943HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_7600, Function | MediumTest | Level1) 2944{ 2945 int32_t cmdId = 0; 2946 int32_t ret; 2947 struct IWiFiAp *apFeature = nullptr; 2948 int8_t data[TEST_BUF_SIZE] = {0}; 2949 2950 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2951 EXPECT_EQ(ret, HDF_SUCCESS); 2952 ret = g_wifi->sendCmdIoctl(nullptr, cmdId, data, TEST_BUF_SIZE); 2953 EXPECT_NE(ret, HDF_SUCCESS); 2954 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2955 EXPECT_EQ(ret, HDF_SUCCESS); 2956} 2957 2958/** 2959 * @tc.name: SendCmdIoctl004 2960 * @tc.desc: wifi hal send ioctl command function test_04 2961 * @tc.type: FUNC 2962 */ 2963HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_7700, Function | MediumTest | Level1) 2964{ 2965 int32_t cmdId = 0; 2966 int32_t ret; 2967 bool flag; 2968 struct IWiFiAp *apFeature = nullptr; 2969 int8_t data[TEST_BUF_SIZE] = {0}; 2970 const char *ifName = "wlan0"; 2971 2972 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 2973 EXPECT_EQ(ret, HDF_SUCCESS); 2974 for (cmdId = CMD_HID2D_MODULE_INIT; cmdId <= CMD_SET_CHAN_ADJUST; cmdId++) { 2975 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE); 2976 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret); 2977 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 2978 ASSERT_TRUE(flag); 2979 } 2980 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 2981 EXPECT_EQ(ret, HDF_SUCCESS); 2982} 2983 2984/** 2985 * @tc.name: SendCmdIoctl005 2986 * @tc.desc: wifi hal send ioctl command function test_05 2987 * @tc.type: FUNC 2988 */ 2989HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_7800, Function | MediumTest | Level1) 2990{ 2991 int32_t cmdId = 0; 2992 int32_t ret; 2993 struct IWiFiSta *staFeature = nullptr; 2994 2995 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 2996 EXPECT_EQ(ret, HDF_SUCCESS); 2997 ret = g_wifi->sendCmdIoctl(nullptr, cmdId, nullptr, TEST_BUF_SIZE); 2998 EXPECT_NE(ret, HDF_SUCCESS); 2999 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 3000 EXPECT_EQ(ret, HDF_SUCCESS); 3001} 3002 3003/** 3004 * @tc.name: SendCmdIoctl006 3005 * @tc.desc: wifi hal send ioctl command function test_06 3006 * @tc.type: FUNC 3007 */ 3008HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_7900, Function | MediumTest | Level1) 3009{ 3010 int32_t cmdId = 0; 3011 int32_t ret; 3012 struct IWiFiSta *staFeature = nullptr; 3013 const char *ifName = "wlan0"; 3014 3015 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 3016 EXPECT_EQ(ret, HDF_SUCCESS); 3017 ret = g_wifi->sendCmdIoctl(ifName, cmdId, nullptr, TEST_BUF_SIZE); 3018 EXPECT_NE(ret, HDF_SUCCESS); 3019 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 3020 EXPECT_EQ(ret, HDF_SUCCESS); 3021} 3022 3023/** 3024 * @tc.name: SendCmdIoctl007 3025 * @tc.desc: wifi hal send ioctl command function test_07 3026 * @tc.type: FUNC 3027 */ 3028HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_8000, Function | MediumTest | Level1) 3029{ 3030 int32_t cmdId = 0; 3031 int32_t ret; 3032 struct IWiFiSta *staFeature = nullptr; 3033 int8_t data[TEST_BUF_SIZE] = {0}; 3034 3035 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 3036 EXPECT_EQ(ret, HDF_SUCCESS); 3037 ret = g_wifi->sendCmdIoctl(nullptr, cmdId, data, TEST_BUF_SIZE); 3038 EXPECT_NE(ret, HDF_SUCCESS); 3039 3040 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 3041 EXPECT_EQ(ret, HDF_SUCCESS); 3042} 3043 3044/** 3045 * @tc.name: SendCmdIoctl008 3046 * @tc.desc: wifi hal send ioctl command function test_08 3047 * @tc.type: FUNC 3048 */ 3049HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_8100, Function | MediumTest | Level1) 3050{ 3051 int32_t cmdId = 0; 3052 int32_t ret; 3053 bool flag; 3054 struct IWiFiSta *staFeature = nullptr; 3055 int8_t data[TEST_BUF_SIZE] = {0}; 3056 const char *ifName = "wlan0"; 3057 3058 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 3059 EXPECT_EQ(ret, HDF_SUCCESS); 3060 for (cmdId = CMD_HID2D_MODULE_INIT; cmdId <= CMD_SET_CHAN_ADJUST; cmdId++) { 3061 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE); 3062 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret); 3063 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 3064 ASSERT_TRUE(flag); 3065 } 3066 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 3067 EXPECT_EQ(ret, HDF_SUCCESS); 3068} 3069 3070/** 3071 * @tc.name: GetStationInfo001 3072 * @tc.desc: Wifi hdi get station information function test_01 3073 * @tc.type: FUNC 3074 */ 3075HWTEST_F(WifiHalTest, SUB_Driver_Wlan_ReportSTAEvent_0100, Function | MediumTest | Level1) 3076{ 3077 int32_t ret; 3078 struct IWiFiAp *apFeature = nullptr; 3079 3080 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 3081 EXPECT_EQ(ret, HDF_SUCCESS); 3082 ret = g_wifi->getStationInfo(nullptr, nullptr, nullptr, ETH_ADDR_LEN); 3083 EXPECT_NE(ret, HDF_SUCCESS); 3084 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 3085 EXPECT_EQ(ret, HDF_SUCCESS); 3086} 3087 3088/** 3089 * @tc.name: GetStationInfo002 3090 * @tc.desc: Wifi hdi get station information function test_02 3091 * @tc.type: FUNC 3092 */ 3093HWTEST_F(WifiHalTest, SUB_Driver_Wlan_ReportSTAEvent_0200, Function | MediumTest | Level1) 3094{ 3095 int32_t ret; 3096 struct IWiFiAp *apFeature = nullptr; 3097 const char *ifName = "wlan0"; 3098 3099 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 3100 EXPECT_EQ(ret, HDF_SUCCESS); 3101 ret = g_wifi->getStationInfo(ifName, nullptr, nullptr, ETH_ADDR_LEN); 3102 EXPECT_NE(ret, HDF_SUCCESS); 3103 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 3104 EXPECT_EQ(ret, HDF_SUCCESS); 3105} 3106 3107/** 3108 * @tc.name: GetStationInfo003 3109 * @tc.desc: Wifi hdi get station information function test_03 3110 * @tc.type: FUNC 3111 */ 3112HWTEST_F(WifiHalTest, SUB_Driver_Wlan_ReportSTAEvent_0300, Function | MediumTest | Level1) 3113{ 3114 int32_t ret; 3115 StationInfo info; 3116 struct IWiFiAp *apFeature = nullptr; 3117 3118 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 3119 EXPECT_EQ(ret, HDF_SUCCESS); 3120 ret = g_wifi->getStationInfo(nullptr, &info, nullptr, ETH_ADDR_LEN); 3121 EXPECT_NE(ret, HDF_SUCCESS); 3122 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 3123 EXPECT_EQ(ret, HDF_SUCCESS); 3124} 3125 3126/** 3127 * @tc.name: GetStationInfo004 3128 * @tc.desc: Wifi hdi get station information function test_04 3129 * @tc.type: FUNC 3130 */ 3131HWTEST_F(WifiHalTest, SUB_Driver_Wlan_ReportSTAEvent_0400, Function | MediumTest | Level1) 3132{ 3133 int32_t ret; 3134 uint8_t mac[ETH_ADDR_LEN] = {0}; 3135 struct IWiFiAp *apFeature = nullptr; 3136 3137 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 3138 EXPECT_EQ(ret, HDF_SUCCESS); 3139 ret = g_wifi->getStationInfo(nullptr, nullptr, mac, ETH_ADDR_LEN); 3140 EXPECT_NE(ret, HDF_SUCCESS); 3141 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 3142 EXPECT_EQ(ret, HDF_SUCCESS); 3143} 3144 3145/** 3146 * @tc.name: GetStationInfo005 3147 * @tc.desc: Wifi hdi get station information function test_05 3148 * @tc.type: FUNC 3149 */ 3150HWTEST_F(WifiHalTest, SUB_Driver_Wlan_ReportSTAEvent_0500, Function | MediumTest | Level1) 3151{ 3152 int32_t ret; 3153 StationInfo info; 3154 struct IWiFiAp *apFeature = nullptr; 3155 const char *ifName = "wlan0"; 3156 3157 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 3158 EXPECT_EQ(ret, HDF_SUCCESS); 3159 ret = g_wifi->getStationInfo(ifName, &info, nullptr, ETH_ADDR_LEN); 3160 EXPECT_NE(ret, HDF_SUCCESS); 3161 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 3162 EXPECT_EQ(ret, HDF_SUCCESS); 3163} 3164 3165/** 3166 * @tc.name: GetStationInfo006 3167 * @tc.desc: Wifi hdi get station information function test_06 3168 * @tc.type: FUNC 3169 */ 3170HWTEST_F(WifiHalTest, SUB_Driver_Wlan_ReportSTAEvent_0600, Function | MediumTest | Level1) 3171{ 3172 int32_t ret; 3173 StationInfo info; 3174 uint8_t mac[ETH_ADDR_LEN] = {0}; 3175 struct IWiFiAp *apFeature = nullptr; 3176 3177 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 3178 EXPECT_EQ(ret, HDF_SUCCESS); 3179 ret = g_wifi->getStationInfo(nullptr, &info, mac, ETH_ADDR_LEN); 3180 EXPECT_NE(ret, HDF_SUCCESS); 3181 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 3182 EXPECT_EQ(ret, HDF_SUCCESS); 3183} 3184 3185/** 3186 * @tc.name: GetStationInfo007 3187 * @tc.desc: Wifi hdi get station information function test_07 3188 * @tc.type: FUNC 3189 */ 3190HWTEST_F(WifiHalTest, SUB_Driver_Wlan_ReportSTAEvent_0700, Function | MediumTest | Level1) 3191{ 3192 int32_t ret; 3193 uint8_t mac[ETH_ADDR_LEN] = {0}; 3194 struct IWiFiAp *apFeature = nullptr; 3195 const char *ifName = "wlan0"; 3196 3197 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 3198 EXPECT_EQ(ret, HDF_SUCCESS); 3199 ret = g_wifi->getStationInfo(ifName, nullptr, mac, ETH_ADDR_LEN); 3200 EXPECT_NE(ret, HDF_SUCCESS); 3201 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 3202 EXPECT_EQ(ret, HDF_SUCCESS); 3203} 3204 3205/** 3206 * @tc.name: GetStationInfo008 3207 * @tc.desc: Wifi hdi get station information function test_08 3208 * @tc.type: FUNC 3209 */ 3210HWTEST_F(WifiHalTest, SUB_Driver_Wlan_ReportSTAEvent_0800, Function | MediumTest | Level1) 3211{ 3212 int32_t ret; 3213 StationInfo info; 3214 bool flag; 3215 uint8_t mac[ETH_ADDR_LEN] = {0}; 3216 struct IWiFiAp *apFeature = nullptr; 3217 const char *ifName = "wlan0"; 3218 3219 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 3220 EXPECT_EQ(ret, HDF_SUCCESS); 3221 ret = g_wifi->getStationInfo(ifName, &info, mac, ETH_ADDR_LEN); 3222 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 3223 ASSERT_TRUE(flag); 3224 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 3225 EXPECT_EQ(ret, HDF_SUCCESS); 3226} 3227 3228/** 3229 * @tc.name: GetStationInfo009 3230 * @tc.desc: Wifi hdi get station information function test_09 3231 * @tc.type: FUNC 3232 */ 3233HWTEST_F(WifiHalTest, SUB_Driver_Wlan_ReportSTAEvent_0900, Function | MediumTest | Level1) 3234{ 3235 int32_t ret; 3236 struct IWiFiSta *staFeature = nullptr; 3237 3238 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&staFeature); 3239 EXPECT_EQ(ret, HDF_SUCCESS); 3240 ret = g_wifi->getStationInfo(nullptr, nullptr, nullptr, ETH_ADDR_LEN); 3241 EXPECT_NE(ret, HDF_SUCCESS); 3242 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 3243 EXPECT_EQ(ret, HDF_SUCCESS); 3244} 3245 3246/** 3247 * @tc.name: GetStationInfo010 3248 * @tc.desc: Wifi hdi get station information function test_10 3249 * @tc.type: FUNC 3250 */ 3251HWTEST_F(WifiHalTest, SUB_Driver_Wlan_ReportSTAEvent_1000, Function | MediumTest | Level1) 3252{ 3253 int32_t ret; 3254 struct IWiFiSta *staFeature = nullptr; 3255 const char *ifName = "wlan0"; 3256 3257 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&staFeature); 3258 EXPECT_EQ(ret, HDF_SUCCESS); 3259 ret = g_wifi->getStationInfo(ifName, nullptr, nullptr, ETH_ADDR_LEN); 3260 EXPECT_NE(ret, HDF_SUCCESS); 3261 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 3262 EXPECT_EQ(ret, HDF_SUCCESS); 3263} 3264 3265/** 3266 * @tc.name: GetStationInfo011 3267 * @tc.desc: Wifi hdi get station information function test_11 3268 * @tc.type: FUNC 3269 */ 3270HWTEST_F(WifiHalTest, SUB_Driver_Wlan_ReportSTAEvent_1100, Function | MediumTest | Level1) 3271{ 3272 int32_t ret; 3273 StationInfo info; 3274 struct IWiFiSta *staFeature = nullptr; 3275 3276 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&staFeature); 3277 EXPECT_EQ(ret, HDF_SUCCESS); 3278 ret = g_wifi->getStationInfo(nullptr, &info, nullptr, ETH_ADDR_LEN); 3279 EXPECT_NE(ret, HDF_SUCCESS); 3280 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 3281 EXPECT_EQ(ret, HDF_SUCCESS); 3282} 3283 3284/** 3285 * @tc.name: GetStationInfo012 3286 * @tc.desc: Wifi hdi get station information function test_12 3287 * @tc.type: FUNC 3288 */ 3289HWTEST_F(WifiHalTest, SUB_Driver_Wlan_ReportSTAEvent_1200, Function | MediumTest | Level1) 3290{ 3291 int32_t ret; 3292 uint8_t mac[ETH_ADDR_LEN] = {0}; 3293 struct IWiFiSta *staFeature = nullptr; 3294 3295 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&staFeature); 3296 EXPECT_EQ(ret, HDF_SUCCESS); 3297 ret = g_wifi->getStationInfo(nullptr, nullptr, mac, ETH_ADDR_LEN); 3298 EXPECT_NE(ret, HDF_SUCCESS); 3299 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 3300 EXPECT_EQ(ret, HDF_SUCCESS); 3301} 3302 3303/** 3304 * @tc.name: GetStationInfo013 3305 * @tc.desc: Wifi hdi get station information function test_13 3306 * @tc.type: FUNC 3307 */ 3308HWTEST_F(WifiHalTest, SUB_Driver_Wlan_ReportSTAEvent_1300, Function | MediumTest | Level1) 3309{ 3310 int32_t ret; 3311 StationInfo info; 3312 struct IWiFiSta *staFeature = nullptr; 3313 const char *ifName = "wlan0"; 3314 3315 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&staFeature); 3316 EXPECT_EQ(ret, HDF_SUCCESS); 3317 ret = g_wifi->getStationInfo(ifName, &info, nullptr, ETH_ADDR_LEN); 3318 EXPECT_NE(ret, HDF_SUCCESS); 3319 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 3320 EXPECT_EQ(ret, HDF_SUCCESS); 3321} 3322 3323/** 3324 * @tc.name: GetStationInfo014 3325 * @tc.desc: Wifi hdi get station information function test_14 3326 * @tc.type: FUNC 3327 */ 3328HWTEST_F(WifiHalTest, SUB_Driver_Wlan_ReportSTAEvent_1400, Function | MediumTest | Level1) 3329{ 3330 int32_t ret; 3331 StationInfo info; 3332 uint8_t mac[ETH_ADDR_LEN] = {0}; 3333 struct IWiFiSta *staFeature = nullptr; 3334 3335 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&staFeature); 3336 EXPECT_EQ(ret, HDF_SUCCESS); 3337 ret = g_wifi->getStationInfo(nullptr, &info, mac, ETH_ADDR_LEN); 3338 EXPECT_NE(ret, HDF_SUCCESS); 3339 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 3340 EXPECT_EQ(ret, HDF_SUCCESS); 3341} 3342 3343/** 3344 * @tc.name: GetStationInfo015 3345 * @tc.desc: Wifi hdi get station information function test_15 3346 * @tc.type: FUNC 3347 */ 3348HWTEST_F(WifiHalTest, SUB_Driver_Wlan_ReportSTAEvent_1500, Function | MediumTest | Level1) 3349{ 3350 int32_t ret; 3351 uint8_t mac[ETH_ADDR_LEN] = {0}; 3352 struct IWiFiSta *staFeature = nullptr; 3353 const char *ifName = "wlan0"; 3354 3355 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&staFeature); 3356 EXPECT_EQ(ret, HDF_SUCCESS); 3357 ret = g_wifi->getStationInfo(ifName, nullptr, mac, ETH_ADDR_LEN); 3358 EXPECT_NE(ret, HDF_SUCCESS); 3359 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 3360 EXPECT_EQ(ret, HDF_SUCCESS); 3361} 3362 3363/** 3364 * @tc.name: GetStationInfo016 3365 * @tc.desc: Wifi hdi get station information function test_16 3366 * @tc.type: FUNC 3367 */ 3368HWTEST_F(WifiHalTest, SUB_Driver_Wlan_ReportSTAEvent_1600, Function | MediumTest | Level1) 3369{ 3370 int32_t ret; 3371 StationInfo info; 3372 bool flag; 3373 uint8_t mac[ETH_ADDR_LEN] = {0}; 3374 struct IWiFiSta *staFeature = nullptr; 3375 const char *ifName = "wlan0"; 3376 3377 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&staFeature); 3378 EXPECT_EQ(ret, HDF_SUCCESS); 3379 ret = g_wifi->getStationInfo(ifName, &info, mac, ETH_ADDR_LEN); 3380 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 3381 ASSERT_TRUE(flag); 3382 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 3383 EXPECT_EQ(ret, HDF_SUCCESS); 3384} 3385 3386/** 3387 * @tc.number: WifiHalResetDriver001 3388 * @tc.name: Reset the WiFi driver_01 3389 * @tc.size:Medium 3390 * @tc.level: Level 3 3391 */ 3392HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_2200, Function | MediumTest | Level3) 3393{ 3394 int32_t ret; 3395 struct IWiFiSta *staFeature = nullptr; 3396 uint8_t chipId = 0; 3397 uint8_t chipIdInvalid = 20; 3398 3399 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 3400 EXPECT_EQ(ret, HDF_SUCCESS); 3401 EXPECT_NE(staFeature, nullptr); 3402 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId); 3403 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE); 3404 EXPECT_EQ(ret, HDF_SUCCESS); 3405 3406 ret = g_wifi->resetDriver(chipIdInvalid, "wlan0"); 3407 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 3408 ret = g_wifi->resetDriver(chipId, nullptr); 3409 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 3410 ret = g_wifi->resetDriver(chipId, staFeature->baseFeature.ifName); 3411 EXPECT_EQ(ret, HDF_SUCCESS); 3412 sleep(RESET_TIME); 3413 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 3414 EXPECT_EQ(HDF_SUCCESS, ret); 3415} 3416 3417/** 3418 * @tc.number: WifiHalResetDriver002 3419 * @tc.name: Reset the WiFi driver_02 3420 * @tc.size:Medium 3421 * @tc.level: Level 3 3422 */ 3423HWTEST_F(WifiHalTest, SUB_Driver_Wlan_WifiHdi_2300, Function | MediumTest | Level3) 3424{ 3425 int32_t ret; 3426 struct IWiFiAp *apFeature = nullptr; 3427 uint8_t chipId = 0; 3428 uint8_t chipIdInvalid = 20; 3429 3430 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 3431 EXPECT_EQ(ret, HDF_SUCCESS); 3432 EXPECT_NE(apFeature, nullptr); 3433 ret = apFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)apFeature, &chipId); 3434 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE); 3435 EXPECT_EQ(ret, HDF_SUCCESS); 3436 3437 ret = g_wifi->resetDriver(chipIdInvalid, "wlan0"); 3438 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 3439 ret = g_wifi->resetDriver(chipId, nullptr); 3440 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM); 3441 ret = g_wifi->resetDriver(chipId, apFeature->baseFeature.ifName); 3442 EXPECT_EQ(ret, HDF_SUCCESS); 3443 sleep(RESET_TIME); 3444 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 3445 EXPECT_EQ(HDF_SUCCESS, ret); 3446} 3447};