1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <osal_mem.h>
18 #include "hdf_base.h"
19 #include "hdf_sbuf.h"
20 #include "wifi_hal.h"
21 #include "wifi_hal_ap_feature.h"
22 #include "wifi_hal_base_feature.h"
23 #include "wifi_hal_sta_feature.h"
24 #include "securec.h"
25
26 using namespace testing::ext;
27
28 namespace HalTest {
29 struct IWiFi *g_wifi = nullptr;
30 const int32_t WLAN_TX_POWER = 160;
31 const uint32_t IFNAME_MIN_NUM = 0;
32 const uint32_t IFNAME_MAX_NUM = 32;
33 const uint32_t MAX_IF_NAME_LENGTH = 16;
34 const uint32_t TEST_PARAM_BUF_SIZE = 64;
35 const uint32_t SIZE = 4;
36 const int32_t TEST_CMD = 123;
37 const uint32_t RESET_TIME = 20;
38 const uint32_t TEST_BUF_SIZE = 64;
39
40 class WifiHalTest : public testing::Test {
41 public:
42 static void SetUpTestCase();
43 static void TearDownTestCase();
44 void SetUp();
45 void TearDown();
46 };
47
SetUpTestCase()48 void WifiHalTest::SetUpTestCase()
49 {
50 int ret;
51
52 ret = WifiConstruct(&g_wifi);
53 ASSERT_EQ(HDF_SUCCESS, ret);
54 }
55
TearDownTestCase()56 void WifiHalTest::TearDownTestCase()
57 {
58 int ret;
59
60 ret = WifiDestruct(&g_wifi);
61 ASSERT_EQ(HDF_SUCCESS, ret);
62 }
63
SetUp()64 void WifiHalTest::SetUp()
65 {
66 int ret;
67
68 ret = g_wifi->start(nullptr);
69 ASSERT_EQ(HDF_ERR_INVALID_PARAM, ret);
70 ret = g_wifi->start(g_wifi);
71 ASSERT_EQ(HDF_SUCCESS, ret);
72 }
73
TearDown()74 void WifiHalTest::TearDown()
75 {
76 int ret;
77
78 ret = g_wifi->stop(nullptr);
79 ASSERT_EQ(HDF_ERR_INVALID_PARAM, ret);
80 ret = g_wifi->stop(g_wifi);
81 ASSERT_EQ(HDF_SUCCESS, ret);
82 }
83
ParseScanResult(WifiScanResult * scanResult)84 static void ParseScanResult(WifiScanResult *scanResult)
85 {
86 printf("ParseScanResult: flags=%d, caps=%d, freq=%d, beaconInt=%d,\n", scanResult->flags, scanResult->caps,
87 scanResult->freq, scanResult->beaconInt);
88 printf("ParseScanResult: qual=%d, beaconIeLen=%d, level=%d, age=%d, ieLen=%d,\n", scanResult->qual,
89 scanResult->beaconIeLen, scanResult->level, scanResult->age, scanResult->ieLen);
90 }
91
92 /**
93 * @tc.name: WifiHalCreateAndDestroyFeature001
94 * @tc.desc: Wifi hal create and destroy feature function test
95 * @tc.type: FUNC
96 * @tc.require: AR000F869G
97 */
98 HWTEST_F(WifiHalTest, WifiHalCreateAndDestroyFeature001, TestSize.Level1)
99 {
100 int ret;
101 struct IWiFiAp *apFeature = nullptr;
102
103 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
104 EXPECT_EQ(HDF_SUCCESS, ret);
105 EXPECT_NE(nullptr, apFeature);
106
107 ret = g_wifi->destroyFeature(nullptr);
108 EXPECT_NE(HDF_SUCCESS, ret);
109 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
110 EXPECT_EQ(HDF_SUCCESS, ret);
111 }
112
113 /**
114 * @tc.name: WifiHalCreateAndDestroyFeature002
115 * @tc.desc: Wifi hal create and destroy feature function test
116 * @tc.type: FUNC
117 * @tc.require: AR000F869E
118 */
119 HWTEST_F(WifiHalTest, WifiHalCreateAndDestroyFeature002, TestSize.Level1)
120 {
121 int ret;
122 struct IWiFiSta *staFeature = nullptr;
123
124 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
125 EXPECT_EQ(HDF_SUCCESS, ret);
126 EXPECT_NE(nullptr, staFeature);
127
128 ret = g_wifi->destroyFeature(nullptr);
129 EXPECT_NE(HDF_SUCCESS, ret);
130 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
131 EXPECT_EQ(HDF_SUCCESS, ret);
132 }
133
134 /**
135 * @tc.name: WifiHalGetFeatureByIfName001
136 * @tc.desc: Wifi hal get feature by ifname function test
137 * @tc.type: FUNC
138 * @tc.require: AR000F869G
139 */
140 HWTEST_F(WifiHalTest, WifiHalGetFeatureByIfName001, TestSize.Level1)
141 {
142 int ret;
143 struct IWiFiAp *apFeature = nullptr;
144 struct IWiFiAp *apFeatureGet = nullptr;
145 const char *ifName0 = "wlanTest";
146
147 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
148 EXPECT_EQ(HDF_SUCCESS, ret);
149 EXPECT_NE(nullptr, apFeature);
150 ret = g_wifi->getFeatureByIfName(nullptr, (struct IWiFiBaseFeature **)&apFeatureGet);
151 EXPECT_NE(HDF_SUCCESS, ret);
152 ret = g_wifi->getFeatureByIfName(ifName0, (struct IWiFiBaseFeature **)&apFeatureGet);
153 EXPECT_NE(HDF_SUCCESS, ret);
154 ret = g_wifi->getFeatureByIfName(apFeature->baseFeature.ifName, (struct IWiFiBaseFeature **)&apFeatureGet);
155 EXPECT_EQ(HDF_SUCCESS, ret);
156 EXPECT_NE(nullptr, apFeatureGet);
157
158 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
159 EXPECT_EQ(HDF_SUCCESS, ret);
160 }
161
HalCallbackEvent(uint32_t event,void * respData,const char * ifName)162 static int32_t HalCallbackEvent(uint32_t event, void *respData, const char *ifName)
163 {
164 (void)event;
165 if (respData == nullptr) {
166 return HDF_FAILURE;
167 }
168 printf("HalCallbackEvent ifName = %s, event = %d\n", ifName, event);
169 switch (event) {
170 case WIFI_EVENT_SCAN_DONE:
171 printf("HalCallbackEvent WIFI_EVENT_SCAN_DONE Process\n");
172 break;
173 case WIFI_EVENT_SCAN_RESULT:
174 ParseScanResult((WifiScanResult *)respData);
175 break;
176 default:
177 break;
178 }
179 return HDF_SUCCESS;
180 }
181
182 /**
183 * @tc.name: WifiHalRegisterEventCallback001
184 * @tc.desc: Wifi hal register callback function test
185 * @tc.type: FUNC
186 * @tc.require: AR000F869G
187 */
188 HWTEST_F(WifiHalTest, WifiHalRegisterEventCallback001, TestSize.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 * @tc.require: AR000F869G
201 */
202 HWTEST_F(WifiHalTest, WifiHalUnRegisterEventCallback001, TestSize.Level1)
203 {
204 int ret;
205
206 ret = g_wifi->unregisterEventCallback(HalCallbackEvent, "wlan0");
207 EXPECT_EQ(HDF_SUCCESS, ret);
208 }
209
210 /**
211 * @tc.name: WifiHalGetNetworkIfaceName001
212 * @tc.desc: Wifi hal get network iface name function test
213 * @tc.type: FUNC
214 * @tc.require: AR000F869G
215 */
216 HWTEST_F(WifiHalTest, WifiHalGetNetworkIfaceName001, TestSize.Level1)
217 {
218 int ret;
219 struct IWiFiAp *apFeature = nullptr;
220
221 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
222 EXPECT_EQ(HDF_SUCCESS, ret);
223 EXPECT_NE(nullptr, apFeature);
224 const char *ifnameTest = apFeature->baseFeature.getNetworkIfaceName(nullptr);
225 EXPECT_EQ(nullptr, ifnameTest);
226 const char *ifName = apFeature->baseFeature.getNetworkIfaceName((const struct IWiFiBaseFeature *)apFeature);
227 EXPECT_NE(nullptr, ifName);
228
229 if (strncmp(ifName, "wlan", 4) == 0 || strncmp(ifName, "nan", 3) == 0 || strncmp(ifName, "p2p", 3) == 0) {
230 ret = 0;
231 } else {
232 ret = -1;
233 }
234 EXPECT_EQ(0, ret);
235
236 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
237 EXPECT_EQ(HDF_SUCCESS, ret);
238 }
239
240 /**
241 * @tc.name: WifiHalGetGetFeatureType001
242 * @tc.desc: Wifi hal get feature type function test
243 * @tc.type: FUNC
244 * @tc.require: AR000F869G
245 */
246 HWTEST_F(WifiHalTest, WifiHalGetGetFeatureType001, TestSize.Level1)
247 {
248 int ret;
249 struct IWiFiAp *apFeature = nullptr;
250 int32_t type;
251 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
252 EXPECT_EQ(HDF_SUCCESS, ret);
253 EXPECT_NE(nullptr, apFeature);
254 type = apFeature->baseFeature.getFeatureType(nullptr);
255 EXPECT_EQ(HDF_FAILURE, type);
256 type = apFeature->baseFeature.getFeatureType((struct IWiFiBaseFeature *)apFeature);
257 EXPECT_EQ(PROTOCOL_80211_IFTYPE_AP, type);
258
259 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
260 EXPECT_EQ(HDF_SUCCESS, ret);
261 }
262
263 /**
264 * @tc.name: WifiHalSetMacAddress001
265 * @tc.desc: Wifi hal set Mac address function test
266 * @tc.type: FUNC
267 * @tc.require: AR000F869G
268 */
269 HWTEST_F(WifiHalTest, WifiHalSetMacAddress001, TestSize.Level1)
270 {
271 int ret;
272 struct IWiFiAp *apFeature = nullptr;
273 unsigned char errorMac[ETH_ADDR_LEN] = {0x11, 0x34, 0x56, 0x78, 0xab, 0xcd};
274 unsigned char mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
275
276 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
277 EXPECT_EQ(HDF_SUCCESS, ret);
278 EXPECT_NE(nullptr, apFeature);
279 ret = apFeature->baseFeature.setMacAddress(nullptr, mac, ETH_ADDR_LEN);
280 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
281 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, nullptr, ETH_ADDR_LEN);
282 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
283 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, mac, 0);
284 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
285 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, errorMac, ETH_ADDR_LEN);
286 EXPECT_NE(HDF_SUCCESS, ret);
287 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, mac, ETH_ADDR_LEN);
288 printf("%s: ret = %d\n", __func__, ret);
289 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_DEVICE_BUSY);
290 ASSERT_TRUE(flag);
291
292 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
293 EXPECT_EQ(HDF_SUCCESS, ret);
294 }
295
296 /**
297 * @tc.name: WifiHalSetMacAddress002
298 * @tc.desc: Wifi hal set Mac address function test
299 * @tc.type: FUNC
300 * @tc.require: AR000F869E
301 */
302 HWTEST_F(WifiHalTest, WifiHalSetMacAddress002, TestSize.Level1)
303 {
304 int ret;
305 struct IWiFiSta *staFeature = nullptr;
306 unsigned char mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
307 unsigned char errorMac[ETH_ADDR_LEN] = {0x11, 0x34, 0x56, 0x78, 0xab, 0xcd};
308
309 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
310 EXPECT_EQ(HDF_SUCCESS, ret);
311 EXPECT_NE(nullptr, staFeature);
312 ret = staFeature->baseFeature.setMacAddress(nullptr, mac, ETH_ADDR_LEN);
313 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
314 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, nullptr, ETH_ADDR_LEN);
315 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
316 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, mac, 0);
317 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
318 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, errorMac, ETH_ADDR_LEN);
319 EXPECT_NE(HDF_SUCCESS, ret);
320 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, mac, ETH_ADDR_LEN);
321 printf("%s: ret = %d\n", __func__, ret);
322 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_DEVICE_BUSY);
323 ASSERT_TRUE(flag);
324
325 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
326 EXPECT_EQ(HDF_SUCCESS, ret);
327 }
328
329 /**
330 * @tc.name: WifiHalSetTxPower001
331 * @tc.desc: Wifi hal set transmit power function test
332 * @tc.type: FUNC
333 * @tc.require: AR000F869G
334 */
335 HWTEST_F(WifiHalTest, WifiHalSetTxPower001, TestSize.Level1)
336 {
337 int ret;
338 struct IWiFiAp *apFeature = nullptr;
339
340 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
341 EXPECT_EQ(HDF_SUCCESS, ret);
342 EXPECT_NE(nullptr, apFeature);
343 ret = apFeature->baseFeature.setTxPower(nullptr, WLAN_TX_POWER);
344 EXPECT_NE(HDF_SUCCESS, ret);
345 ret = apFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)apFeature, 0);
346 EXPECT_NE(HDF_SUCCESS, ret);
347 ret = apFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)apFeature, WLAN_TX_POWER);
348 EXPECT_EQ(HDF_SUCCESS, ret);
349
350 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
351 EXPECT_EQ(HDF_SUCCESS, ret);
352 }
353
354 /**
355 * @tc.name: WifiHalSetCountryCode001
356 * @tc.desc: Wifi hal set country code function test
357 * @tc.type: FUNC
358 * @tc.require: AR000F869K
359 */
360 HWTEST_F(WifiHalTest, WifiHalSetCountryCode001, TestSize.Level1)
361 {
362 int ret;
363 struct IWiFiAp *apFeature = nullptr;
364
365 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
366 EXPECT_EQ(HDF_SUCCESS, ret);
367 EXPECT_NE(nullptr, apFeature);
368 ret = apFeature->setCountryCode(apFeature, nullptr, 0);
369 EXPECT_NE(HDF_SUCCESS, ret);
370 ret = apFeature->setCountryCode(nullptr, "CN", 2);
371 EXPECT_NE(HDF_SUCCESS, ret);
372 ret = apFeature->setCountryCode(apFeature, "CN", 3);
373 EXPECT_NE(HDF_SUCCESS, ret);
374 ret = apFeature->setCountryCode(apFeature, "99", 2);
375 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
376 ASSERT_TRUE(flag);
377 ret = apFeature->setCountryCode(apFeature, "CN", 2);
378 EXPECT_EQ(HDF_SUCCESS, ret);
379
380 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
381 EXPECT_EQ(HDF_SUCCESS, ret);
382 }
383
384 /**
385 * @tc.name: WifiHalGetIfNamesByChipId001
386 * @tc.desc: Obtain all ifNames and the number of the current chip
387 * @tc.type: FUNC
388 * @tc.require: AR000F869G
389 */
390 HWTEST_F(WifiHalTest, WifiHalGetIfNamesByChipId001, TestSize.Level1)
391 {
392 int ret;
393 struct IWiFiSta *staFeature = nullptr;
394 char *ifNames = nullptr;
395 unsigned int num = 0;
396 unsigned char chipId = 0;
397 uint8_t i;
398
399 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
400 EXPECT_EQ(HDF_SUCCESS, ret);
401 EXPECT_NE(nullptr, staFeature);
402 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId);
403 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE);
404 EXPECT_EQ(HDF_SUCCESS, ret);
405 ret = staFeature->baseFeature.getIfNamesByChipId(chipId, nullptr, nullptr);
406 EXPECT_NE(HDF_SUCCESS, ret);
407 ret = staFeature->baseFeature.getIfNamesByChipId(100, &ifNames, &num);
408 EXPECT_NE(HDF_SUCCESS, ret);
409 ret = staFeature->baseFeature.getIfNamesByChipId(chipId, &ifNames, &num);
410 EXPECT_NE(nullptr, ifNames);
411 EXPECT_EQ(HDF_SUCCESS, ret);
412 ASSERT_TRUE(num <= IFNAME_MAX_NUM && num >= IFNAME_MIN_NUM);
413 for (i = 0; i < num; i++) {
414 EXPECT_EQ(0, strncmp("wlan", ifNames + i * MAX_IF_NAME_LENGTH, SIZE));
415 }
416 free(ifNames);
417
418 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
419 EXPECT_EQ(HDF_SUCCESS, ret);
420 }
421
422 HWTEST_F(WifiHalTest, GetNetDevInfo001, TestSize.Level1)
423 {
424 int ret;
425 struct IWiFiAp *apFeature = nullptr;
426 struct NetDeviceInfoResult netDeviceInfoResult;
427
428 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
429 EXPECT_EQ(HDF_SUCCESS, ret);
430 EXPECT_NE(nullptr, apFeature);
431 ret = g_wifi->getNetDevInfo(nullptr);
432 EXPECT_NE(HDF_SUCCESS, ret);
433 ret = g_wifi->getNetDevInfo(&netDeviceInfoResult);
434 EXPECT_EQ(HDF_SUCCESS, ret);
435 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
436 EXPECT_EQ(HDF_SUCCESS, ret);
437 }
438
439 HWTEST_F(WifiHalTest, GetNetDevInfo002, TestSize.Level1)
440 {
441 int ret;
442 struct IWiFiSta *staFeature = nullptr;
443 struct NetDeviceInfoResult netDeviceInfoResult;
444
445 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
446 EXPECT_EQ(HDF_SUCCESS, ret);
447 EXPECT_NE(nullptr, staFeature);
448 ret = g_wifi->getNetDevInfo(nullptr);
449 EXPECT_NE(HDF_SUCCESS, ret);
450 ret = g_wifi->getNetDevInfo(&netDeviceInfoResult);
451 EXPECT_EQ(HDF_SUCCESS, ret);
452 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
453 EXPECT_EQ(HDF_SUCCESS, ret);
454 }
455
456 /**
457 * @tc.name: GetPowerModeTest_001
458 * @tc.desc: Wifi hdi get power mode function test
459 * @tc.type: FUNC
460 * @tc.require: AR000H60O7
461 */
462 HWTEST_F(WifiHalTest, GetPowerMode001, TestSize.Level1)
463 {
464 int32_t ret;
465 struct IWiFiAp *apFeature = nullptr;
466 const char *ifName = "eth0";
467 uint8_t mode;
468
469 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
470 EXPECT_EQ(HDF_SUCCESS, ret);
471 EXPECT_NE(nullptr, apFeature);
472 printf("GetPowerMode001: ifname is %s\n", apFeature->baseFeature.ifName);
473 ret = g_wifi->getPowerMode(nullptr, &mode);
474 EXPECT_NE(HDF_SUCCESS, ret);
475 ret = g_wifi->getPowerMode(ifName, nullptr);
476 EXPECT_NE(HDF_SUCCESS, ret);
477 ret = g_wifi->getPowerMode(ifName, &mode);
478 EXPECT_NE(HDF_SUCCESS, ret);
479 ret = g_wifi->getPowerMode(apFeature->baseFeature.ifName, nullptr);
480 EXPECT_NE(HDF_SUCCESS, ret);
481 ret = g_wifi->getPowerMode(apFeature->baseFeature.ifName, &mode);
482 printf("%s: ret = %d\n", __func__, ret);
483 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
484 ASSERT_TRUE(flag);
485 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
486 EXPECT_EQ(HDF_SUCCESS, ret);
487 }
488
489 /**
490 * @tc.name: GetPowerModeTest_002
491 * @tc.desc: Wifi hdi get power mode function test
492 * @tc.type: FUNC
493 * @tc.require: AR000H60O7
494 */
495 HWTEST_F(WifiHalTest, GetPowerMode002, TestSize.Level1)
496 {
497 int32_t ret;
498 struct IWiFiSta *staFeature = nullptr;
499 const char *ifName = "eth0";
500 uint8_t mode;
501
502 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
503 EXPECT_EQ(HDF_SUCCESS, ret);
504 EXPECT_NE(nullptr, staFeature);
505 printf("GetPowerMode002: ifname is %s\n", staFeature->baseFeature.ifName);
506 ret = g_wifi->getPowerMode(nullptr, &mode);
507 EXPECT_NE(HDF_SUCCESS, ret);
508 ret = g_wifi->getPowerMode(ifName, nullptr);
509 EXPECT_NE(HDF_SUCCESS, ret);
510 ret = g_wifi->getPowerMode(ifName, &mode);
511 EXPECT_NE(HDF_SUCCESS, ret);
512 ret = g_wifi->getPowerMode(staFeature->baseFeature.ifName, nullptr);
513 EXPECT_NE(HDF_SUCCESS, ret);
514 ret = g_wifi->getPowerMode(staFeature->baseFeature.ifName, &mode);
515 printf("%s: ret = %d\n", __func__, ret);
516 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
517 ASSERT_TRUE(flag);
518 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
519 EXPECT_EQ(HDF_SUCCESS, ret);
520 }
521
522 /**
523 * @tc.name: SetPowerMode001
524 * @tc.desc: Wifi hdi set power mode function test
525 * @tc.type: FUNC
526 * @tc.require: AR000H60O7
527 */
528 HWTEST_F(WifiHalTest, SetPowerMode001, TestSize.Level1)
529 {
530 int32_t ret;
531 struct IWiFiAp *apFeature = nullptr;
532 const char *ifName = "eth0";
533
534 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
535 EXPECT_EQ(HDF_SUCCESS, ret);
536 EXPECT_NE(nullptr, apFeature);
537 printf("SetPowerMode001: ifname is %s\n", apFeature->baseFeature.ifName);
538 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_NUM);
539 EXPECT_NE(HDF_SUCCESS, ret);
540 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_NUM);
541 EXPECT_NE(HDF_SUCCESS, ret);
542 ret = g_wifi->setPowerMode(apFeature->baseFeature.ifName, WIFI_POWER_MODE_NUM);
543 EXPECT_NE(HDF_SUCCESS, ret);
544 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
545 EXPECT_EQ(HDF_SUCCESS, ret);
546 }
547
548 /**
549 * @tc.name: SetPowerMode002
550 * @tc.desc: Wifi hdi set power mode function test
551 * @tc.type: FUNC
552 * @tc.require: AR000H60O7
553 */
554 HWTEST_F(WifiHalTest, SetPowerMode002, TestSize.Level1)
555 {
556 int32_t ret;
557 struct IWiFiAp *apFeature = nullptr;
558 const char *ifName = "eth0";
559
560 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
561 EXPECT_EQ(HDF_SUCCESS, ret);
562 EXPECT_NE(nullptr, apFeature);
563 printf("SetPowerMode002: ifname is %s\n", apFeature->baseFeature.ifName);
564 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_SLEEPING);
565 EXPECT_NE(HDF_SUCCESS, ret);
566 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_SLEEPING);
567 EXPECT_NE(HDF_SUCCESS, ret);
568 ret = g_wifi->setPowerMode(apFeature->baseFeature.ifName, WIFI_POWER_MODE_SLEEPING);
569 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
570 ASSERT_TRUE(flag);
571 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
572 EXPECT_EQ(HDF_SUCCESS, ret);
573 }
574
575 /**
576 * @tc.name: SetPowerMode003
577 * @tc.desc: Wifi hdi set power mode function test
578 * @tc.type: FUNC
579 * @tc.require: AR000H60O7
580 */
581 HWTEST_F(WifiHalTest, SetPowerMode003, TestSize.Level1)
582 {
583 int32_t ret;
584 struct IWiFiAp *apFeature = nullptr;
585 const char *ifName = "eth0";
586
587 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
588 EXPECT_EQ(HDF_SUCCESS, ret);
589 EXPECT_NE(nullptr, apFeature);
590 printf("SetPowerMode003: ifname is %s\n", apFeature->baseFeature.ifName);
591 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_GENERAL);
592 EXPECT_NE(HDF_SUCCESS, ret);
593 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_GENERAL);
594 EXPECT_NE(HDF_SUCCESS, ret);
595 ret = g_wifi->setPowerMode(apFeature->baseFeature.ifName, WIFI_POWER_MODE_GENERAL);
596 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
597 ASSERT_TRUE(flag);
598 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
599 EXPECT_EQ(HDF_SUCCESS, ret);
600 }
601
602 /**
603 * @tc.name: SetPowerMode004
604 * @tc.desc: Wifi hdi set power mode function test
605 * @tc.type: FUNC
606 * @tc.require: AR000H60O7
607 */
608 HWTEST_F(WifiHalTest, SetPowerMode004, TestSize.Level1)
609 {
610 int32_t ret;
611 struct IWiFiAp *apFeature = nullptr;
612 const char *ifName = "eth0";
613
614 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
615 EXPECT_EQ(HDF_SUCCESS, ret);
616 EXPECT_NE(nullptr, apFeature);
617 printf("SetPowerMode004: ifname is %s\n", apFeature->baseFeature.ifName);
618 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_THROUGH_WALL);
619 EXPECT_NE(HDF_SUCCESS, ret);
620 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_THROUGH_WALL);
621 EXPECT_NE(HDF_SUCCESS, ret);
622 ret = g_wifi->setPowerMode(apFeature->baseFeature.ifName, WIFI_POWER_MODE_THROUGH_WALL);
623 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
624 ASSERT_TRUE(flag);
625 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
626 EXPECT_EQ(HDF_SUCCESS, ret);
627 }
628
629 /**
630 * @tc.name: SetPowerMode005
631 * @tc.desc: Wifi hdi set power mode function test
632 * @tc.type: FUNC
633 * @tc.require: AR000H60O7
634 */
635 HWTEST_F(WifiHalTest, SetPowerMode005, TestSize.Level1)
636 {
637 int32_t ret;
638 struct IWiFiSta *staFeature = nullptr;
639 const char *ifName = "eth0";
640
641 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
642 EXPECT_EQ(HDF_SUCCESS, ret);
643 EXPECT_NE(nullptr, staFeature);
644 printf("SetPowerMode005: ifname is %s\n", staFeature->baseFeature.ifName);
645 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_NUM);
646 EXPECT_NE(HDF_SUCCESS, ret);
647 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_NUM);
648 EXPECT_NE(HDF_SUCCESS, ret);
649 ret = g_wifi->setPowerMode(staFeature->baseFeature.ifName, WIFI_POWER_MODE_NUM);
650 EXPECT_NE(HDF_SUCCESS, ret);
651 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
652 EXPECT_EQ(HDF_SUCCESS, ret);
653 }
654
655 /**
656 * @tc.name: SetPowerMode006
657 * @tc.desc: Wifi hdi set power mode function test
658 * @tc.type: FUNC
659 * @tc.require: AR000H60O7
660 */
661 HWTEST_F(WifiHalTest, SetPowerMode006, TestSize.Level1)
662 {
663 int32_t ret;
664 struct IWiFiSta *staFeature = nullptr;
665 const char *ifName = "eth0";
666
667 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
668 EXPECT_EQ(HDF_SUCCESS, ret);
669 EXPECT_NE(nullptr, staFeature);
670 printf("SetPowerMode005: ifname is %s\n", staFeature->baseFeature.ifName);
671 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_SLEEPING);
672 EXPECT_NE(HDF_SUCCESS, ret);
673 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_SLEEPING);
674 EXPECT_NE(HDF_SUCCESS, ret);
675 ret = g_wifi->setPowerMode(staFeature->baseFeature.ifName, WIFI_POWER_MODE_SLEEPING);
676 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
677 ASSERT_TRUE(flag);
678 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
679 EXPECT_EQ(HDF_SUCCESS, ret);
680 }
681
682 /**
683 * @tc.name: SetPowerMode007
684 * @tc.desc: Wifi hdi set power mode function test
685 * @tc.type: FUNC
686 * @tc.require: AR000H60O7
687 */
688 HWTEST_F(WifiHalTest, SetPowerMode007, TestSize.Level1)
689 {
690 int32_t ret;
691 struct IWiFiSta *staFeature = nullptr;
692 const char *ifName = "eth0";
693
694 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
695 EXPECT_EQ(HDF_SUCCESS, ret);
696 EXPECT_NE(nullptr, staFeature);
697 printf("SetPowerMode005: ifname is %s\n", staFeature->baseFeature.ifName);
698 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_GENERAL);
699 EXPECT_NE(HDF_SUCCESS, ret);
700 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_GENERAL);
701 EXPECT_NE(HDF_SUCCESS, ret);
702 ret = g_wifi->setPowerMode(staFeature->baseFeature.ifName, WIFI_POWER_MODE_GENERAL);
703 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
704 ASSERT_TRUE(flag);
705 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
706 EXPECT_EQ(HDF_SUCCESS, ret);
707 }
708
709 /**
710 * @tc.name: SetPowerMode008
711 * @tc.desc: Wifi hdi set power mode function test
712 * @tc.type: FUNC
713 * @tc.require: AR000H60O7
714 */
715 HWTEST_F(WifiHalTest, SetPowerMode008, TestSize.Level1)
716 {
717 int32_t ret;
718 struct IWiFiSta *staFeature = nullptr;
719 const char *ifName = "eth0";
720
721 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
722 EXPECT_EQ(HDF_SUCCESS, ret);
723 EXPECT_NE(nullptr, staFeature);
724 printf("SetPowerMode005: ifname is %s\n", staFeature->baseFeature.ifName);
725 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_THROUGH_WALL);
726 EXPECT_NE(HDF_SUCCESS, ret);
727 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_THROUGH_WALL);
728 EXPECT_NE(HDF_SUCCESS, ret);
729 ret = g_wifi->setPowerMode(staFeature->baseFeature.ifName, WIFI_POWER_MODE_THROUGH_WALL);
730 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
731 ASSERT_TRUE(flag);
732 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
733 EXPECT_EQ(HDF_SUCCESS, ret);
734 }
735
736 /**
737 * @tc.name: WifiHalStartScan001
738 * @tc.desc: Wifi hdi Start Scan function test
739 * @tc.type: FUNC
740 * @tc.require: AR000H60O7
741 */
742 HWTEST_F(WifiHalTest, WifiHalStartScan001, TestSize.Level1)
743 {
744 int ret;
745 struct IWiFiSta *staFeature = nullptr;
746 const char *ifName = "wlan0";
747 WifiScan scan = {0};
748
749 ret = g_wifi->registerEventCallback(HalCallbackEvent, ifName);
750 EXPECT_EQ(HDF_SUCCESS, ret);
751 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
752 EXPECT_EQ(HDF_SUCCESS, ret);
753 EXPECT_NE(staFeature, nullptr);
754 ret = staFeature->startScan(nullptr, &scan);
755 EXPECT_NE(HDF_SUCCESS, ret);
756 ret = staFeature->startScan(ifName, nullptr);
757 EXPECT_NE(HDF_SUCCESS, ret);
758 ret = staFeature->startScan(ifName, &scan);
759 EXPECT_EQ(HDF_SUCCESS, ret);
760 sleep(10);
761 }
762
763 /**
764 * @tc.name: WifiHalCreateFeature003
765 * @tc.desc: Wifi hal create feature function test
766 * @tc.type: FUNC
767 * @tc.require: AR000H603L
768 */
769 HWTEST_F(WifiHalTest, WifiHalCreateFeature003, TestSize.Level1)
770 {
771 int32_t ret;
772 struct IWiFiSta *staFeature = nullptr;
773
774 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, nullptr);
775 EXPECT_EQ(ret, HDF_FAILURE);
776 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, nullptr);
777 EXPECT_EQ(ret, HDF_FAILURE);
778
779 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_NUM, (struct IWiFiBaseFeature **)&staFeature);
780 EXPECT_NE(HDF_SUCCESS, ret);
781 ret = g_wifi->createFeature(-1, (struct IWiFiBaseFeature **)&staFeature);
782 EXPECT_NE(HDF_SUCCESS, ret);
783 }
784
785 /**
786 * @tc.name: WifiHalGetFeatureByIfName002
787 * @tc.desc: Wifi hal get feature by ifname function test
788 * @tc.type: FUNC
789 * @tc.require: AR000H603L
790 */
791 HWTEST_F(WifiHalTest, WifiHalGetFeatureByIfName002, TestSize.Level1)
792 {
793 int32_t ret;
794 struct IWiFiSta *staFeature = nullptr;
795 struct IWiFiSta *staFeatureGet = nullptr;
796 const char *ifName0 = "wlanTest";
797
798 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
799 EXPECT_EQ(HDF_SUCCESS, ret);
800 EXPECT_NE(nullptr, staFeature);
801 ret = g_wifi->getFeatureByIfName(nullptr, (struct IWiFiBaseFeature **)&staFeature);
802 EXPECT_NE(HDF_SUCCESS, ret);
803 ret = g_wifi->getFeatureByIfName(ifName0, (struct IWiFiBaseFeature **)&staFeature);
804 EXPECT_NE(HDF_SUCCESS, ret);
805 ret = g_wifi->getFeatureByIfName(staFeature->baseFeature.ifName, (struct IWiFiBaseFeature **)&staFeatureGet);
806 EXPECT_EQ(HDF_SUCCESS, ret);
807 EXPECT_NE(nullptr, staFeatureGet);
808
809 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
810 EXPECT_EQ(HDF_SUCCESS, ret);
811 }
812
813 /**
814 * @tc.name: WifiHalRegisterEventCallback002
815 * @tc.desc: Wifi hal register event callback test
816 * @tc.type: FUNC
817 * @tc.require: AR000H603L
818 */
819 HWTEST_F(WifiHalTest, WifiHalRegisterEventCallback002, TestSize.Level1)
820 {
821 int32_t ret;
822
823 ret = g_wifi->registerEventCallback(nullptr, "wlan0");
824 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
825 ret = g_wifi->registerEventCallback(HalCallbackEvent, nullptr);
826 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
827 }
828
829 /**
830 * @tc.name: WifiHalUnRegisterEventCallback002
831 * @tc.desc: Wifi hal unregister event callback test
832 * @tc.type: FUNC
833 * @tc.require: AR000H603L
834 */
835 HWTEST_F(WifiHalTest, WifiHalUnRegisterEventCallback002, TestSize.Level1)
836 {
837 int32_t ret;
838
839 ret = g_wifi->unregisterEventCallback(nullptr, "wlan0");
840 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
841 ret = g_wifi->unregisterEventCallback(HalCallbackEvent, nullptr);
842 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
843 }
844
845 /**
846 * @tc.name: GetSupportFeature001
847 * @tc.desc: Wifi hal get supported feature test
848 * @tc.type: FUNC
849 * @tc.require: AR000H603L
850 */
851 HWTEST_F(WifiHalTest, GetSupportFeature001, TestSize.Level1)
852 {
853 int32_t ret;
854 uint8_t supType[PROTOCOL_80211_IFTYPE_NUM + 1] = {0};
855
856 ret = g_wifi->getSupportFeature(nullptr, PROTOCOL_80211_IFTYPE_NUM + 1);
857 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
858 ret = g_wifi->getSupportFeature(supType, PROTOCOL_80211_IFTYPE_NUM);
859 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
860
861 ret = g_wifi->getSupportFeature(supType, PROTOCOL_80211_IFTYPE_NUM + 1);
862 EXPECT_EQ(RET_CODE_SUCCESS, ret);
863 }
864
865 /**
866 * @tc.name: WifiHalGetNetworkIfaceName002
867 * @tc.desc: Wifi hal get network iface name function test
868 * @tc.type: FUNC
869 * @tc.require: AR000H603L
870 */
871 HWTEST_F(WifiHalTest, WifiHalGetNetworkIfaceName002, TestSize.Level1)
872 {
873 int32_t ret;
874 struct IWiFiSta *staFeature = nullptr;
875
876 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
877 EXPECT_EQ(HDF_SUCCESS, ret);
878 EXPECT_NE(nullptr, staFeature);
879
880 const char *ifnameTest = staFeature->baseFeature.getNetworkIfaceName(nullptr);
881 EXPECT_EQ(nullptr, ifnameTest);
882 const char *ifName = staFeature->baseFeature.getNetworkIfaceName((const struct IWiFiBaseFeature *)staFeature);
883 EXPECT_NE(nullptr, ifName);
884 if (strncmp(ifName, "wlan", 4) == 0 || strncmp(ifName, "nan", 3) == 0 || strncmp(ifName, "p2p", 3) == 0) {
885 ret = 0;
886 } else {
887 ret = -1;
888 }
889 EXPECT_EQ(0, ret);
890
891 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
892 EXPECT_EQ(HDF_SUCCESS, ret);
893 }
894
895 /**
896 * @tc.name: WifiHalGetGetFeatureType002
897 * @tc.desc: Wifi hal get feature type function test
898 * @tc.type: FUNC
899 * @tc.require: AR000H603L
900 */
901 HWTEST_F(WifiHalTest, WifiHalGetGetFeatureType002, TestSize.Level1)
902 {
903 int32_t ret;
904 struct IWiFiSta *staFeature = nullptr;
905 int32_t type;
906
907 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
908 EXPECT_EQ(HDF_SUCCESS, ret);
909 EXPECT_NE(nullptr, staFeature);
910
911 type = staFeature->baseFeature.getFeatureType(nullptr);
912 EXPECT_EQ(HDF_FAILURE, type);
913 type = staFeature->baseFeature.getFeatureType((struct IWiFiBaseFeature *)staFeature);
914 EXPECT_EQ(PROTOCOL_80211_IFTYPE_STATION, type);
915
916 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
917 EXPECT_EQ(HDF_SUCCESS, ret);
918 }
919
920 /**
921 * @tc.name: GetDeviceMacAddress001
922 * @tc.desc: Wifi hal get device's MAC address test
923 * @tc.type: FUNC
924 * @tc.require: AR000H603L
925 */
926 HWTEST_F(WifiHalTest, GetDeviceMacAddress001, TestSize.Level1)
927 {
928 int32_t ret;
929 struct IWiFiAp *apFeature = nullptr;
930
931 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
932 EXPECT_EQ(HDF_SUCCESS, ret);
933 EXPECT_NE(nullptr, apFeature);
934
935 unsigned char readMac[ETH_ADDR_LEN] = {0};
936 ret = apFeature->baseFeature.getDeviceMacAddress(nullptr, readMac, ETH_ADDR_LEN);
937 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
938 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, nullptr, 0);
939 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
940 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, readMac, 0);
941 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
942 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, readMac, ETH_ADDR_LEN);
943 EXPECT_EQ(HDF_SUCCESS, ret);
944
945 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
946 EXPECT_EQ(HDF_SUCCESS, ret);
947 }
948
949 /**
950 * @tc.name: GetDeviceMacAddress002
951 * @tc.desc: Wifi hal get device's MAC address test
952 * @tc.type: FUNC
953 * @tc.require: AR000H603L
954 */
955 HWTEST_F(WifiHalTest, GetDeviceMacAddress002, TestSize.Level1)
956 {
957 int32_t ret;
958 struct IWiFiSta *staFeature = nullptr;
959
960 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
961 EXPECT_EQ(HDF_SUCCESS, ret);
962 EXPECT_NE(nullptr, staFeature);
963
964 unsigned char readMac[ETH_ADDR_LEN] = {0};
965 ret = staFeature->baseFeature.getDeviceMacAddress(nullptr, readMac, ETH_ADDR_LEN);
966 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
967 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, nullptr, 0);
968 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
969 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, readMac, 0);
970 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
971 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, readMac, ETH_ADDR_LEN);
972 EXPECT_EQ(HDF_SUCCESS, ret);
973
974 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
975 EXPECT_EQ(HDF_SUCCESS, ret);
976 }
977
978 /**
979 * @tc.name: GetValidFreqsWithBand001
980 * @tc.desc: Wifi hal get valid frequency with specific band test
981 * @tc.type: FUNC
982 * @tc.require: AR000H603L
983 */
984 HWTEST_F(WifiHalTest, GetValidFreqsWithBand001, TestSize.Level1)
985 {
986 int32_t ret;
987 struct IWiFiSta *staFeature = nullptr;
988 int32_t band = IEEE80211_BAND_2GHZ;
989 int32_t bandNotSupport = IEEE80211_NUM_BANDS;
990 int32_t freqs[MAX_CHANNEL_NUM] = {0};
991 uint32_t size = MAX_CHANNEL_NUM;
992 uint32_t num = 0;
993
994 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
995 EXPECT_EQ(HDF_SUCCESS, ret);
996 EXPECT_NE(nullptr, staFeature);
997 ret = staFeature->baseFeature.getValidFreqsWithBand(nullptr, band, freqs, size, &num);
998 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
999 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature,
1000 band, nullptr, size, &num);
1001 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1002 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature, band, freqs, 10, &num);
1003 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1004 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature,
1005 band, freqs, size, nullptr);
1006 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1007 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature,
1008 bandNotSupport, freqs, size, &num);
1009 EXPECT_NE(HDF_SUCCESS, ret);
1010 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature,
1011 band, freqs, size, &num);
1012 EXPECT_EQ(HDF_SUCCESS, ret);
1013
1014 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1015 EXPECT_EQ(HDF_SUCCESS, ret);
1016 }
1017
1018 /**
1019 * @tc.name: GetValidFreqsWithBand002
1020 * @tc.desc: Wifi hal get valid frequency with specific band test
1021 * @tc.type: FUNC
1022 * @tc.require: AR000H603L
1023 */
1024 HWTEST_F(WifiHalTest, GetValidFreqsWithBand002, TestSize.Level1)
1025 {
1026 int32_t ret;
1027 struct IWiFiAp *apFeature = nullptr;
1028 int32_t band = IEEE80211_BAND_2GHZ;
1029 int32_t bandNotSupport = IEEE80211_NUM_BANDS;
1030 int32_t freqs[MAX_CHANNEL_NUM] = {0};
1031 uint32_t size = MAX_CHANNEL_NUM;
1032 uint32_t num = 0;
1033
1034 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1035 EXPECT_EQ(HDF_SUCCESS, ret);
1036 EXPECT_NE(nullptr, apFeature);
1037 ret = apFeature->baseFeature.getValidFreqsWithBand(nullptr, band, freqs, size, &num);
1038 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1039 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature, band, nullptr, size, &num);
1040 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1041 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature, band, freqs, 10, &num);
1042 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1043 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature,
1044 band, freqs, size, nullptr);
1045 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1046 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature,
1047 bandNotSupport, freqs, size, &num);
1048 EXPECT_NE(HDF_SUCCESS, ret);
1049 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature, band, freqs, size, &num);
1050 EXPECT_EQ(HDF_SUCCESS, ret);
1051
1052 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1053 EXPECT_EQ(HDF_SUCCESS, ret);
1054 }
1055
1056 /**
1057 * @tc.name: WifiHalSetTxPower002
1058 * @tc.desc: Wifi hal set transmit power function test
1059 * @tc.type: FUNC
1060 * @tc.require: AR000H603L
1061 */
1062 HWTEST_F(WifiHalTest, WifiHalSetTxPower002, TestSize.Level1)
1063 {
1064 int32_t ret;
1065 struct IWiFiSta *staFeature = nullptr;
1066
1067 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1068 EXPECT_EQ(HDF_SUCCESS, ret);
1069 EXPECT_NE(nullptr, staFeature);
1070 ret = staFeature->baseFeature.setTxPower(nullptr, WLAN_TX_POWER);
1071 EXPECT_NE(HDF_SUCCESS, ret);
1072 ret = staFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)staFeature, -1);
1073 EXPECT_NE(HDF_SUCCESS, ret);
1074 ret = staFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)staFeature, WLAN_TX_POWER);
1075 EXPECT_EQ(HDF_SUCCESS, ret);
1076
1077 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1078 EXPECT_EQ(HDF_SUCCESS, ret);
1079 }
1080
1081 /**
1082 * @tc.name: WifiHalGetIfNamesByChipId002
1083 * @tc.desc: Obtain all ifNames and the number of the current chip
1084 * @tc.type: FUNC
1085 * @tc.require: AR000H603L
1086 */
1087 HWTEST_F(WifiHalTest, WifiHalGetIfNamesByChipId002, TestSize.Level1)
1088 {
1089 int32_t ret;
1090 struct IWiFiAp *apFeature = nullptr;
1091 char *ifNames = nullptr;
1092 unsigned int num = 0;
1093 unsigned char chipId = 0;
1094 uint8_t i;
1095
1096 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1097 EXPECT_EQ(HDF_SUCCESS, ret);
1098 EXPECT_NE(nullptr, apFeature);
1099 ret = apFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)apFeature, &chipId);
1100 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE);
1101 EXPECT_EQ(HDF_SUCCESS, ret);
1102
1103 ret = apFeature->baseFeature.getIfNamesByChipId(chipId, nullptr, nullptr);
1104 EXPECT_NE(HDF_SUCCESS, ret);
1105 ret = apFeature->baseFeature.getIfNamesByChipId(100, &ifNames, &num);
1106 EXPECT_NE(HDF_SUCCESS, ret);
1107 ret = apFeature->baseFeature.getIfNamesByChipId(chipId, &ifNames, &num);
1108 EXPECT_NE(nullptr, ifNames);
1109 EXPECT_EQ(HDF_SUCCESS, ret);
1110 bool flag = (num <= IFNAME_MAX_NUM && num >= IFNAME_MIN_NUM);
1111 ASSERT_TRUE(flag);
1112 for (i = 0; i < num; i++) {
1113 EXPECT_EQ(0, strncmp("wlan", ifNames + i * MAX_IF_NAME_LENGTH, SIZE));
1114 }
1115 free(ifNames);
1116
1117 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1118 EXPECT_EQ(HDF_SUCCESS, ret);
1119 }
1120
1121 /**
1122 * @tc.name: HalGetChipId001
1123 * @tc.desc: wifi hal get chip ID function test
1124 * @tc.type: FUNC
1125 * @tc.require: AR000H603L
1126 */
1127 HWTEST_F(WifiHalTest, HalGetChipId001, TestSize.Level1)
1128 {
1129 int32_t ret;
1130 struct IWiFiSta *staFeature = nullptr;
1131 unsigned char chipId = 0;
1132
1133 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1134 EXPECT_EQ(HDF_SUCCESS, ret);
1135 EXPECT_NE(nullptr, staFeature);
1136
1137 ret = staFeature->baseFeature.getChipId(nullptr, &chipId);
1138 EXPECT_NE(HDF_SUCCESS, ret);
1139 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, nullptr);
1140 EXPECT_NE(HDF_SUCCESS, ret);
1141 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId);
1142 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE);
1143 EXPECT_EQ(HDF_SUCCESS, ret);
1144
1145 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1146 EXPECT_EQ(HDF_SUCCESS, ret);
1147 }
1148
1149 /**
1150 * @tc.name: HalGetChipId002
1151 * @tc.desc: wifi hal get chip ID function test
1152 * @tc.type: FUNC
1153 * @tc.require: AR000H603L
1154 */
1155 HWTEST_F(WifiHalTest, HalGetChipId002, TestSize.Level1)
1156 {
1157 int32_t ret;
1158 struct IWiFiAp *apFeature = nullptr;
1159 unsigned char chipId = 0;
1160
1161 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1162 EXPECT_EQ(HDF_SUCCESS, ret);
1163 EXPECT_NE(nullptr, apFeature);
1164 ret = apFeature->baseFeature.getChipId(nullptr, &chipId);
1165 EXPECT_NE(HDF_SUCCESS, ret);
1166 ret = apFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)apFeature, nullptr);
1167 EXPECT_NE(HDF_SUCCESS, ret);
1168 ret = apFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)apFeature, &chipId);
1169 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE);
1170 EXPECT_EQ(HDF_SUCCESS, ret);
1171
1172 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1173 EXPECT_EQ(HDF_SUCCESS, ret);
1174 }
1175
1176 /**
1177 * @tc.name: GetAssociatedStas001
1178 * @tc.desc: wifi hal get association state function test
1179 * @tc.type: FUNC
1180 * @tc.require: AR000H603L
1181 */
1182 HWTEST_F(WifiHalTest, GetAssociatedStas001, TestSize.Level1)
1183 {
1184 int32_t ret;
1185 struct IWiFiAp *apFeature = nullptr;
1186 struct StaInfo staInfo[MAX_ASSOC_STA_NUM];
1187 (void)memset_s(staInfo, sizeof(StaInfo) * MAX_ASSOC_STA_NUM, 0, sizeof(StaInfo) * MAX_ASSOC_STA_NUM);
1188 uint32_t num = 0;
1189
1190 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1191 EXPECT_EQ(HDF_SUCCESS, ret);
1192 EXPECT_NE(nullptr, apFeature);
1193 ret = apFeature->getAssociatedStas(nullptr, staInfo, MAX_ASSOC_STA_NUM, &num);
1194 EXPECT_NE(HDF_SUCCESS, ret);
1195 ret = apFeature->getAssociatedStas(apFeature, nullptr, MAX_ASSOC_STA_NUM, &num);
1196 EXPECT_NE(HDF_SUCCESS, ret);
1197 ret = apFeature->getAssociatedStas(apFeature, staInfo, 0, &num);
1198 EXPECT_NE(HDF_SUCCESS, ret);
1199 ret = apFeature->getAssociatedStas(apFeature, staInfo, MAX_ASSOC_STA_NUM, nullptr);
1200 EXPECT_NE(HDF_SUCCESS, ret);
1201 ret = apFeature->getAssociatedStas(apFeature, staInfo, MAX_ASSOC_STA_NUM, &num);
1202 EXPECT_EQ(HDF_SUCCESS, ret);
1203
1204 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1205 EXPECT_EQ(HDF_SUCCESS, ret);
1206 }
1207
1208 /**
1209 * @tc.name: SetScanningMacAddress001
1210 * @tc.desc: wifi hal set scanning MAC address function test
1211 * @tc.type: FUNC
1212 * @tc.require: AR000H603L
1213 */
1214 HWTEST_F(WifiHalTest, SetScanningMacAddress001, TestSize.Level1)
1215 {
1216 int32_t ret;
1217 struct IWiFiSta *staFeature = nullptr;
1218 unsigned char scanMac[WIFI_MAC_ADDR_LENGTH] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
1219
1220 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1221 EXPECT_EQ(HDF_SUCCESS, ret);
1222 EXPECT_NE(nullptr, staFeature);
1223
1224 ret = staFeature->setScanningMacAddress(nullptr, scanMac, WIFI_MAC_ADDR_LENGTH);
1225 EXPECT_NE(HDF_SUCCESS, ret);
1226 ret = staFeature->setScanningMacAddress(staFeature, nullptr, WIFI_MAC_ADDR_LENGTH);
1227 EXPECT_NE(HDF_SUCCESS, ret);
1228 ret = staFeature->setScanningMacAddress(staFeature, scanMac, 0);
1229 EXPECT_NE(HDF_SUCCESS, ret);
1230 ret = staFeature->setScanningMacAddress(staFeature, scanMac, WIFI_MAC_ADDR_LENGTH);
1231 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
1232 ASSERT_TRUE(flag);
1233
1234 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1235 EXPECT_EQ(HDF_SUCCESS, ret);
1236 }
1237
1238 /**
1239 * @tc.name: SetProjectionScreenParam001
1240 * @tc.desc: wifi hal config projection screen function test
1241 * @tc.type: FUNC
1242 * @tc.require: AR000HDUEE
1243 */
1244 HWTEST_F(WifiHalTest, SetProjectionScreenParam001, TestSize.Level1)
1245 {
1246 int32_t ret;
1247 bool flag;
1248 struct IWiFiAp *apFeature = nullptr;
1249 ProjScrnCmdParam *param;
1250
1251 param = (ProjScrnCmdParam *)OsalMemCalloc(sizeof(ProjScrnCmdParam) + TEST_PARAM_BUF_SIZE);
1252 EXPECT_NE(nullptr, param);
1253 param->cmdId = TEST_CMD;
1254 param->bufLen = 1;
1255 param->buf[0] = 0;
1256 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1257 EXPECT_EQ(ret, HDF_SUCCESS);
1258 ret = g_wifi->setProjectionScreenParam(nullptr, nullptr);
1259 EXPECT_NE(ret, HDF_SUCCESS);
1260 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, nullptr);
1261 EXPECT_NE(ret, HDF_SUCCESS);
1262 ret = g_wifi->setProjectionScreenParam(nullptr, param);
1263 EXPECT_NE(ret, HDF_SUCCESS);
1264 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, param);
1265 EXPECT_NE(ret, HDF_SUCCESS);
1266 for (int i = CMD_CLOSE_GO_CAC; i <= CMD_ID_CTRL_ROAM_CHANNEL; i++) {
1267 param->cmdId = i;
1268 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, param);
1269 printf("SetProjectionScreenParam001_%d: ret = %d\n", __LINE__, ret);
1270 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
1271 ASSERT_TRUE(flag);
1272 }
1273 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1274 EXPECT_EQ(ret, HDF_SUCCESS);
1275 OsalMemFree(param);
1276 }
1277
1278 /**
1279 * @tc.name: SetProjectionScreenParam002
1280 * @tc.desc: wifi hal config projection screen function test
1281 * @tc.type: FUNC
1282 * @tc.require: AR000HDUEE
1283 */
1284 HWTEST_F(WifiHalTest, SetProjectionScreenParam002, TestSize.Level1)
1285 {
1286 int32_t ret;
1287 bool flag;
1288 struct IWiFiSta *staFeature = nullptr;
1289 ProjScrnCmdParam *param;
1290
1291 param = (ProjScrnCmdParam *)OsalMemCalloc(sizeof(ProjScrnCmdParam) + TEST_PARAM_BUF_SIZE);
1292 EXPECT_NE(nullptr, param);
1293 param->cmdId = TEST_CMD;
1294 param->bufLen = 1;
1295 param->buf[0] = 0;
1296 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1297 EXPECT_EQ(ret, HDF_SUCCESS);
1298 ret = g_wifi->setProjectionScreenParam(nullptr, nullptr);
1299 EXPECT_NE(ret, HDF_SUCCESS);
1300 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, nullptr);
1301 EXPECT_NE(ret, HDF_SUCCESS);
1302 ret = g_wifi->setProjectionScreenParam(nullptr, param);
1303 EXPECT_NE(ret, HDF_SUCCESS);
1304 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, param);
1305 EXPECT_NE(ret, HDF_SUCCESS);
1306 for (int i = CMD_CLOSE_GO_CAC; i <= CMD_ID_CTRL_ROAM_CHANNEL; i++) {
1307 param->cmdId = i;
1308 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, param);
1309 printf("SetProjectionScreenParam001_%d: ret = %d\n", __LINE__, ret);
1310 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
1311 ASSERT_TRUE(flag);
1312 }
1313 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1314 EXPECT_EQ(ret, HDF_SUCCESS);
1315 OsalMemFree(param);
1316 }
1317
1318 /**
1319 * @tc.name: SendCmdIoctl001
1320 * @tc.desc: wifi hal send ioctl command function test
1321 * @tc.type: FUNC
1322 * @tc.require: AR000HDUEE
1323 */
1324 HWTEST_F(WifiHalTest, SendCmdIoctl001, TestSize.Level1)
1325 {
1326 int32_t cmdId = 0;
1327 int32_t ret;
1328 bool flag;
1329 struct IWiFiAp *apFeature = nullptr;
1330 int8_t data[TEST_BUF_SIZE] = {0};
1331 const char *ifName = "wlan0";
1332
1333 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1334 EXPECT_EQ(ret, HDF_SUCCESS);
1335 ret = g_wifi->sendCmdIoctl(nullptr, cmdId, nullptr, TEST_BUF_SIZE);
1336 EXPECT_NE(ret, HDF_SUCCESS);
1337 ret = g_wifi->sendCmdIoctl(ifName, cmdId, nullptr, TEST_BUF_SIZE);
1338 EXPECT_NE(ret, HDF_SUCCESS);
1339 ret = g_wifi->sendCmdIoctl(nullptr, cmdId, data, TEST_BUF_SIZE);
1340 EXPECT_NE(ret, HDF_SUCCESS);
1341 for (cmdId = CMD_HID2D_MODULE_INIT; cmdId <= CMD_SET_CHAN_ADJUST; cmdId++) {
1342 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE);
1343 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret);
1344 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
1345 ASSERT_TRUE(flag);
1346 }
1347 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1348 EXPECT_EQ(ret, HDF_SUCCESS);
1349 }
1350
1351 /**
1352 * @tc.name: SendCmdIoctl002
1353 * @tc.desc: wifi hal send ioctl command function test
1354 * @tc.type: FUNC
1355 * @tc.require: AR000HDUEE
1356 */
1357 HWTEST_F(WifiHalTest, SendCmdIoctl002, TestSize.Level1)
1358 {
1359 int32_t cmdId = 0;
1360 int32_t ret;
1361 bool flag;
1362 struct IWiFiSta *staFeature = nullptr;
1363 int8_t data[TEST_BUF_SIZE] = {0};
1364 const char *ifName = "wlan0";
1365
1366 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1367 EXPECT_EQ(ret, HDF_SUCCESS);
1368 ret = g_wifi->sendCmdIoctl(nullptr, cmdId, nullptr, TEST_BUF_SIZE);
1369 EXPECT_NE(ret, HDF_SUCCESS);
1370 ret = g_wifi->sendCmdIoctl(ifName, cmdId, nullptr, TEST_BUF_SIZE);
1371 EXPECT_NE(ret, HDF_SUCCESS);
1372 ret = g_wifi->sendCmdIoctl(nullptr, cmdId, data, TEST_BUF_SIZE);
1373 EXPECT_NE(ret, HDF_SUCCESS);
1374 for (cmdId = CMD_HID2D_MODULE_INIT; cmdId <= CMD_SET_CHAN_ADJUST; cmdId++) {
1375 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE);
1376 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret);
1377 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
1378 ASSERT_TRUE(flag);
1379 }
1380 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1381 EXPECT_EQ(ret, HDF_SUCCESS);
1382 }
1383
1384 /**
1385 * @tc.name: GetStationInfo001
1386 * @tc.desc: Wifi hdi get station information function test
1387 * @tc.type: FUNC
1388 * @tc.require:
1389 */
1390 HWTEST_F(WifiHalTest, GetStationInfo001, TestSize.Level1)
1391 {
1392 int32_t ret;
1393 StationInfo info;
1394 bool flag;
1395 uint8_t mac[ETH_ADDR_LEN] = {0};
1396 struct IWiFiAp *apFeature = nullptr;
1397 const char *ifName = "wlan0";
1398
1399 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1400 EXPECT_EQ(ret, HDF_SUCCESS);
1401 ret = g_wifi->getStationInfo(nullptr, nullptr, nullptr, ETH_ADDR_LEN);
1402 EXPECT_NE(ret, HDF_SUCCESS);
1403 ret = g_wifi->getStationInfo(ifName, nullptr, nullptr, ETH_ADDR_LEN);
1404 EXPECT_NE(ret, HDF_SUCCESS);
1405 ret = g_wifi->getStationInfo(nullptr, &info, nullptr, ETH_ADDR_LEN);
1406 EXPECT_NE(ret, HDF_SUCCESS);
1407 ret = g_wifi->getStationInfo(nullptr, nullptr, mac, ETH_ADDR_LEN);
1408 EXPECT_NE(ret, HDF_SUCCESS);
1409 ret = g_wifi->getStationInfo(ifName, &info, nullptr, ETH_ADDR_LEN);
1410 EXPECT_NE(ret, HDF_SUCCESS);
1411 ret = g_wifi->getStationInfo(nullptr, &info, mac, ETH_ADDR_LEN);
1412 EXPECT_NE(ret, HDF_SUCCESS);
1413 ret = g_wifi->getStationInfo(ifName, nullptr, mac, ETH_ADDR_LEN);
1414 EXPECT_NE(ret, HDF_SUCCESS);
1415 ret = g_wifi->getStationInfo(ifName, &info, mac, ETH_ADDR_LEN);
1416 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
1417 ASSERT_TRUE(flag);
1418 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1419 EXPECT_EQ(ret, HDF_SUCCESS);
1420 }
1421
1422 /**
1423 * @tc.name: GetStationInfo002
1424 * @tc.desc: Wifi hdi get station information function test
1425 * @tc.type: FUNC
1426 * @tc.require:
1427 */
1428 HWTEST_F(WifiHalTest, GetStationInfo002, TestSize.Level1)
1429 {
1430 int32_t ret;
1431 StationInfo info;
1432 bool flag;
1433 uint8_t mac[ETH_ADDR_LEN] = {0};
1434 struct IWiFiSta *staFeature = nullptr;
1435 const char *ifName = "wlan0";
1436
1437 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&staFeature);
1438 EXPECT_EQ(ret, HDF_SUCCESS);
1439 ret = g_wifi->getStationInfo(nullptr, nullptr, nullptr, ETH_ADDR_LEN);
1440 EXPECT_NE(ret, HDF_SUCCESS);
1441 ret = g_wifi->getStationInfo(ifName, nullptr, nullptr, ETH_ADDR_LEN);
1442 EXPECT_NE(ret, HDF_SUCCESS);
1443 ret = g_wifi->getStationInfo(nullptr, &info, nullptr, ETH_ADDR_LEN);
1444 EXPECT_NE(ret, HDF_SUCCESS);
1445 ret = g_wifi->getStationInfo(nullptr, nullptr, mac, ETH_ADDR_LEN);
1446 EXPECT_NE(ret, HDF_SUCCESS);
1447 ret = g_wifi->getStationInfo(ifName, &info, nullptr, ETH_ADDR_LEN);
1448 EXPECT_NE(ret, HDF_SUCCESS);
1449 ret = g_wifi->getStationInfo(nullptr, &info, mac, ETH_ADDR_LEN);
1450 EXPECT_NE(ret, HDF_SUCCESS);
1451 ret = g_wifi->getStationInfo(ifName, nullptr, mac, ETH_ADDR_LEN);
1452 EXPECT_NE(ret, HDF_SUCCESS);
1453 ret = g_wifi->getStationInfo(ifName, &info, mac, ETH_ADDR_LEN);
1454 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
1455 ASSERT_TRUE(flag);
1456 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1457 EXPECT_EQ(ret, HDF_SUCCESS);
1458 }
1459
1460 /**
1461 * @tc.name: ResetDriver001
1462 * @tc.desc: wifi hal reset driver function test
1463 * @tc.type: FUNC
1464 * @tc.require: AR000H603L
1465 */
1466 HWTEST_F(WifiHalTest, ResetDriver001, TestSize.Level1)
1467 {
1468 int32_t ret;
1469 struct IWiFiSta *staFeature = nullptr;
1470 uint8_t chipId = 0;
1471 uint8_t chipIdInvalid = 20;
1472
1473 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1474 EXPECT_EQ(HDF_SUCCESS, ret);
1475 EXPECT_NE(nullptr, staFeature);
1476 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId);
1477 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE);
1478 EXPECT_EQ(HDF_SUCCESS, ret);
1479
1480 ret = g_wifi->resetDriver(chipIdInvalid, "wlan0");
1481 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1482 ret = g_wifi->resetDriver(chipId, nullptr);
1483 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1484 ret = g_wifi->resetDriver(chipId, staFeature->baseFeature.ifName);
1485 EXPECT_EQ(HDF_SUCCESS, ret);
1486 sleep(RESET_TIME);
1487 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1488 EXPECT_EQ(HDF_SUCCESS, ret);
1489 }
1490
1491 /**
1492 * @tc.name: ResetDriver002
1493 * @tc.desc: wifi hal reset driver function test
1494 * @tc.type: FUNC
1495 * @tc.require: AR000H603L
1496 */
1497 HWTEST_F(WifiHalTest, ResetDriver002, TestSize.Level1)
1498 {
1499 int32_t ret;
1500 struct IWiFiAp *apFeature = nullptr;
1501 uint8_t chipId = 0;
1502 uint8_t chipIdInvalid = 20;
1503
1504 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1505 EXPECT_EQ(HDF_SUCCESS, ret);
1506 EXPECT_NE(nullptr, apFeature);
1507 ret = apFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)apFeature, &chipId);
1508 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE);
1509 EXPECT_EQ(HDF_SUCCESS, ret);
1510
1511 ret = g_wifi->resetDriver(chipIdInvalid, "wlan0");
1512 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1513 ret = g_wifi->resetDriver(chipId, nullptr);
1514 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1515 ret = g_wifi->resetDriver(chipId, apFeature->baseFeature.ifName);
1516 EXPECT_EQ(HDF_SUCCESS, ret);
1517 sleep(RESET_TIME);
1518 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1519 EXPECT_EQ(HDF_SUCCESS, ret);
1520 }
1521 }; // namespace HalTest
1522