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