1 /*
2 * Copyright (c) 2021 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 <cstdint>
16 #include <gtest/gtest.h>
17 #include <securec.h>
18 #include "hdf_base.h"
19 #include "hdf_uhdf_test.h"
20 #include "hdf_wifi_test.h"
21 #include "hdf_sbuf.h"
22 #include "wifi_hal.h"
23 #include "wifi_hal_ap_feature.h"
24 #include "wifi_hal_base_feature.h"
25 #include "wifi_hal_sta_feature.h"
26
27 using namespace testing::ext;
28
29 namespace HalTest {
30 struct IWiFi *g_wifi = nullptr;
31 const int32_t WLAN_TX_POWER = 160;
32 const uint32_t WLAN_MIN_CHIPID = 0;
33 const uint32_t WLAN_MAX_CHIPID = 2;
34 const uint32_t IFNAME_MIN_NUM = 0;
35 const uint32_t IFNAME_MAX_NUM = 32;
36 const uint32_t MAX_IF_NAME_LENGTH = 16;
37 const uint32_t SIZE = 4;
38 const uint32_t SLEEP_TIME = 5;
39 const uint32_t RESET_TIME = 15;
40 const int32_t WLAN_BAND_2G = 0;
41 const int32_t WLAN_FREQ_MAX_NUM = 14;
42 const int32_t WLAN_MAX_NUM_STA_WITH_AP = 4;
43 const uint32_t DEFAULT_COMBO_SIZE = 10;
44
45 class WifiHalTest : public testing::Test {
46 public:
47 static void SetUpTestCase();
48 static void TearDownTestCase();
49 void SetUp();
50 void TearDown();
51 };
52
SetUpTestCase()53 void WifiHalTest::SetUpTestCase()
54 {
55 int ret;
56
57 ret = WifiConstruct(&g_wifi);
58 ASSERT_EQ(HDF_SUCCESS, ret);
59 }
60
TearDownTestCase()61 void WifiHalTest::TearDownTestCase()
62 {
63 int ret;
64
65 ret = WifiDestruct(&g_wifi);
66 ASSERT_EQ(HDF_SUCCESS, ret);
67 }
68
SetUp()69 void WifiHalTest::SetUp()
70 {
71 int ret;
72
73 ret = g_wifi->start(nullptr);
74 ASSERT_EQ(HDF_ERR_INVALID_PARAM, ret);
75 ret = g_wifi->start(g_wifi);
76 ASSERT_EQ(HDF_SUCCESS, ret);
77 }
78
TearDown()79 void WifiHalTest::TearDown()
80 {
81 int ret;
82
83 ret = g_wifi->stop(nullptr);
84 ASSERT_EQ(HDF_ERR_INVALID_PARAM, ret);
85 ret = g_wifi->stop(g_wifi);
86 ASSERT_EQ(HDF_SUCCESS, ret);
87 }
88
ParseScanResult(WifiScanResult * scanResult)89 static void ParseScanResult(WifiScanResult *scanResult)
90 {
91 printf("ParseScanResult: flags=%d, caps=%d, freq=%d, beaconInt=%d,\n",
92 scanResult->flags, scanResult->caps, scanResult->freq, scanResult->beaconInt);
93 printf("ParseScanResult: qual=%d, beaconIeLen=%d, level=%d, age=%d, ieLen=%d,\n",
94 scanResult->qual, scanResult->beaconIeLen, scanResult->level, scanResult->age, scanResult->ieLen);
95 }
96
HalCallbackEvent(uint32_t event,void * respData,const char * ifName)97 static int32_t HalCallbackEvent(uint32_t event, void *respData, const char *ifName)
98 {
99 (void)event;
100 if (respData == nullptr) {
101 return HDF_FAILURE;
102 }
103 printf("HalCallbackEvent ifName = %s, event = %d\n", ifName, event);
104 switch (event) {
105 case WIFI_EVENT_SCAN_DONE:
106 printf("HalCallbackEvent WIFI_EVENT_SCAN_DONE Process\n");
107 break;
108 case WIFI_EVENT_SCAN_RESULT:
109 ParseScanResult((WifiScanResult *)respData);
110 break;
111 default:
112 break;
113 }
114 return HDF_SUCCESS;
115 }
116
117 /**
118 * @tc.name: WifiHalCreateAndDestroyFeature001
119 * @tc.desc: Wifi hal create and destroy feature function test
120 * @tc.type: FUNC
121 */
122 HWTEST_F(WifiHalTest, WifiHalCreateAndDestroyFeature001, Function | MediumTest | Level1)
123 {
124 int ret;
125 struct IWiFiAp *apFeature = nullptr;
126
127 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
128 EXPECT_EQ(HDF_SUCCESS, ret);
129 EXPECT_NE(nullptr, apFeature);
130
131 ret = g_wifi->destroyFeature(nullptr);
132 EXPECT_NE(HDF_SUCCESS, ret);
133 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
134 EXPECT_EQ(HDF_SUCCESS, ret);
135 }
136
137 /**
138 * @tc.name: WifiHalCreateAndDestroyFeature002
139 * @tc.desc: Wifi hal create and destroy feature function test
140 * @tc.type: FUNC
141 */
142 HWTEST_F(WifiHalTest, WifiHalCreateAndDestroyFeature002, Function | MediumTest | Level1)
143 {
144 int ret;
145 struct IWiFiSta *staFeature = nullptr;
146
147 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
148 EXPECT_EQ(HDF_SUCCESS, ret);
149 EXPECT_NE(nullptr, staFeature);
150
151 ret = g_wifi->destroyFeature(nullptr);
152 EXPECT_NE(HDF_SUCCESS, ret);
153 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
154 EXPECT_EQ(HDF_SUCCESS, ret);
155 }
156
157 /**
158 * @tc.name: WifiHalGetFeatureByIfName001
159 * @tc.desc: Wifi hal get feature by ifname function test
160 * @tc.type: FUNC
161 */
162 HWTEST_F(WifiHalTest, WifiHalGetFeatureByIfName001, Function | MediumTest | Level1)
163 {
164 int ret;
165 struct IWiFiAp *apFeature = nullptr;
166 struct IWiFiAp *apFeatureGet = nullptr;
167 const char *ifName0 = "wlanTest";
168 const char *ifName1 = "wlan0";
169
170 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
171 EXPECT_EQ(HDF_SUCCESS, ret);
172 EXPECT_NE(nullptr, apFeature);
173 ret = g_wifi->getFeatureByIfName(ifName0, (struct IWiFiBaseFeature **)&apFeatureGet);
174 EXPECT_NE(HDF_SUCCESS, ret);
175 ret = g_wifi->getFeatureByIfName(ifName1, (struct IWiFiBaseFeature **)&apFeatureGet);
176 EXPECT_EQ(HDF_SUCCESS, ret);
177 EXPECT_NE(nullptr, apFeatureGet);
178
179 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
180 EXPECT_EQ(HDF_SUCCESS, ret);
181 }
182
183 /**
184 * @tc.name: WifiHalRegisterEventCallback001
185 * @tc.desc: Wifi hal register callback function test
186 * @tc.type: FUNC
187 */
188 HWTEST_F(WifiHalTest, WifiHalRegisterEventCallback001, Function | MediumTest | Level1)
189 {
190 int ret;
191
192 ret = g_wifi->registerEventCallback(HalCallbackEvent, "wlan0");
193 EXPECT_EQ(HDF_SUCCESS, ret);
194 }
195
196 /**
197 * @tc.name: WifiHalUnRegisterEventCallback001
198 * @tc.desc: Wifi hal unregister callback function test
199 * @tc.type: FUNC
200 */
201 HWTEST_F(WifiHalTest, WifiHalUnRegisterEventCallback001, Function | MediumTest | Level1)
202 {
203 int ret;
204
205 ret = g_wifi->unregisterEventCallback(HalCallbackEvent, "wlan0");
206 EXPECT_EQ(HDF_SUCCESS, ret);
207 }
208
209 /**
210 * @tc.name: WifiHalGetNetworkIfaceName001
211 * @tc.desc: Wifi hal get network iface name function test
212 * @tc.type: FUNC
213 */
214 HWTEST_F(WifiHalTest, WifiHalGetNetworkIfaceName001, Function | MediumTest | Level1)
215 {
216 int ret;
217 struct IWiFiAp *apFeature = nullptr;
218
219 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
220 EXPECT_EQ(HDF_SUCCESS, ret);
221 EXPECT_NE(nullptr, apFeature);
222 const char *ifName = apFeature->baseFeature.getNetworkIfaceName((const struct IWiFiBaseFeature *)apFeature);
223 EXPECT_NE(nullptr, ifName);
224 ret = strcmp(ifName, "wlan0");
225 EXPECT_EQ(0, ret);
226
227 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
228 EXPECT_EQ(HDF_SUCCESS, ret);
229 }
230
231 /**
232 * @tc.name: WifiHalGetGetFeatureType001
233 * @tc.desc: Wifi hal get feature type function test
234 * @tc.type: FUNC
235 */
236 HWTEST_F(WifiHalTest, WifiHalGetGetFeatureType001, Function | MediumTest | Level1)
237 {
238 int ret;
239 struct IWiFiAp *apFeature = nullptr;
240 int32_t type;
241
242 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
243 EXPECT_EQ(HDF_SUCCESS, ret);
244 EXPECT_NE(nullptr, apFeature);
245 type = apFeature->baseFeature.getFeatureType((struct IWiFiBaseFeature *)apFeature);
246 EXPECT_EQ(PROTOCOL_80211_IFTYPE_AP, type);
247
248 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
249 EXPECT_EQ(HDF_SUCCESS, ret);
250 }
251
252 /**
253 * @tc.name: WifiHalSetMacAddress001
254 * @tc.desc: Wifi hal set Mac address function test
255 * @tc.type: FUNC
256 */
257 HWTEST_F(WifiHalTest, WifiHalSetMacAddress001, Function | MediumTest | Level1)
258 {
259 int ret;
260 struct IWiFiAp *apFeature = nullptr;
261 unsigned char errorMac[ETH_ADDR_LEN] = {0x11, 0x34, 0x56, 0x78, 0xab, 0xcd};
262 unsigned char mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
263
264 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
265 EXPECT_EQ(HDF_SUCCESS, ret);
266 EXPECT_NE(nullptr, apFeature);
267 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, nullptr, 0);
268 EXPECT_NE(HDF_SUCCESS, ret);
269 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, errorMac, ETH_ADDR_LEN);
270 EXPECT_NE(HDF_SUCCESS, ret);
271 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, mac, ETH_ADDR_LEN);
272 EXPECT_EQ(HDF_SUCCESS, ret);
273
274 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
275 EXPECT_EQ(HDF_SUCCESS, ret);
276 }
277
278 /**
279 * @tc.name: WifiHalSetMacAddress002
280 * @tc.desc: Wifi hal set Mac address function test
281 * @tc.type: FUNC
282 */
283 HWTEST_F(WifiHalTest, WifiHalSetMacAddress002, Function | MediumTest | Level1)
284 {
285 int ret;
286 struct IWiFiSta *staFeature = nullptr;
287 unsigned char errorMac[ETH_ADDR_LEN] = {0};
288 unsigned char mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
289
290 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
291 EXPECT_EQ(HDF_SUCCESS, ret);
292 EXPECT_NE(nullptr, staFeature);
293 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, nullptr, 0);
294 EXPECT_NE(HDF_SUCCESS, ret);
295 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, errorMac, ETH_ADDR_LEN);
296 EXPECT_NE(HDF_SUCCESS, ret);
297 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, mac, ETH_ADDR_LEN);
298 EXPECT_EQ(HDF_SUCCESS, ret);
299
300 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
301 EXPECT_EQ(HDF_SUCCESS, ret);
302 }
303
304 /**
305 * @tc.name: WifiHalSetTxPower001
306 * @tc.desc: Wifi hal set transmit power function test
307 * @tc.type: FUNC
308 */
309 HWTEST_F(WifiHalTest, WifiHalSetTxPower001, Function | MediumTest | Level1)
310 {
311 int ret;
312 struct IWiFiAp *apFeature = nullptr;
313
314 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
315 EXPECT_EQ(HDF_SUCCESS, ret);
316 EXPECT_NE(nullptr, apFeature);
317 ret = apFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)apFeature, 0);
318 EXPECT_NE(HDF_SUCCESS, ret);
319 ret = apFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)apFeature, WLAN_TX_POWER);
320 EXPECT_EQ(HDF_SUCCESS, ret);
321
322 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
323 EXPECT_EQ(HDF_SUCCESS, ret);
324 }
325
326 /**
327 * @tc.name: WifiHalSetCountryCode001
328 * @tc.desc: Wifi hal set country code function test
329 * @tc.type: FUNC
330 */
331 HWTEST_F(WifiHalTest, WifiHalSetCountryCode001, Function | MediumTest | Level1)
332 {
333 int ret;
334 struct IWiFiAp *apFeature = nullptr;
335
336 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
337 EXPECT_EQ(HDF_SUCCESS, ret);
338 EXPECT_NE(nullptr, apFeature);
339 ret = apFeature->setCountryCode(apFeature, nullptr, 0);
340 EXPECT_NE(HDF_SUCCESS, ret);
341 ret = apFeature->setCountryCode(apFeature, "CN", 2);
342 EXPECT_EQ(HDF_SUCCESS, ret);
343
344 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
345 EXPECT_EQ(HDF_SUCCESS, ret);
346 }
347
348 /**
349 * @tc.name: WifiHalGetIfNamesByChipId001
350 * @tc.desc: Obtain all ifNames and the number of the current chip
351 * @tc.type: FUNC
352 */
353 HWTEST_F(WifiHalTest, WifiHalGetIfNamesByChipId001, Function | MediumTest | Level1)
354 {
355 int ret;
356 struct IWiFiSta *staFeature = nullptr;
357 char *ifNames = nullptr;
358 unsigned int num = 0;
359 unsigned char chipId = 0;
360 uint8_t i;
361
362 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
363 EXPECT_EQ(HDF_SUCCESS, ret);
364 EXPECT_NE(nullptr, staFeature);
365 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId);
366 ASSERT_TRUE(chipId <= WLAN_MAX_CHIPID && chipId >= WLAN_MIN_CHIPID);
367 EXPECT_EQ(HDF_SUCCESS, ret);
368 ret = staFeature->baseFeature.getIfNamesByChipId(chipId, nullptr, nullptr);
369 EXPECT_NE(HDF_SUCCESS, ret);
370 ret = staFeature->baseFeature.getIfNamesByChipId(chipId, &ifNames, &num);
371 EXPECT_NE(nullptr, ifNames);
372 EXPECT_EQ(HDF_SUCCESS, ret);
373 ASSERT_TRUE(num <= IFNAME_MAX_NUM && num >= IFNAME_MIN_NUM);
374 for (i = 0; i < num; i++) {
375 EXPECT_EQ(0, strncmp("wlan", ifNames + i * MAX_IF_NAME_LENGTH, SIZE));
376 }
377 free(ifNames);
378
379 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
380 EXPECT_EQ(HDF_SUCCESS, ret);
381 }
382
383 /**
384 * @tc.name: WifiHalGetSupportFeature001
385 * @tc.desc: Get supported features
386 * @tc.type: FUNC
387 */
388 HWTEST_F(WifiHalTest, WifiHalGetSupportFeature001, Function | MediumTest | Level1)
389 {
390 int ret;
391 uint8_t supportTest[PROTOCOL_80211_IFTYPE_NUM] = {0};
392 uint8_t support[PROTOCOL_80211_IFTYPE_NUM + 1] = {0};
393
394 ret = g_wifi->getSupportFeature(nullptr, 0);
395 EXPECT_NE(HDF_SUCCESS, ret);
396 ret = g_wifi->getSupportFeature(supportTest, PROTOCOL_80211_IFTYPE_NUM);
397 EXPECT_NE(HDF_SUCCESS, ret);
398 ret = g_wifi->getSupportFeature(support, PROTOCOL_80211_IFTYPE_NUM + 1);
399 EXPECT_EQ(HDF_SUCCESS, ret);
400 }
401
402 /**
403 * @tc.name: WifiHalGetSupportCombo001
404 * @tc.desc: Get supported combo
405 * @tc.type: FUNC
406 */
407 HWTEST_F(WifiHalTest, WifiHalGetSupportCombo001, Function | MediumTest | Level1)
408 {
409 int ret;
410 uint8_t support[PROTOCOL_80211_IFTYPE_NUM + 1] = {0};
411 uint64_t combo[DEFAULT_COMBO_SIZE] = {0};
412
413 ret = g_wifi->getSupportFeature(support, PROTOCOL_80211_IFTYPE_NUM + 1);
414 EXPECT_EQ(HDF_SUCCESS, ret);
415 ret = g_wifi->getSupportCombo(nullptr, 0);
416 EXPECT_NE(HDF_SUCCESS, ret);
417 ret = g_wifi->getSupportCombo(combo, DEFAULT_COMBO_SIZE);
418 if (support[PROTOCOL_80211_IFTYPE_NUM] == 0) {
419 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
420 } else {
421 EXPECT_EQ(HDF_SUCCESS, ret);
422 }
423 }
424
425 /**
426 * @tc.name: WifiHalGetDeviceMacAddress001
427 * @tc.desc: Get device Mac address for ap mode
428 * @tc.type: FUNC
429 * @tc.require: AR000F869G
430 */
431 HWTEST_F(WifiHalTest, WifiHalGetDeviceMacAddress001, Function | MediumTest | Level1)
432 {
433 int ret;
434 struct IWiFiAp *apFeature = nullptr;
435 unsigned char mac[ETH_ADDR_LEN] = {0};
436
437 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
438 EXPECT_EQ(HDF_SUCCESS, ret);
439 EXPECT_NE(nullptr, apFeature);
440 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, nullptr, 0);
441 EXPECT_NE(HDF_SUCCESS, ret);
442 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, mac, ETH_ADDR_LEN - 1);
443 EXPECT_NE(HDF_SUCCESS, ret);
444 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, mac, ETH_ADDR_LEN);
445 EXPECT_NE(HDF_FAILURE, ret);
446
447 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
448 EXPECT_EQ(HDF_SUCCESS, ret);
449 }
450
451 /**
452 * @tc.name: WifiHalGetDeviceMacAddress002
453 * @tc.desc: Get device Mac address for sta mode
454 * @tc.type: FUNC
455 */
456 HWTEST_F(WifiHalTest, WifiHalGetDeviceMacAddress002, Function | MediumTest | Level1)
457 {
458 int ret;
459 struct IWiFiSta *staFeature = nullptr;
460 unsigned char mac[ETH_ADDR_LEN] = {0};
461
462 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
463 EXPECT_EQ(HDF_SUCCESS, ret);
464 EXPECT_NE(nullptr, staFeature);
465 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, nullptr, 0);
466 EXPECT_NE(HDF_SUCCESS, ret);
467 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, mac, ETH_ADDR_LEN - 1);
468 EXPECT_NE(HDF_SUCCESS, ret);
469 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, mac, ETH_ADDR_LEN);
470 EXPECT_NE(HDF_FAILURE, ret);
471
472 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
473 EXPECT_EQ(HDF_SUCCESS, ret);
474 }
475
476 /**
477 * @tc.name: WifiHaGetValidFreqsWithBand001
478 * @tc.desc: Get available frequencies
479 * @tc.type: FUNC
480 */
481 HWTEST_F(WifiHalTest, WifiHaGetValidFreqsWithBand001, Function | MediumTest | Level1)
482 {
483 int ret;
484 struct IWiFiAp *apFeature = nullptr;
485 int32_t freq[WLAN_FREQ_MAX_NUM] = {0};
486 uint32_t num = 0;
487
488 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
489 EXPECT_EQ(HDF_SUCCESS, ret);
490 EXPECT_NE(nullptr, apFeature);
491 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature,
492 WLAN_BAND_2G, nullptr, 0, nullptr);
493 EXPECT_NE(HDF_SUCCESS, ret);
494 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature,
495 WLAN_BAND_2G, freq, WLAN_FREQ_MAX_NUM, &num);
496 EXPECT_EQ(HDF_SUCCESS, ret);
497
498 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
499 EXPECT_EQ(HDF_SUCCESS, ret);
500 }
501
502 /**
503 * @tc.name: WifiHalGetAssociatedStas001
504 * @tc.desc: Get asscociated STA info
505 * @tc.type: FUNC
506 */
507 HWTEST_F(WifiHalTest, WifiHalGetAsscociatedStas001, Function | MediumTest | Level1)
508 {
509 int ret;
510 struct IWiFiAp *apFeature = nullptr;
511 struct StaInfo staInfo[WLAN_MAX_NUM_STA_WITH_AP] = {{0}};
512 uint32_t num = 0;
513
514 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
515 EXPECT_EQ(HDF_SUCCESS, ret);
516 EXPECT_NE(nullptr, apFeature);
517 ret = apFeature->getAsscociatedStas(apFeature, nullptr, 0, nullptr);
518 EXPECT_NE(HDF_SUCCESS, ret);
519 ret = apFeature->getAsscociatedStas(apFeature, staInfo, WLAN_MAX_NUM_STA_WITH_AP, &num);
520 EXPECT_EQ(HDF_SUCCESS, ret);
521
522 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
523 EXPECT_EQ(HDF_SUCCESS, ret);
524 }
525
526 /**
527 * @tc.name: WifiHalSetScanningMacAddress001
528 * @tc.desc: Set Mac address scanning
529 * @tc.type: FUNC
530 */
531 HWTEST_F(WifiHalTest, WifiHalSetScanningMacAddress001, Function | MediumTest | Level1)
532 {
533 int ret;
534 struct IWiFiSta *staFeature = nullptr;
535 unsigned char scanMac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
536
537 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
538 EXPECT_EQ(HDF_SUCCESS, ret);
539 EXPECT_NE(nullptr, staFeature);
540 ret = staFeature->setScanningMacAddress(staFeature, nullptr, 0);
541 EXPECT_NE(HDF_SUCCESS, ret);
542 ret = staFeature->setScanningMacAddress(staFeature, scanMac, ETH_ADDR_LEN);
543 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
544
545 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
546 EXPECT_EQ(HDF_SUCCESS, ret);
547 }
548
549 /**
550 * @tc.name: WifiHalGetNetdevInfo001
551 * @tc.desc: Wifi hdi get netdev info function test
552 * @tc.type: FUNC
553 */
554 HWTEST_F(WifiHalTest, WifiHalGetNetdevInfo001, Function | MediumTest | Level1)
555 {
556 int ret;
557 struct NetDeviceInfoResult netDeviceInfoResult;
558
559 (void)memset_s(&netDeviceInfoResult, sizeof(struct NetDeviceInfoResult), 0, sizeof(struct NetDeviceInfoResult));
560 ret = g_wifi->getNetDevInfo(&netDeviceInfoResult);
561 EXPECT_EQ(ret, HDF_SUCCESS);
562 }
563
564 /**
565 * @tc.number: WifiHalResetDriver001
566 * @tc.name: Reset the WiFi driver
567 * @tc.size:Medium
568 * @tc.level: Level 3
569 */
570 HWTEST_F(WifiHalTest, WifiHalResetDriver001, Function | MediumTest | Level3)
571 {
572 int ret;
573 struct IWiFiSta *staFeature = nullptr;
574 const char *ifName = "wlan0";
575 unsigned char chipId = 0;
576
577 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
578 EXPECT_EQ(HDF_SUCCESS, ret);
579 EXPECT_NE(nullptr, staFeature);
580 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId);
581 ASSERT_TRUE(chipId <= WLAN_MAX_CHIPID && chipId >= WLAN_MIN_CHIPID);
582 EXPECT_EQ(HDF_SUCCESS, ret);
583 ret = g_wifi->resetDriver(chipId, ifName);
584 EXPECT_EQ(HDF_SUCCESS, ret);
585 printf("wait 15 for reset test now\n");
586 sleep(RESET_TIME);
587 }
588
589 /**
590 * @tc.name: WifiHalStartScan001
591 * @tc.desc: start scan is successfully
592 * @tc.type: FUNC
593 */
594 HWTEST_F(WifiHalTest, WifiHalStartScan001, Function | MediumTest | Level3)
595 {
596 int ret;
597 struct IWiFiSta *staFeature = nullptr;
598 const char *ifName = "wlan0";
599 WifiScan scan = {0};
600
601 ret = g_wifi->registerEventCallback(HalCallbackEvent, ifName);
602 EXPECT_EQ(HDF_SUCCESS, ret);
603 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
604 EXPECT_EQ(HDF_SUCCESS, ret);
605 EXPECT_NE(nullptr, staFeature);
606 ret = staFeature->startScan(ifName, &scan);
607 EXPECT_EQ(HDF_SUCCESS, ret);
608 printf("wait 5 for Scan test now\n");
609 sleep(SLEEP_TIME);
610 ret = g_wifi->unregisterEventCallback(HalCallbackEvent, ifName);
611 EXPECT_EQ(HDF_SUCCESS, ret);
612 }
613 };