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#include <benchmark/benchmark.h> 16#include <string> 17#include <vector> 18 19#include <gtest/gtest.h> 20#include <osal_mem.h> 21#include "hdf_base.h" 22#include "hdf_sbuf.h" 23#include "wifi_hal.h" 24#include "wifi_hal_ap_feature.h" 25#include "wifi_hal_base_feature.h" 26#include "wifi_hal_sta_feature.h" 27#include "securec.h" 28#include <servmgr_hdi.h> 29#include "v1_3/iwlan_interface.h" 30#include "wlan_impl.h" 31 32using namespace std; 33using namespace testing::ext; 34 35namespace { 36struct IWiFi *g_wifi = nullptr; 37const int32_t WLAN_TX_POWER = 160; 38const uint32_t WLAN_MIN_CHIPID = 0; 39const uint32_t WLAN_MAX_CHIPID = 2; 40const uint32_t IFNAME_MIN_NUM = 0; 41const uint32_t IFNAME_MAX_NUM = 32; 42const uint32_t MAX_IF_NAME_LENGTH = 16; 43const uint32_t SIZE = 4; 44const int32_t WLAN_BAND_2G = 0; 45const int32_t WLAN_MAX_NUM_STA_WITH_AP = 4; 46const uint32_t TEST_BUF_SIZE = 64; 47const uint32_t TEST_PARAM_BUF_SIZE = 64; 48const int32_t TEST_CMD = 123; 49const uint32_t RESET_TIME = 20; 50const int32_t WLAN_FREQ_MAX_NUM = 35; 51const int32_t DEFAULT_COMBO_SIZE = 6; 52const uint32_t MEAS_CHANNEL_TIME = 10; 53 54static struct IWlanInterface *g_wlanObj = nullptr; 55class wlanBenchmarkTest : public benchmark::Fixture { 56public: 57 void SetUp(const ::benchmark::State &state); 58 void TearDown(const ::benchmark::State &state); 59}; 60 61void wlanBenchmarkTest::SetUp(const ::benchmark::State &state) 62{ 63 int ret = WifiConstruct(&g_wifi); 64 ASSERT_EQ(HDF_SUCCESS, ret); 65} 66 67void wlanBenchmarkTest::TearDown(const ::benchmark::State &state) 68{ 69 int ret = WifiDestruct(&g_wifi); 70 ASSERT_EQ(HDF_SUCCESS, ret); 71} 72 73static void ParseScanResult(WifiScanResult *scanResult) 74{ 75 printf("ParseScanResult: flags=%d, caps=%d, freq=%d, beaconInt=%d,\n", 76 scanResult->flags, scanResult->caps, scanResult->freq, scanResult->beaconInt); 77 printf("ParseScanResult: qual=%d, beaconIeLen=%d, level=%d, age=%d, ieLen=%d,\n", 78 scanResult->qual, scanResult->beaconIeLen, scanResult->level, scanResult->age, scanResult->ieLen); 79} 80 81static int32_t HalCallbackEvent(uint32_t event, void *respData, const char *ifName) 82{ 83 (void)event; 84 if (respData == nullptr) { 85 return HDF_FAILURE; 86 } 87 printf("HalCallbackEvent ifName = %s, event = %u\n", ifName, event); 88 switch (event) { 89 case WIFI_EVENT_SCAN_DONE: 90 printf("HalCallbackEvent WIFI_EVENT_SCAN_DONE Process\n"); 91 break; 92 case WIFI_EVENT_SCAN_RESULT: 93 ParseScanResult((WifiScanResult *)respData); 94 break; 95 default: 96 break; 97 } 98 return HDF_SUCCESS; 99} 100 101/** 102 * @tc.name:wifiHalstartandstop001 103 * @tc.desc: Wifi hal start and stop 104 * @tc.type: FUNC 105 */ 106 107BENCHMARK_F(wlanBenchmarkTest, wifiHalstartandstop001)( 108 benchmark::State &st) 109{ 110 for (auto _ : st) { 111 g_wifi->start(g_wifi); 112 g_wifi->stop(g_wifi); 113 } 114} 115 116BENCHMARK_REGISTER_F(wlanBenchmarkTest, wifiHalstartandstop001)->Iterations(100)-> 117 Repetitions(3)->ReportAggregatesOnly(); 118 119/** 120 * @tc.name:wifiHalstartScan001 121 * @tc.desc: Wifi startscan 122 * @tc.type: FUNC 123 */ 124 125BENCHMARK_F(wlanBenchmarkTest, wifiHalstartScan001)( 126 benchmark::State &st) 127{ 128 g_wifi->start(g_wifi); 129 int ret; 130 struct IWiFiSta *staFeature = nullptr; 131 const char *ifName = "wlan0"; 132 WifiScan scan = {0}; 133 134 ret = g_wifi->registerEventCallback(HalCallbackEvent, ifName); 135 EXPECT_EQ(HDF_SUCCESS, ret); 136 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 137 EXPECT_EQ(HDF_SUCCESS, ret); 138 EXPECT_NE(nullptr, staFeature); 139 for (auto _ : st) { 140 ret = staFeature->startScan(nullptr, &scan); 141 } 142 EXPECT_NE(ret, HDF_SUCCESS); 143 sleep(10); 144 g_wifi->stop(g_wifi); 145} 146 147BENCHMARK_REGISTER_F(wlanBenchmarkTest, wifiHalstartScan001)->Iterations(100)-> 148 Repetitions(3)->ReportAggregatesOnly(); 149 150/** 151 * @tc.name:wifiHalStartChannelMeas001 152 * @tc.desc: Wifi hal StartChannelMeas 153 * @tc.type: FUNC 154 */ 155 156BENCHMARK_F(wlanBenchmarkTest, wifiHalStartChannelMeas001)( 157 benchmark::State &st) 158{ 159 int32_t rc = g_wlanObj->Start(g_wlanObj); 160 ASSERT_EQ(rc, HDF_SUCCESS); 161 const char *ifName = "wlan0"; 162 struct MeasChannelParam measChannelParam; 163 struct MeasChannelResult measChannelResult = {0}; 164 165 measChannelParam.channelId = 1; 166 measChannelParam.measTime = 15; 167 rc = g_wlanObj->StartChannelMeas(g_wlanObj, ifName, &measChannelParam); 168 bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT); 169 ASSERT_TRUE(flag); 170 sleep(MEAS_CHANNEL_TIME); 171 for (auto _ : st) { 172 rc = g_wlanObj->GetChannelMeasResult(g_wlanObj, ifName, &measChannelResult); 173 } 174 flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT || rc == HDF_DEV_ERR_NODATA); 175 ASSERT_TRUE(flag); 176 rc = g_wlanObj->Stop(g_wlanObj); 177 ASSERT_EQ(rc, HDF_SUCCESS); 178} 179 180BENCHMARK_REGISTER_F(wlanBenchmarkTest, wifiHalStartChannelMeas001)->Iterations(100)-> 181 Repetitions(3)->ReportAggregatesOnly(); 182 183/** 184 * @tc.name:wifiHalGetChannelMeasResult001 185 * @tc.desc: Wifi hal StartChannelMeas 186 * @tc.type: FUNC 187 */ 188 189BENCHMARK_F(wlanBenchmarkTest, wifiHalGetChannelMeasResult001)( 190 benchmark::State &st) 191{ 192 int32_t rc = g_wlanObj->Start(g_wlanObj); 193 ASSERT_EQ(rc, HDF_SUCCESS); 194 const char *ifName = "wlan0"; 195 struct MeasChannelParam measChannelParam; 196 struct MeasChannelResult measChannelResult = {0}; 197 198 measChannelParam.channelId = 1; 199 measChannelParam.measTime = 15; 200 rc = g_wlanObj->StartChannelMeas(g_wlanObj, ifName, &measChannelParam); 201 bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT); 202 ASSERT_TRUE(flag); 203 sleep(MEAS_CHANNEL_TIME); 204 for (auto _ : st) { 205 rc = g_wlanObj->GetChannelMeasResult(g_wlanObj, ifName, &measChannelResult); 206 } 207 flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT || rc == HDF_DEV_ERR_NODATA); 208 ASSERT_TRUE(flag); 209 rc = g_wlanObj->Stop(g_wlanObj); 210 ASSERT_EQ(rc, HDF_SUCCESS); 211} 212 213BENCHMARK_REGISTER_F(wlanBenchmarkTest, wifiHalGetChannelMeasResult001)->Iterations(100)-> 214 Repetitions(3)->ReportAggregatesOnly(); 215 216/** 217 * @tc.name:wifiHalcreateFeaturete001 218 * @tc.desc: Wifi hal create and destroy feature for ap mode benchmark test 219 * @tc.type: FUNC 220 */ 221 222BENCHMARK_F(wlanBenchmarkTest, wifiHalcreateFeaturete001)( 223 benchmark::State &st) 224{ 225 g_wifi->start(g_wifi); 226 int ret; 227 struct IWiFiAp *apFeature = nullptr; 228 for (auto _ : st) { 229 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 230 g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 231 } 232 EXPECT_EQ(HDF_SUCCESS, ret); 233 g_wifi->stop(g_wifi); 234} 235 236BENCHMARK_REGISTER_F(wlanBenchmarkTest, wifiHalcreateFeaturete001)->Iterations(100)-> 237 Repetitions(3)->ReportAggregatesOnly(); 238 239/** 240 * @tc.name:wifiHalcreateFeaturete002 241 * @tc.desc: Wifi hal create and destroy feature for sta mode benchmark test 242 * @tc.type: FUNC 243 */ 244 245BENCHMARK_F(wlanBenchmarkTest, wifiHalcreateFeaturete002)( 246 benchmark::State &st) 247{ 248 g_wifi->start(g_wifi); 249 int ret; 250 struct IWiFiSta *staFeature = nullptr; 251 for (auto _ : st) { 252 g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 253 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 254 } 255 EXPECT_EQ(HDF_SUCCESS, ret); 256 g_wifi->stop(g_wifi); 257} 258 259BENCHMARK_REGISTER_F(wlanBenchmarkTest, wifiHalcreateFeaturete002)->Iterations(100)-> 260 Repetitions(3)->ReportAggregatesOnly(); 261 262/** 263 * @tc.name: WifiHalGetFeatureByIfName001 264 * @tc.desc: Wifi hal get feature by ifname benchmark test 265 * @tc.type: FUNC 266 */ 267 268BENCHMARK_F(wlanBenchmarkTest, wifiHalGetFeatureByIfName001)( 269 benchmark::State &st) 270{ 271 g_wifi->start(g_wifi); 272 int ret; 273 struct IWiFiAp *apFeature = nullptr; 274 struct IWiFiAp *apFeatureGet = nullptr; 275 const char *ifName0 = "wlanTest"; 276 const char *ifName1 = "wlan0"; 277 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 278 EXPECT_EQ(HDF_SUCCESS, ret); 279 EXPECT_NE(nullptr, apFeature); 280 ret = g_wifi->getFeatureByIfName(ifName0, (struct IWiFiBaseFeature **)&apFeatureGet); 281 EXPECT_NE(HDF_SUCCESS, ret); 282 for (auto _ : st) { 283 ret = g_wifi->getFeatureByIfName(ifName1, (struct IWiFiBaseFeature **)&apFeatureGet); 284 } 285 EXPECT_EQ(HDF_SUCCESS, ret); 286 EXPECT_NE(nullptr, apFeatureGet); 287 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 288 EXPECT_EQ(HDF_SUCCESS, ret); 289 g_wifi->stop(g_wifi); 290} 291 292BENCHMARK_REGISTER_F(wlanBenchmarkTest, wifiHalGetFeatureByIfName001)->Iterations(100)-> 293 Repetitions(3)->ReportAggregatesOnly(); 294 295/** 296 * @tc.name: WifiHalRegisterEventCallback001 297 * @tc.desc: Wifi hal register callback benchmark test 298 * @tc.type: FUNC 299 */ 300 301BENCHMARK_F(wlanBenchmarkTest, wifiHalregisterEventCallback001)( 302 benchmark::State &st) 303{ 304 g_wifi->start(g_wifi); 305 int ret; 306 for (auto _ : st) { 307 ret = g_wifi->registerEventCallback(HalCallbackEvent, "wlan0"); 308 } 309 EXPECT_EQ(HDF_SUCCESS, ret); 310 g_wifi->stop(g_wifi); 311} 312 313BENCHMARK_REGISTER_F(wlanBenchmarkTest, wifiHalregisterEventCallback001)->Iterations(100)-> 314 Repetitions(3)->ReportAggregatesOnly(); 315 316/** 317 * @tc.name: WifiHalUnRegisterEventCallback001 318 * @tc.desc: Wifi hal unregister callback benchmark test 319 * @tc.type: FUNC 320 */ 321 322BENCHMARK_F(wlanBenchmarkTest, wifiHalunregisterEventCallback001)( 323 benchmark::State &st) 324{ 325 g_wifi->start(g_wifi); 326 int ret; 327 for (auto _ : st) { 328 ret = g_wifi->unregisterEventCallback(HalCallbackEvent, "wlan0"); 329 } 330 EXPECT_EQ(HDF_SUCCESS, ret); 331 g_wifi->stop(g_wifi); 332} 333 334BENCHMARK_REGISTER_F(wlanBenchmarkTest, wifiHalunregisterEventCallback001)->Iterations(100)-> 335 Repetitions(3)->ReportAggregatesOnly(); 336 337/** 338 * @tc.name: WifiHalGetNetworkIfaceName001 339 * @tc.desc: Wifi hal get network iface name benchmark test 340 * @tc.type: FUNC 341 */ 342 343BENCHMARK_F(wlanBenchmarkTest, WifiHalgetNetworkIfaceName001)( 344 benchmark::State &st) 345{ 346 g_wifi->start(g_wifi); 347 int ret; 348 const char *ifName=nullptr; 349 struct IWiFiAp *apFeature = nullptr; 350 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 351 EXPECT_EQ(HDF_SUCCESS, ret); 352 EXPECT_NE(nullptr, apFeature); 353 for (auto _ : st) { 354 ifName = apFeature->baseFeature.getNetworkIfaceName((const struct IWiFiBaseFeature *)apFeature); 355 } 356 EXPECT_NE(nullptr, ifName); 357 ret = strcmp(ifName, "wlan0"); 358 EXPECT_EQ(0, ret); 359 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 360 EXPECT_EQ(HDF_SUCCESS, ret); 361 g_wifi->stop(g_wifi); 362} 363 364BENCHMARK_REGISTER_F(wlanBenchmarkTest, WifiHalgetNetworkIfaceName001)->Iterations(100)-> 365 Repetitions(3)->ReportAggregatesOnly(); 366 367/** 368 * @tc.name: WifiHalGetGetFeatureType001 369 * @tc.desc: Wifi hal get feature type benchmark test 370 * @tc.type: FUNC 371 */ 372 373BENCHMARK_F(wlanBenchmarkTest, WifiHalgetFeatureType001)( 374 benchmark::State &st) 375{ 376 g_wifi->start(g_wifi); 377 int ret; 378 struct IWiFiAp *apFeature = nullptr; 379 int32_t type; 380 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 381 EXPECT_EQ(HDF_SUCCESS, ret); 382 EXPECT_NE(nullptr, apFeature); 383 for (auto _ : st) { 384 type = apFeature->baseFeature.getFeatureType((struct IWiFiBaseFeature *)apFeature); 385 } 386 EXPECT_EQ(PROTOCOL_80211_IFTYPE_AP, type); 387 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 388 EXPECT_EQ(HDF_SUCCESS, ret); 389 g_wifi->stop(g_wifi); 390} 391 392BENCHMARK_REGISTER_F(wlanBenchmarkTest, WifiHalgetFeatureType001)->Iterations(100)-> 393 Repetitions(3)->ReportAggregatesOnly(); 394 395 /** 396 * @tc.name: WifiHalSetMacAddress001 397 * @tc.desc: Wifi hal set Mac address benchmark test 398 * @tc.type: FUNC 399 */ 400 401BENCHMARK_F(wlanBenchmarkTest, WifiHalsetMacAddress001)( 402 benchmark::State &st) 403{ 404 g_wifi->start(g_wifi); 405 int ret; 406 struct IWiFiAp *apFeature = nullptr; 407 unsigned char errorMac[ETH_ADDR_LEN] = {0x11, 0x34, 0x56, 0x78, 0xab, 0xcd}; 408 unsigned char mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd}; 409 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 410 EXPECT_EQ(HDF_SUCCESS, ret); 411 EXPECT_NE(nullptr, apFeature); 412 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, nullptr, 0); 413 EXPECT_NE(HDF_SUCCESS, ret); 414 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, errorMac, ETH_ADDR_LEN); 415 EXPECT_NE(HDF_SUCCESS, ret); 416 for (auto _ : st) { 417 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, mac, ETH_ADDR_LEN); 418 } 419 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 420 EXPECT_EQ(HDF_SUCCESS, ret); 421 g_wifi->stop(g_wifi); 422} 423 424BENCHMARK_REGISTER_F(wlanBenchmarkTest, WifiHalsetMacAddress001)->Iterations(100)-> 425 Repetitions(3)->ReportAggregatesOnly(); 426 427/** 428 * @tc.name: WifiHalSetMacAddress002 429 * @tc.desc: Wifi hal set Mac address benchmark test 430 * @tc.type: FUNC 431 */ 432 433BENCHMARK_F(wlanBenchmarkTest, WifiHalsetMacAddress002)( 434 benchmark::State &st) 435{ 436 g_wifi->start(g_wifi); 437 int ret; 438 struct IWiFiSta *staFeature = nullptr; 439 unsigned char errorMac[ETH_ADDR_LEN] = {0}; 440 unsigned char mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd}; 441 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 442 EXPECT_EQ(HDF_SUCCESS, ret); 443 EXPECT_NE(nullptr, staFeature); 444 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, nullptr, 0); 445 EXPECT_NE(HDF_SUCCESS, ret); 446 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, errorMac, ETH_ADDR_LEN); 447 EXPECT_NE(HDF_SUCCESS, ret); 448 for (auto _ : st) { 449 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, mac, ETH_ADDR_LEN); 450 } 451 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 452 EXPECT_EQ(HDF_SUCCESS, ret); 453 g_wifi->stop(g_wifi); 454} 455 456BENCHMARK_REGISTER_F(wlanBenchmarkTest, WifiHalsetMacAddress002)->Iterations(100)-> 457 Repetitions(3)->ReportAggregatesOnly(); 458 459/** 460 * @tc.name: WifiHalSetTxPower001 461 * @tc.desc: Wifi hal set transmit power benchmark test 462 * @tc.type: FUNC 463 */ 464 465BENCHMARK_F(wlanBenchmarkTest, WifiHalsetTxPower001)( 466 benchmark::State &st) 467{ 468 g_wifi->start(g_wifi); 469 int ret; 470 struct IWiFiAp *apFeature = nullptr; 471 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 472 EXPECT_EQ(HDF_SUCCESS, ret); 473 EXPECT_NE(nullptr, apFeature); 474 ret = apFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)apFeature, 0); 475 EXPECT_NE(HDF_SUCCESS, ret); 476 for (auto _ : st) { 477 ret = apFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)apFeature, WLAN_TX_POWER); 478 } 479 EXPECT_EQ(HDF_SUCCESS, ret); 480 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 481 EXPECT_EQ(HDF_SUCCESS, ret); 482 g_wifi->stop(g_wifi); 483} 484 485BENCHMARK_REGISTER_F(wlanBenchmarkTest, WifiHalsetTxPower001)->Iterations(100)-> 486 Repetitions(3)->ReportAggregatesOnly(); 487 488/** 489 * @tc.name: WifiHalSetCountryCode001 490 * @tc.desc: Wifi hal set country code benchmark test 491 * @tc.type: FUNC 492 */ 493 494BENCHMARK_F(wlanBenchmarkTest, WifiHalsetCountryCode001)( 495 benchmark::State &st) 496{ 497 g_wifi->start(g_wifi); 498 int ret; 499 struct IWiFiAp *apFeature = nullptr; 500 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 501 EXPECT_EQ(HDF_SUCCESS, ret); 502 EXPECT_NE(nullptr, apFeature); 503 ret = apFeature->setCountryCode(apFeature, nullptr, 0); 504 EXPECT_NE(HDF_SUCCESS, ret); 505 for (auto _ : st) { 506 ret = apFeature->setCountryCode(apFeature, "CN", 2); 507 } 508 EXPECT_EQ(HDF_SUCCESS, ret); 509 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 510 EXPECT_EQ(HDF_SUCCESS, ret); 511 g_wifi->stop(g_wifi); 512} 513 514BENCHMARK_REGISTER_F(wlanBenchmarkTest, WifiHalsetCountryCode001)->Iterations(100)-> 515 Repetitions(3)->ReportAggregatesOnly(); 516 517/** 518 * @tc.name: WifiHalGetIfNamesByChipId001 519 * @tc.desc: Obtain all ifNames and the number of the current chip 520 * @tc.type: FUNC 521 */ 522 523BENCHMARK_F(wlanBenchmarkTest, WifiHalgetIfNamesByChipId001)( 524 benchmark::State &st) 525{ 526 g_wifi->start(g_wifi); 527 int ret; 528 struct IWiFiSta *staFeature = nullptr; 529 char *ifNames = nullptr; 530 unsigned int num = 0; 531 unsigned char chipId = 0; 532 uint8_t i; 533 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 534 EXPECT_EQ(HDF_SUCCESS, ret); 535 EXPECT_NE(nullptr, staFeature); 536 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId); 537 ASSERT_TRUE(chipId <= WLAN_MAX_CHIPID && chipId >= WLAN_MIN_CHIPID); 538 EXPECT_EQ(HDF_SUCCESS, ret); 539 ret = staFeature->baseFeature.getIfNamesByChipId(chipId, nullptr, nullptr); 540 EXPECT_NE(HDF_SUCCESS, ret); 541 for (auto _ : st) { 542 ret = staFeature->baseFeature.getIfNamesByChipId(chipId, &ifNames, &num); 543 } 544 EXPECT_NE(nullptr, ifNames); 545 EXPECT_EQ(HDF_SUCCESS, ret); 546 ASSERT_TRUE(num <= IFNAME_MAX_NUM && num >= IFNAME_MIN_NUM); 547 for (i = 0; i < num; i++) { 548 EXPECT_EQ(0, strncmp("wlan", ifNames + i * MAX_IF_NAME_LENGTH, SIZE)); 549 } 550 free(ifNames); 551 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 552 EXPECT_EQ(HDF_SUCCESS, ret); 553 g_wifi->stop(g_wifi); 554} 555 556BENCHMARK_REGISTER_F(wlanBenchmarkTest, WifiHalgetIfNamesByChipId001)->Iterations(100)-> 557 Repetitions(3)->ReportAggregatesOnly(); 558 559/** 560 * @tc.name: WifiHalGetSupportFeature001 561 * @tc.desc: Get supported features 562 * @tc.type: FUNC 563 */ 564 565BENCHMARK_F(wlanBenchmarkTest, WifiHalgetSupportFeature001)( 566 benchmark::State &st) 567{ 568 g_wifi->start(g_wifi); 569 int ret; 570 uint8_t supportTest[PROTOCOL_80211_IFTYPE_NUM] = {0}; 571 uint8_t support[PROTOCOL_80211_IFTYPE_NUM + 1] = {0}; 572 ret = g_wifi->getSupportFeature(nullptr, 0); 573 EXPECT_NE(HDF_SUCCESS, ret); 574 ret = g_wifi->getSupportFeature(supportTest, PROTOCOL_80211_IFTYPE_NUM); 575 EXPECT_NE(HDF_SUCCESS, ret); 576 for (auto _ : st) { 577 ret = g_wifi->getSupportFeature(support, PROTOCOL_80211_IFTYPE_NUM + 1); 578 } 579 EXPECT_EQ(HDF_SUCCESS, ret); 580 g_wifi->stop(g_wifi); 581} 582 583BENCHMARK_REGISTER_F(wlanBenchmarkTest, WifiHalgetSupportFeature001)->Iterations(100)-> 584 Repetitions(3)->ReportAggregatesOnly(); 585 586/** 587 * @tc.name: WifiHalGetSupportCombo001 588 * @tc.desc: Get supported combo 589 * @tc.type: FUNC 590 */ 591 592BENCHMARK_F(wlanBenchmarkTest, WifiHalgetSupportCombo001)( 593 benchmark::State &st) 594{ 595 g_wifi->start(g_wifi); 596 int ret; 597 uint8_t support[PROTOCOL_80211_IFTYPE_NUM + 1] = {0}; 598 uint64_t combo[DEFAULT_COMBO_SIZE] = {0}; 599 ret = g_wifi->getSupportFeature(support, PROTOCOL_80211_IFTYPE_NUM + 1); 600 EXPECT_EQ(HDF_SUCCESS, ret); 601 for (auto _ : st) { 602 ret = g_wifi->getSupportCombo(nullptr, 0); 603 } 604 EXPECT_NE(HDF_SUCCESS, ret); 605 ret = g_wifi->getSupportCombo(combo, DEFAULT_COMBO_SIZE); 606 if (support[PROTOCOL_80211_IFTYPE_NUM] == 0) { 607 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); 608 } else { 609 EXPECT_EQ(HDF_SUCCESS, ret); 610 } 611 g_wifi->stop(g_wifi); 612} 613 614BENCHMARK_REGISTER_F(wlanBenchmarkTest, WifiHalgetSupportCombo001)->Iterations(100)-> 615 Repetitions(3)->ReportAggregatesOnly(); 616 617/** 618 * @tc.name: WifiHalGetDeviceMacAddress001 619 * @tc.desc: Get device Mac address for ap mode 620 * @tc.type: FUNC 621 */ 622 623BENCHMARK_F(wlanBenchmarkTest, WifiHalgetDeviceMacAddress001)( 624 benchmark::State &st) 625{ 626 g_wifi->start(g_wifi); 627 int ret; 628 struct IWiFiAp *apFeature = nullptr; 629 unsigned char mac[ETH_ADDR_LEN] = {0}; 630 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 631 EXPECT_EQ(HDF_SUCCESS, ret); 632 EXPECT_NE(nullptr, apFeature); 633 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, nullptr, 0); 634 EXPECT_NE(HDF_SUCCESS, ret); 635 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, mac, ETH_ADDR_LEN - 1); 636 EXPECT_NE(HDF_SUCCESS, ret); 637 for (auto _ : st) { 638 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, mac, ETH_ADDR_LEN); 639 } 640 EXPECT_NE(HDF_FAILURE, ret); 641 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 642 EXPECT_EQ(HDF_SUCCESS, ret); 643 g_wifi->stop(g_wifi); 644} 645 646BENCHMARK_REGISTER_F(wlanBenchmarkTest, WifiHalgetDeviceMacAddress001)->Iterations(100)-> 647 Repetitions(3)->ReportAggregatesOnly(); 648 649/** 650 * @tc.name: WifiHalGetDeviceMacAddress002 651 * @tc.desc: Get device Mac address for sta mode 652 * @tc.type: FUNC 653 */ 654 655BENCHMARK_F(wlanBenchmarkTest, WifiHalgetDeviceMacAddress002)( 656 benchmark::State &st) 657{ 658 g_wifi->start(g_wifi); 659 int ret; 660 struct IWiFiSta *staFeature = nullptr; 661 unsigned char mac[ETH_ADDR_LEN] = {0}; 662 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 663 EXPECT_EQ(HDF_SUCCESS, ret); 664 EXPECT_NE(nullptr, staFeature); 665 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, nullptr, 0); 666 EXPECT_NE(HDF_SUCCESS, ret); 667 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, mac, ETH_ADDR_LEN - 1); 668 EXPECT_NE(HDF_SUCCESS, ret); 669 for (auto _ : st) { 670 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, mac, ETH_ADDR_LEN); 671 } 672 EXPECT_NE(HDF_FAILURE, ret); 673 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 674 EXPECT_EQ(HDF_SUCCESS, ret); 675 g_wifi->stop(g_wifi); 676} 677 678BENCHMARK_REGISTER_F(wlanBenchmarkTest, WifiHalgetDeviceMacAddress002)->Iterations(100)-> 679 Repetitions(3)->ReportAggregatesOnly(); 680 681/** 682 * @tc.name: WifiHaGetValidFreqsWithBand001 683 * @tc.desc: Get available frequencies 684 * @tc.type: FUNC 685 */ 686 687BENCHMARK_F(wlanBenchmarkTest, WifiHalgetValidFreqsWithBand001)( 688 benchmark::State &st) 689{ 690 g_wifi->start(g_wifi); 691 int ret; 692 struct IWiFiAp *apFeature = nullptr; 693 int32_t freq[WLAN_FREQ_MAX_NUM] = {0}; 694 uint32_t num = 0; 695 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 696 EXPECT_EQ(HDF_SUCCESS, ret); 697 EXPECT_NE(nullptr, apFeature); 698 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature, 699 WLAN_BAND_2G, nullptr, 0, nullptr); 700 EXPECT_NE(HDF_SUCCESS, ret); 701 for (auto _ : st) { 702 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature, 703 WLAN_BAND_2G, freq, WLAN_FREQ_MAX_NUM, &num); 704 } 705 EXPECT_EQ(HDF_SUCCESS, ret); 706 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 707 EXPECT_EQ(HDF_SUCCESS, ret); 708 g_wifi->stop(g_wifi); 709} 710 711BENCHMARK_REGISTER_F(wlanBenchmarkTest, WifiHalgetValidFreqsWithBand001)->Iterations(100)-> 712 Repetitions(3)->ReportAggregatesOnly(); 713 714/** 715 * @tc.name: WifiHalGetAssociatedStas001 716 * @tc.desc: Get asscociated STA info benchmark test 717 * @tc.type: FUNC 718 */ 719 720BENCHMARK_F(wlanBenchmarkTest, WifiHalgetAssociatedStas001)( 721 benchmark::State &st) 722{ 723 g_wifi->start(g_wifi); 724 int ret; 725 struct IWiFiAp *apFeature = nullptr; 726 struct StaInfo staInfo[WLAN_MAX_NUM_STA_WITH_AP] = {{0}}; 727 uint32_t num = 0; 728 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 729 EXPECT_EQ(HDF_SUCCESS, ret); 730 EXPECT_NE(nullptr, apFeature); 731 ret = apFeature->getAssociatedStas(apFeature, nullptr, 0, nullptr); 732 EXPECT_NE(HDF_SUCCESS, ret); 733 for (auto _ : st) { 734 ret = apFeature->getAssociatedStas(apFeature, staInfo, WLAN_MAX_NUM_STA_WITH_AP, &num); 735 } 736 EXPECT_EQ(HDF_SUCCESS, ret); 737 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 738 EXPECT_EQ(HDF_SUCCESS, ret); 739 g_wifi->stop(g_wifi); 740} 741 742BENCHMARK_REGISTER_F(wlanBenchmarkTest, WifiHalgetAssociatedStas001)->Iterations(100)-> 743 Repetitions(3)->ReportAggregatesOnly(); 744 745/** 746 * @tc.name: WifiHalSetScanningMacAddress001 747 * @tc.desc: Set Mac address scanning benchmark test 748 * @tc.type: FUNC 749 */ 750 751BENCHMARK_F(wlanBenchmarkTest, WifiHalsetScanningMacAddress001)( 752 benchmark::State &st) 753{ 754 g_wifi->start(g_wifi); 755 int ret; 756 struct IWiFiSta *staFeature = nullptr; 757 unsigned char scanMac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd}; 758 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 759 EXPECT_EQ(HDF_SUCCESS, ret); 760 EXPECT_NE(nullptr, staFeature); 761 ret = staFeature->setScanningMacAddress(staFeature, nullptr, 0); 762 EXPECT_NE(HDF_SUCCESS, ret); 763 for (auto _ : st) { 764 ret = staFeature->setScanningMacAddress(staFeature, scanMac, ETH_ADDR_LEN); 765 } 766 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret); 767 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 768 EXPECT_EQ(HDF_SUCCESS, ret); 769 g_wifi->stop(g_wifi); 770} 771 772BENCHMARK_REGISTER_F(wlanBenchmarkTest, WifiHalsetScanningMacAddress001)->Iterations(100)-> 773 Repetitions(3)->ReportAggregatesOnly(); 774 775/** 776 * @tc.name: WifiHalGetNetdevInfo001 777 * @tc.desc: Wifi hdi get netdev info benchmark test 778 * @tc.type: FUNC 779 */ 780 781BENCHMARK_F(wlanBenchmarkTest, WifiHalgetNetDevInfo001)( 782 benchmark::State &st) 783{ 784 g_wifi->start(g_wifi); 785 int ret; 786 struct NetDeviceInfoResult netDeviceInfoResult; 787 (void)memset_s(&netDeviceInfoResult, sizeof(struct NetDeviceInfoResult), 0, sizeof(struct NetDeviceInfoResult)); 788 for (auto _ : st) { 789 ret = g_wifi->getNetDevInfo(&netDeviceInfoResult); 790 } 791 EXPECT_EQ(ret, HDF_SUCCESS); 792 g_wifi->stop(g_wifi); 793} 794 795BENCHMARK_REGISTER_F(wlanBenchmarkTest, WifiHalgetNetDevInfo001)->Iterations(100)-> 796 Repetitions(3)->ReportAggregatesOnly(); 797 798 799/** 800 * @tc.name: GetPowerModeTest001 801 * @tc.desc: Wifi hdi get power mode function test 802 * @tc.type: FUNC 803 */ 804 805BENCHMARK_F(wlanBenchmarkTest, GetPowerMode001)( 806 benchmark::State &st) 807{ 808 g_wifi->start(g_wifi); 809 int32_t ret; 810 struct IWiFiAp *apFeature = nullptr; 811 const char *ifName = "eth0"; 812 uint8_t mode; 813 814 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 815 EXPECT_EQ(ret, HDF_SUCCESS); 816 EXPECT_NE(apFeature, nullptr); 817 for (auto _ : st) { 818 ret = g_wifi->getPowerMode(nullptr, &mode); 819 } 820 EXPECT_NE(ret, HDF_SUCCESS); 821 ret = g_wifi->getPowerMode(ifName, nullptr); 822 EXPECT_NE(ret, HDF_SUCCESS); 823 ret = g_wifi->getPowerMode(ifName, &mode); 824 EXPECT_NE(ret, HDF_SUCCESS); 825 ret = g_wifi->getPowerMode(apFeature->baseFeature.ifName, nullptr); 826 EXPECT_NE(ret, HDF_SUCCESS); 827 ret = g_wifi->getPowerMode(apFeature->baseFeature.ifName, &mode); 828 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 829 ASSERT_TRUE(flag); 830 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 831 EXPECT_EQ(ret, HDF_SUCCESS); 832 g_wifi->stop(g_wifi); 833} 834 835BENCHMARK_REGISTER_F(wlanBenchmarkTest, GetPowerMode001)->Iterations(100)-> 836 Repetitions(3)->ReportAggregatesOnly(); 837 838/** 839 * @tc.name: SetPowerModeTest001 840 * @tc.desc: Wifi hdi set power mode function test 841 * @tc.type: FUNC 842 */ 843 844BENCHMARK_F(wlanBenchmarkTest, SetPowerModeTest001)( 845 benchmark::State &st) 846{ 847 g_wifi->start(g_wifi); 848 int32_t ret; 849 struct IWiFiAp *apFeature = nullptr; 850 const char *ifName = "eth0"; 851 852 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 853 EXPECT_EQ(ret, HDF_SUCCESS); 854 EXPECT_NE(apFeature, nullptr); 855 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_SLEEPING); 856 EXPECT_NE(ret, HDF_SUCCESS); 857 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_SLEEPING); 858 EXPECT_NE(ret, HDF_SUCCESS); 859 for (auto _ : st) { 860 ret = g_wifi->setPowerMode(apFeature->baseFeature.ifName, WIFI_POWER_MODE_SLEEPING); 861 } 862 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 863 ASSERT_TRUE(flag); 864 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 865 EXPECT_EQ(ret, HDF_SUCCESS); 866 g_wifi->stop(g_wifi); 867} 868 869BENCHMARK_REGISTER_F(wlanBenchmarkTest, SetPowerModeTest001)->Iterations(100)-> 870 Repetitions(3)->ReportAggregatesOnly(); 871 872/** 873 * @tc.name: SetProjectionScreenParam001 874 * @tc.desc: wifi hal config projection screen function test 875 * @tc.type: FUNC 876 */ 877 878BENCHMARK_F(wlanBenchmarkTest, SetProjectionScreenParam001)( 879 benchmark::State &st) 880{ 881 g_wifi->start(g_wifi); 882 int32_t ret; 883 bool flag; 884 struct IWiFiAp *apFeature = nullptr; 885 ProjectionScreenParam *param; 886 887 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE); 888 EXPECT_NE(nullptr, param); 889 param->cmdId = TEST_CMD; 890 param->bufLen = 1; 891 param->buf[0] = 0; 892 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 893 EXPECT_EQ(ret, HDF_SUCCESS); 894 ret = g_wifi->setProjectionScreenParam(nullptr, nullptr); 895 EXPECT_NE(ret, HDF_SUCCESS); 896 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, nullptr); 897 EXPECT_NE(ret, HDF_SUCCESS); 898 ret = g_wifi->setProjectionScreenParam(nullptr, param); 899 EXPECT_NE(ret, HDF_SUCCESS); 900 for (auto _ : st) { 901 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, param); 902 } 903 EXPECT_NE(ret, HDF_SUCCESS); 904 for (int i = CMD_CLOSE_GO_CAC; i <= CMD_ID_CTRL_ROAM_CHANNEL; i++) { 905 param->cmdId = i; 906 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, param); 907 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 908 ASSERT_TRUE(flag); 909 } 910 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 911 EXPECT_EQ(ret, HDF_SUCCESS); 912 OsalMemFree(param); 913 g_wifi->stop(g_wifi); 914} 915 916BENCHMARK_REGISTER_F(wlanBenchmarkTest, SetProjectionScreenParam001)->Iterations(100)-> 917 Repetitions(3)->ReportAggregatesOnly(); 918 919 920/** 921 * @tc.name: SendCmdIoctl001 922 * @tc.desc: wifi hal send ioctl command function test 923 * @tc.type: FUNC 924 */ 925 926BENCHMARK_F(wlanBenchmarkTest, SendCmdIoctl001)( 927 benchmark::State &st) 928{ 929 g_wifi->start(g_wifi); 930 int32_t cmdId = 0; 931 int32_t ret; 932 bool flag; 933 struct IWiFiAp *apFeature = nullptr; 934 int8_t data[TEST_BUF_SIZE] = {0}; 935 const char *ifName = "wlan0"; 936 937 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 938 EXPECT_EQ(ret, HDF_SUCCESS); 939 ret = g_wifi->sendCmdIoctl(nullptr, cmdId, nullptr, TEST_BUF_SIZE); 940 EXPECT_NE(ret, HDF_SUCCESS); 941 ret = g_wifi->sendCmdIoctl(ifName, cmdId, nullptr, TEST_BUF_SIZE); 942 EXPECT_NE(ret, HDF_SUCCESS); 943 for (auto _ : st) { 944 ret = g_wifi->sendCmdIoctl(nullptr, cmdId, data, TEST_BUF_SIZE); 945 } 946 EXPECT_NE(ret, HDF_SUCCESS); 947 for (cmdId = CMD_HID2D_MODULE_INIT; cmdId <= CMD_SET_CHAN_ADJUST; cmdId++) { 948 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE); 949 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 950 ASSERT_TRUE(flag); 951 } 952 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 953 EXPECT_EQ(ret, HDF_SUCCESS); 954 g_wifi->stop(g_wifi); 955} 956 957BENCHMARK_REGISTER_F(wlanBenchmarkTest, SendCmdIoctl001)->Iterations(100)-> 958 Repetitions(3)->ReportAggregatesOnly(); 959 960/** 961 * @tc.name: GetStationInfo001 962 * @tc.desc: Wifi hdi get station information function test 963 * @tc.type: FUNC 964 */ 965 966BENCHMARK_F(wlanBenchmarkTest, GetStationInfo001)( 967 benchmark::State &st) 968{ 969 g_wifi->start(g_wifi); 970 int32_t ret; 971 StationInfo info; 972 bool flag; 973 uint8_t mac[ETH_ADDR_LEN] = {0}; 974 struct IWiFiAp *apFeature = nullptr; 975 const char *ifName = "wlan0"; 976 977 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature); 978 EXPECT_EQ(ret, HDF_SUCCESS); 979 ret = g_wifi->getStationInfo(nullptr, nullptr, nullptr, ETH_ADDR_LEN); 980 EXPECT_NE(ret, HDF_SUCCESS); 981 ret = g_wifi->getStationInfo(ifName, nullptr, nullptr, ETH_ADDR_LEN); 982 EXPECT_NE(ret, HDF_SUCCESS); 983 ret = g_wifi->getStationInfo(nullptr, &info, nullptr, ETH_ADDR_LEN); 984 EXPECT_NE(ret, HDF_SUCCESS); 985 ret = g_wifi->getStationInfo(nullptr, nullptr, mac, ETH_ADDR_LEN); 986 EXPECT_NE(ret, HDF_SUCCESS); 987 ret = g_wifi->getStationInfo(ifName, &info, nullptr, ETH_ADDR_LEN); 988 EXPECT_NE(ret, HDF_SUCCESS); 989 ret = g_wifi->getStationInfo(nullptr, &info, mac, ETH_ADDR_LEN); 990 EXPECT_NE(ret, HDF_SUCCESS); 991 ret = g_wifi->getStationInfo(ifName, nullptr, mac, ETH_ADDR_LEN); 992 EXPECT_NE(ret, HDF_SUCCESS); 993 for (auto _ : st) { 994 ret = g_wifi->getStationInfo(ifName, &info, mac, ETH_ADDR_LEN); 995 } 996 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT); 997 ASSERT_TRUE(flag); 998 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature); 999 EXPECT_EQ(ret, HDF_SUCCESS); 1000 g_wifi->stop(g_wifi); 1001} 1002 1003BENCHMARK_REGISTER_F(wlanBenchmarkTest, GetStationInfo001)->Iterations(100)-> 1004 Repetitions(3)->ReportAggregatesOnly(); 1005 1006/** 1007 * @tc.name: HalGetChipId001 1008 * @tc.desc: wifi hal get chip ID function test 1009 * @tc.type: FUNC 1010 */ 1011 1012BENCHMARK_F(wlanBenchmarkTest, GetChipId001)( 1013 benchmark::State &st) 1014{ 1015 g_wifi->start(g_wifi); 1016 int32_t ret; 1017 struct IWiFiSta *staFeature = nullptr; 1018 unsigned char chipId = 0; 1019 1020 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1021 EXPECT_EQ(HDF_SUCCESS, ret); 1022 EXPECT_NE(nullptr, staFeature); 1023 1024 ret = staFeature->baseFeature.getChipId(nullptr, &chipId); 1025 EXPECT_NE(HDF_SUCCESS, ret); 1026 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, nullptr); 1027 EXPECT_NE(HDF_SUCCESS, ret); 1028 for (auto _ : st) { 1029 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId); 1030 } 1031 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE); 1032 EXPECT_EQ(HDF_SUCCESS, ret); 1033 1034 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1035 EXPECT_EQ(HDF_SUCCESS, ret); 1036 g_wifi->stop(g_wifi); 1037} 1038 1039BENCHMARK_REGISTER_F(wlanBenchmarkTest, GetChipId001)->Iterations(100)-> 1040 Repetitions(3)->ReportAggregatesOnly(); 1041 1042/** 1043 * @tc.name: ResetDriver001 1044 * @tc.desc: wifi hal reset driver function test 1045 * @tc.type: FUNC 1046 */ 1047 1048BENCHMARK_F(wlanBenchmarkTest, ResetDriver001)( 1049 benchmark::State &st) 1050{ 1051 g_wifi->start(g_wifi); 1052 int32_t ret; 1053 struct IWiFiSta *staFeature = nullptr; 1054 uint8_t chipId = 0; 1055 uint8_t chipIdInvalid = 20; 1056 1057 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature); 1058 EXPECT_EQ(HDF_SUCCESS, ret); 1059 EXPECT_NE(nullptr, staFeature); 1060 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId); 1061 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE); 1062 EXPECT_EQ(HDF_SUCCESS, ret); 1063 for (auto _ : st) { 1064 ret = g_wifi->resetDriver(chipIdInvalid, "wlan0"); 1065 } 1066 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 1067 ret = g_wifi->resetDriver(chipId, nullptr); 1068 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret); 1069 ret = g_wifi->resetDriver(chipId, staFeature->baseFeature.ifName); 1070 EXPECT_EQ(HDF_SUCCESS, ret); 1071 sleep(RESET_TIME); 1072 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature); 1073 EXPECT_EQ(HDF_SUCCESS, ret); 1074 g_wifi->stop(g_wifi); 1075} 1076 1077BENCHMARK_REGISTER_F(wlanBenchmarkTest, ResetDriver001)->Iterations(100)-> 1078 Repetitions(3)->ReportAggregatesOnly(); 1079} 1080BENCHMARK_MAIN(); 1081 1082