1 /*
2 * Copyright (c) 2021-2023 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 struct ElementHeader {
27 uint8_t id;
28 uint8_t datalen;
29 };
30
31 using namespace testing::ext;
32
33 namespace HalTest {
34 struct IWiFi *g_wifi = nullptr;
35 const int32_t WLAN_TX_POWER = 160;
36 const uint32_t IFNAME_MIN_NUM = 0;
37 const uint32_t IFNAME_MAX_NUM = 32;
38 const uint32_t MAX_IF_NAME_LENGTH = 16;
39 const uint32_t TEST_PARAM_BUF_SIZE = 64;
40 const uint32_t SIZE = 4;
41 const int32_t TEST_CMD = 123;
42 const uint32_t RESET_TIME = 3;
43 const uint32_t SCAN_TIME = 3;
44 const uint32_t TEST_BUF_SIZE = 64;
45 const uint32_t WLAN_EID_SSID = 0;
46
47 class WifiHalTest : public testing::Test {
48 public:
49 static void SetUpTestCase();
50 static void TearDownTestCase();
51 void SetUp();
52 void TearDown();
53 };
54
SetUpTestCase()55 void WifiHalTest::SetUpTestCase()
56 {
57 int ret;
58
59 ret = WifiConstruct(&g_wifi);
60 ASSERT_EQ(HDF_SUCCESS, ret);
61 }
62
TearDownTestCase()63 void WifiHalTest::TearDownTestCase()
64 {
65 int ret;
66
67 ret = WifiDestruct(&g_wifi);
68 ASSERT_EQ(HDF_SUCCESS, ret);
69 }
70
SetUp()71 void WifiHalTest::SetUp()
72 {
73 int ret;
74
75 ret = g_wifi->start(nullptr);
76 ASSERT_EQ(HDF_ERR_INVALID_PARAM, ret);
77 ret = g_wifi->start(g_wifi);
78 ASSERT_EQ(HDF_SUCCESS, ret);
79 }
80
TearDown()81 void WifiHalTest::TearDown()
82 {
83 int ret;
84
85 ret = g_wifi->stop(nullptr);
86 ASSERT_EQ(HDF_ERR_INVALID_PARAM, ret);
87 ret = g_wifi->stop(g_wifi);
88 ASSERT_EQ(HDF_SUCCESS, ret);
89 }
90
PrintSsid(const uint8_t * ie,uint32_t len)91 static void PrintSsid(const uint8_t *ie, uint32_t len)
92 {
93 char ssid[MAX_SSID_LEN] = {0};
94 uint8_t *pos = NULL;
95 struct ElementHeader *hdr = (struct ElementHeader *)ie;
96
97 if (ie == NULL || len < sizeof(struct ElementHeader)) {
98 return;
99 }
100 while (ie + len >= ((uint8_t *)hdr + sizeof(*hdr) + hdr->datalen)) {
101 pos = (uint8_t *)hdr + sizeof(*hdr);
102 if (hdr->id == WLAN_EID_SSID) {
103 if (hdr->datalen < MAX_SSID_LEN && memcpy_s(ssid, MAX_SSID_LEN, pos, hdr->datalen) == EOK) {
104 printf("ssid: %s\n", ssid);
105 }
106 return;
107 }
108 hdr = (struct ElementHeader *)(pos + hdr->datalen);
109 }
110 }
111
ParseScanResult(WifiScanResult * scanResult)112 static void ParseScanResult(WifiScanResult *scanResult)
113 {
114 printf("ParseScanResult: flags=%d, caps=%d, freq=%d, beaconInt=%d,\n", scanResult->flags, scanResult->caps,
115 scanResult->freq, scanResult->beaconInt);
116 printf("ParseScanResult: qual=%d, beaconIeLen=%d, level=%d, age=%d, ieLen=%d,\n", scanResult->qual,
117 scanResult->beaconIeLen, scanResult->level, scanResult->age, scanResult->ieLen);
118 PrintSsid(scanResult->ie, scanResult->ieLen);
119 }
120
ParseScanResults(WifiScanResults * scanResults)121 static void ParseScanResults(WifiScanResults *scanResults)
122 {
123 uint32_t i;
124 printf("Receive %u scan results\n", scanResults->num);
125 for (i = 0 ; i < scanResults->num; i++) {
126 ParseScanResult(&scanResults->scanResult[i]);
127 }
128 }
129
Hid2dFunCb(const uint8_t * recvMsg,uint32_t recvMsgLen)130 static int32_t Hid2dFunCb(const uint8_t *recvMsg, uint32_t recvMsgLen)
131 {
132 (void)recvMsg;
133 (void)recvMsgLen;
134 return HDF_SUCCESS;
135 }
136
137 /**
138 * @tc.name: WifiHalCreateAndDestroyFeature001
139 * @tc.desc: Wifi hal create and destroy feature function test
140 * @tc.type: FUNC
141 * @tc.require: AR000F869G
142 */
143 HWTEST_F(WifiHalTest, WifiHalCreateAndDestroyFeature001, TestSize.Level1)
144 {
145 int ret;
146 struct IWiFiAp *apFeature = nullptr;
147
148 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
149 if (ret == HDF_SUCCESS) {
150 EXPECT_NE(nullptr, apFeature);
151 ret = g_wifi->destroyFeature(nullptr);
152 EXPECT_NE(HDF_SUCCESS, ret);
153 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
154 EXPECT_EQ(HDF_SUCCESS, ret);
155 }
156 }
157
158 /**
159 * @tc.name: WifiHalCreateAndDestroyFeature002
160 * @tc.desc: Wifi hal create and destroy feature function test
161 * @tc.type: FUNC
162 * @tc.require: AR000F869E
163 */
164 HWTEST_F(WifiHalTest, WifiHalCreateAndDestroyFeature002, TestSize.Level1)
165 {
166 int ret;
167 struct IWiFiSta *staFeature = nullptr;
168
169 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
170 if (ret == HDF_SUCCESS) {
171 EXPECT_NE(nullptr, staFeature);
172 ret = g_wifi->destroyFeature(nullptr);
173 EXPECT_NE(HDF_SUCCESS, ret);
174 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
175 EXPECT_EQ(HDF_SUCCESS, ret);
176 }
177 }
178
179 /**
180 * @tc.name: WifiHalGetFeatureByIfName001
181 * @tc.desc: Wifi hal get feature by ifname function test
182 * @tc.type: FUNC
183 * @tc.require: AR000F869G
184 */
185 HWTEST_F(WifiHalTest, WifiHalGetFeatureByIfName001, TestSize.Level1)
186 {
187 int ret;
188 struct IWiFiAp *apFeature = nullptr;
189 struct IWiFiAp *apFeatureGet = nullptr;
190 const char *ifName0 = "wlanTest";
191
192 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
193 if (ret == HDF_SUCCESS) {
194 EXPECT_NE(nullptr, apFeature);
195 ret = g_wifi->getFeatureByIfName(nullptr, (struct IWiFiBaseFeature **)&apFeatureGet);
196 EXPECT_NE(HDF_SUCCESS, ret);
197 ret = g_wifi->getFeatureByIfName(ifName0, (struct IWiFiBaseFeature **)&apFeatureGet);
198 EXPECT_NE(HDF_SUCCESS, ret);
199 ret = g_wifi->getFeatureByIfName(apFeature->baseFeature.ifName, (struct IWiFiBaseFeature **)&apFeatureGet);
200 EXPECT_EQ(HDF_SUCCESS, ret);
201 EXPECT_NE(nullptr, apFeatureGet);
202 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
203 EXPECT_EQ(HDF_SUCCESS, ret);
204 }
205 }
206
HalCallbackEvent(uint32_t event,void * respData,const char * ifName)207 static int32_t HalCallbackEvent(uint32_t event, void *respData, const char *ifName)
208 {
209 (void)event;
210 if (respData == nullptr) {
211 return HDF_FAILURE;
212 }
213 printf("HalCallbackEvent ifName = %s, event = %d\n", ifName, event);
214 switch (event) {
215 case WIFI_EVENT_SCAN_DONE:
216 printf("HalCallbackEvent WIFI_EVENT_SCAN_DONE Process\n");
217 break;
218 case WIFI_EVENT_SCAN_RESULT:
219 ParseScanResult((WifiScanResult *)respData);
220 break;
221 case WIFI_EVENT_SCAN_RESULTS:
222 ParseScanResults((WifiScanResults *)respData);
223 break;
224 default:
225 printf("HalCallbackEvent: Invalid event\n");
226 }
227 return HDF_SUCCESS;
228 }
229
230 /**
231 * @tc.name: WifiHalRegisterEventCallback001
232 * @tc.desc: Wifi hal register callback function test
233 * @tc.type: FUNC
234 * @tc.require: AR000F869G
235 */
236 HWTEST_F(WifiHalTest, WifiHalRegisterEventCallback001, TestSize.Level1)
237 {
238 int ret;
239
240 ret = g_wifi->registerEventCallback(HalCallbackEvent, "wlan0");
241 EXPECT_EQ(HDF_SUCCESS, ret);
242 }
243
244 /**
245 * @tc.name: WifiHalUnRegisterEventCallback001
246 * @tc.desc: Wifi hal unregister callback function test
247 * @tc.type: FUNC
248 * @tc.require: AR000F869G
249 */
250 HWTEST_F(WifiHalTest, WifiHalUnRegisterEventCallback001, TestSize.Level1)
251 {
252 int ret;
253
254 ret = g_wifi->unregisterEventCallback(HalCallbackEvent, "wlan0");
255 EXPECT_EQ(HDF_SUCCESS, ret);
256 }
257
258 /**
259 * @tc.name: WifiHalGetNetworkIfaceName001
260 * @tc.desc: Wifi hal get network iface name function test
261 * @tc.type: FUNC
262 * @tc.require: AR000F869G
263 */
264 HWTEST_F(WifiHalTest, WifiHalGetNetworkIfaceName001, TestSize.Level1)
265 {
266 int ret;
267 struct IWiFiAp *apFeature = nullptr;
268
269 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
270 if (ret == HDF_SUCCESS) {
271 EXPECT_NE(nullptr, apFeature);
272 const char *ifnameTest = apFeature->baseFeature.getNetworkIfaceName(nullptr);
273 EXPECT_EQ(nullptr, ifnameTest);
274 const char *ifName = apFeature->baseFeature.getNetworkIfaceName((const struct IWiFiBaseFeature *)apFeature);
275 EXPECT_NE(nullptr, ifName);
276 if (strncmp(ifName, "wlan", 4) == 0 || strncmp(ifName, "nan", 3) == 0 || strncmp(ifName, "p2p", 3) == 0) {
277 ret = 0;
278 } else {
279 ret = -1;
280 }
281 EXPECT_EQ(0, ret);
282 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
283 EXPECT_EQ(HDF_SUCCESS, ret);
284 }
285 }
286
287 /**
288 * @tc.name: WifiHalGetGetFeatureType001
289 * @tc.desc: Wifi hal get feature type function test
290 * @tc.type: FUNC
291 * @tc.require: AR000F869G
292 */
293 HWTEST_F(WifiHalTest, WifiHalGetGetFeatureType001, TestSize.Level1)
294 {
295 int ret;
296 struct IWiFiAp *apFeature = nullptr;
297 int32_t type;
298 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
299 if (ret == HDF_SUCCESS) {
300 EXPECT_NE(nullptr, apFeature);
301 type = apFeature->baseFeature.getFeatureType(nullptr);
302 EXPECT_EQ(HDF_FAILURE, type);
303 type = apFeature->baseFeature.getFeatureType((struct IWiFiBaseFeature *)apFeature);
304 EXPECT_EQ(PROTOCOL_80211_IFTYPE_AP, type);
305 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
306 EXPECT_EQ(HDF_SUCCESS, ret);
307 }
308 }
309
310 /**
311 * @tc.name: WifiHalSetMacAddress001
312 * @tc.desc: Wifi hal set Mac address function test
313 * @tc.type: FUNC
314 * @tc.require: AR000F869G
315 */
316 HWTEST_F(WifiHalTest, WifiHalSetMacAddress001, TestSize.Level1)
317 {
318 int ret;
319 struct IWiFiAp *apFeature = nullptr;
320 unsigned char errorMac[ETH_ADDR_LEN] = {0x11, 0x34, 0x56, 0x78, 0xab, 0xcd};
321 unsigned char mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
322
323 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
324 if (ret == HDF_SUCCESS) {
325 EXPECT_NE(nullptr, apFeature);
326 ret = apFeature->baseFeature.setMacAddress(nullptr, mac, ETH_ADDR_LEN);
327 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
328 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, nullptr, ETH_ADDR_LEN);
329 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
330 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, mac, 0);
331 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
332 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, errorMac, ETH_ADDR_LEN);
333 EXPECT_NE(HDF_SUCCESS, ret);
334 ret = apFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)apFeature, mac, ETH_ADDR_LEN);
335 printf("%s: ret = %d\n", __func__, ret);
336 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_DEVICE_BUSY);
337 ASSERT_TRUE(flag);
338
339 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
340 EXPECT_EQ(HDF_SUCCESS, ret);
341 }
342 }
343
344 /**
345 * @tc.name: WifiHalSetMacAddress002
346 * @tc.desc: Wifi hal set Mac address function test
347 * @tc.type: FUNC
348 * @tc.require: AR000F869E
349 */
350 HWTEST_F(WifiHalTest, WifiHalSetMacAddress002, TestSize.Level1)
351 {
352 int ret;
353 struct IWiFiSta *staFeature = nullptr;
354 unsigned char mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
355 unsigned char errorMac[ETH_ADDR_LEN] = {0x11, 0x34, 0x56, 0x78, 0xab, 0xcd};
356
357 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
358 if (ret == HDF_SUCCESS) {
359 EXPECT_NE(nullptr, staFeature);
360 ret = staFeature->baseFeature.setMacAddress(nullptr, mac, ETH_ADDR_LEN);
361 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
362 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, nullptr, ETH_ADDR_LEN);
363 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
364 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, mac, 0);
365 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
366 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, errorMac, ETH_ADDR_LEN);
367 EXPECT_NE(HDF_SUCCESS, ret);
368 ret = staFeature->baseFeature.setMacAddress((struct IWiFiBaseFeature *)staFeature, mac, ETH_ADDR_LEN);
369 printf("%s: ret = %d\n", __func__, ret);
370 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_DEVICE_BUSY);
371 ASSERT_TRUE(flag);
372
373 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
374 EXPECT_EQ(HDF_SUCCESS, ret);
375 }
376 }
377
378 /**
379 * @tc.name: WifiHalSetTxPower001
380 * @tc.desc: Wifi hal set transmit power function test
381 * @tc.type: FUNC
382 * @tc.require: AR000F869G
383 */
384 HWTEST_F(WifiHalTest, WifiHalSetTxPower001, TestSize.Level1)
385 {
386 int ret;
387 struct IWiFiAp *apFeature = nullptr;
388
389 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
390 if (ret == HDF_SUCCESS) {
391 EXPECT_NE(nullptr, apFeature);
392 ret = apFeature->baseFeature.setTxPower(nullptr, WLAN_TX_POWER);
393 EXPECT_NE(HDF_SUCCESS, ret);
394 ret = apFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)apFeature, 0);
395 EXPECT_NE(HDF_SUCCESS, ret);
396 ret = apFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)apFeature, WLAN_TX_POWER);
397 EXPECT_EQ(HDF_SUCCESS, ret);
398
399 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
400 EXPECT_EQ(HDF_SUCCESS, ret);
401 }
402 }
403
404 /**
405 * @tc.name: ResetDriver001
406 * @tc.desc: wifi hal reset driver function test
407 * @tc.type: FUNC
408 * @tc.require:
409 */
410 HWTEST_F(WifiHalTest, ResetDriver001, TestSize.Level1)
411 {
412 int32_t ret;
413 struct IWiFiSta *staFeature = nullptr;
414 uint8_t chipId = 0;
415 uint8_t chipIdInvalid = 20;
416
417 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
418 if (ret == HDF_SUCCESS) {
419 EXPECT_NE(nullptr, staFeature);
420 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId);
421 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE);
422 EXPECT_EQ(HDF_SUCCESS, ret);
423
424 ret = g_wifi->resetDriver(chipIdInvalid, "wlan0");
425 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
426 ret = g_wifi->resetDriver(chipId, nullptr);
427 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
428 ret = g_wifi->resetDriver(chipId, staFeature->baseFeature.ifName);
429 EXPECT_EQ(HDF_SUCCESS, ret);
430 sleep(RESET_TIME);
431 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
432 EXPECT_EQ(HDF_SUCCESS, ret);
433 }
434 }
435
436 /**
437 * @tc.name: ResetDriver002
438 * @tc.desc: wifi hal reset driver function test
439 * @tc.type: FUNC
440 * @tc.require:
441 */
442 HWTEST_F(WifiHalTest, ResetDriver002, TestSize.Level1)
443 {
444 int32_t ret;
445 struct IWiFiAp *apFeature = nullptr;
446 uint8_t chipId = 0;
447 uint8_t chipIdInvalid = 20;
448
449 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
450 if (ret == HDF_SUCCESS) {
451 EXPECT_NE(nullptr, apFeature);
452 ret = apFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)apFeature, &chipId);
453 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE);
454 EXPECT_EQ(HDF_SUCCESS, ret);
455
456 ret = g_wifi->resetDriver(chipIdInvalid, "wlan0");
457 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
458 ret = g_wifi->resetDriver(chipId, nullptr);
459 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
460 ret = g_wifi->resetDriver(chipId, apFeature->baseFeature.ifName);
461 EXPECT_EQ(HDF_SUCCESS, ret);
462 sleep(RESET_TIME);
463 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
464 EXPECT_EQ(HDF_SUCCESS, ret);
465 }
466 }
467
468 /**
469 * @tc.name: WifiHalSetCountryCode001
470 * @tc.desc: Wifi hal set country code function test
471 * @tc.type: FUNC
472 * @tc.require: AR000F869K
473 */
474 HWTEST_F(WifiHalTest, WifiHalSetCountryCode001, TestSize.Level1)
475 {
476 int ret;
477 struct IWiFiAp *apFeature = nullptr;
478
479 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
480 if (ret == HDF_SUCCESS) {
481 EXPECT_NE(nullptr, apFeature);
482 ret = apFeature->setCountryCode(apFeature, nullptr, 0);
483 EXPECT_NE(HDF_SUCCESS, ret);
484 ret = apFeature->setCountryCode(nullptr, "CN", 2);
485 EXPECT_NE(HDF_SUCCESS, ret);
486 ret = apFeature->setCountryCode(apFeature, "CN", 3);
487 EXPECT_NE(HDF_SUCCESS, ret);
488 ret = apFeature->setCountryCode(apFeature, "99", 2);
489 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
490 ASSERT_TRUE(flag);
491 ret = apFeature->setCountryCode(apFeature, "CN", 2);
492 EXPECT_EQ(HDF_SUCCESS, ret);
493
494 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
495 EXPECT_EQ(HDF_SUCCESS, ret);
496 }
497 }
498
499 /**
500 * @tc.name: WifiHalGetIfNamesByChipId001
501 * @tc.desc: Obtain all ifNames and the number of the current chip
502 * @tc.type: FUNC
503 * @tc.require: AR000F869G
504 */
505 HWTEST_F(WifiHalTest, WifiHalGetIfNamesByChipId001, TestSize.Level1)
506 {
507 int ret;
508 struct IWiFiSta *staFeature = nullptr;
509 char *ifNames = nullptr;
510 unsigned int num = 0;
511 unsigned char chipId = 0;
512 uint8_t i;
513
514 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
515 if (ret == HDF_SUCCESS) {
516 EXPECT_NE(nullptr, staFeature);
517 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId);
518 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE);
519 EXPECT_EQ(HDF_SUCCESS, ret);
520 ret = staFeature->baseFeature.getIfNamesByChipId(chipId, nullptr, nullptr);
521 EXPECT_NE(HDF_SUCCESS, ret);
522 ret = staFeature->baseFeature.getIfNamesByChipId(100, &ifNames, &num);
523 EXPECT_NE(HDF_SUCCESS, ret);
524 ret = staFeature->baseFeature.getIfNamesByChipId(chipId, &ifNames, &num);
525 EXPECT_NE(nullptr, ifNames);
526 EXPECT_EQ(HDF_SUCCESS, ret);
527 ASSERT_TRUE(num <= IFNAME_MAX_NUM && num >= IFNAME_MIN_NUM);
528 for (i = 0; i < num; i++) {
529 EXPECT_EQ(0, strncmp("wlan", ifNames + i * MAX_IF_NAME_LENGTH, SIZE));
530 }
531 free(ifNames);
532
533 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
534 EXPECT_EQ(HDF_SUCCESS, ret);
535 }
536 }
537
538 HWTEST_F(WifiHalTest, GetNetDevInfo001, TestSize.Level1)
539 {
540 int ret;
541 struct IWiFiAp *apFeature = nullptr;
542 struct NetDeviceInfoResult netDeviceInfoResult;
543
544 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
545 if (ret == HDF_SUCCESS) {
546 EXPECT_NE(nullptr, apFeature);
547 ret = g_wifi->getNetDevInfo(nullptr);
548 EXPECT_NE(HDF_SUCCESS, ret);
549 ret = g_wifi->getNetDevInfo(&netDeviceInfoResult);
550 EXPECT_EQ(HDF_SUCCESS, ret);
551 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
552 EXPECT_EQ(HDF_SUCCESS, ret);
553 }
554 }
555
556 HWTEST_F(WifiHalTest, GetNetDevInfo002, TestSize.Level1)
557 {
558 int ret;
559 struct IWiFiSta *staFeature = nullptr;
560 struct NetDeviceInfoResult netDeviceInfoResult;
561
562 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
563 if (ret == HDF_SUCCESS) {
564 EXPECT_NE(nullptr, staFeature);
565 ret = g_wifi->getNetDevInfo(nullptr);
566 EXPECT_NE(HDF_SUCCESS, ret);
567 ret = g_wifi->getNetDevInfo(&netDeviceInfoResult);
568 EXPECT_EQ(HDF_SUCCESS, ret);
569 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
570 EXPECT_EQ(HDF_SUCCESS, ret);
571 }
572 }
573
574 /**
575 * @tc.name: GetPowerModeTest_001
576 * @tc.desc: Wifi hdi get power mode function test
577 * @tc.type: FUNC
578 * @tc.require: AR000H60O7
579 */
580 HWTEST_F(WifiHalTest, GetPowerMode001, TestSize.Level1)
581 {
582 int32_t ret;
583 struct IWiFiAp *apFeature = nullptr;
584 const char *ifName = "eth0";
585 uint8_t mode;
586
587 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
588 if (ret == HDF_SUCCESS) {
589 EXPECT_NE(nullptr, apFeature);
590 printf("GetPowerMode001: ifname is %s\n", apFeature->baseFeature.ifName);
591 ret = g_wifi->getPowerMode(nullptr, &mode);
592 EXPECT_NE(HDF_SUCCESS, ret);
593 ret = g_wifi->getPowerMode(ifName, nullptr);
594 EXPECT_NE(HDF_SUCCESS, ret);
595 ret = g_wifi->getPowerMode(ifName, &mode);
596 EXPECT_NE(HDF_SUCCESS, ret);
597 ret = g_wifi->getPowerMode(apFeature->baseFeature.ifName, nullptr);
598 EXPECT_NE(HDF_SUCCESS, ret);
599 ret = g_wifi->getPowerMode(apFeature->baseFeature.ifName, &mode);
600 printf("%s: ret = %d\n", __func__, ret);
601 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
602 ASSERT_TRUE(flag);
603 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
604 EXPECT_EQ(HDF_SUCCESS, ret);
605 }
606 }
607
608 /**
609 * @tc.name: GetPowerModeTest_002
610 * @tc.desc: Wifi hdi get power mode function test
611 * @tc.type: FUNC
612 * @tc.require: AR000H60O7
613 */
614 HWTEST_F(WifiHalTest, GetPowerMode002, TestSize.Level1)
615 {
616 int32_t ret;
617 struct IWiFiSta *staFeature = nullptr;
618 const char *ifName = "eth0";
619 uint8_t mode;
620
621 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
622 if (ret == HDF_SUCCESS) {
623 EXPECT_NE(nullptr, staFeature);
624 printf("GetPowerMode002: ifname is %s\n", staFeature->baseFeature.ifName);
625 ret = g_wifi->getPowerMode(nullptr, &mode);
626 EXPECT_NE(HDF_SUCCESS, ret);
627 ret = g_wifi->getPowerMode(ifName, nullptr);
628 EXPECT_NE(HDF_SUCCESS, ret);
629 ret = g_wifi->getPowerMode(ifName, &mode);
630 EXPECT_NE(HDF_SUCCESS, ret);
631 ret = g_wifi->getPowerMode(staFeature->baseFeature.ifName, nullptr);
632 EXPECT_NE(HDF_SUCCESS, ret);
633 ret = g_wifi->getPowerMode(staFeature->baseFeature.ifName, &mode);
634 printf("%s: ret = %d\n", __func__, ret);
635 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
636 ASSERT_TRUE(flag);
637 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
638 EXPECT_EQ(HDF_SUCCESS, ret);
639 }
640 }
641
642 /**
643 * @tc.name: SetPowerMode001
644 * @tc.desc: Wifi hdi set power mode function test
645 * @tc.type: FUNC
646 * @tc.require: AR000H60O7
647 */
648 HWTEST_F(WifiHalTest, SetPowerMode001, TestSize.Level1)
649 {
650 int32_t ret;
651 struct IWiFiAp *apFeature = nullptr;
652 const char *ifName = "eth0";
653
654 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
655 if (ret == HDF_SUCCESS) {
656 EXPECT_NE(nullptr, apFeature);
657 printf("SetPowerMode001: ifname is %s\n", apFeature->baseFeature.ifName);
658 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_NUM);
659 EXPECT_NE(HDF_SUCCESS, ret);
660 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_NUM);
661 EXPECT_NE(HDF_SUCCESS, ret);
662 ret = g_wifi->setPowerMode(apFeature->baseFeature.ifName, WIFI_POWER_MODE_NUM);
663 EXPECT_NE(HDF_SUCCESS, ret);
664 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
665 EXPECT_EQ(HDF_SUCCESS, ret);
666 }
667 }
668
669 /**
670 * @tc.name: SetPowerMode002
671 * @tc.desc: Wifi hdi set power mode function test
672 * @tc.type: FUNC
673 * @tc.require: AR000H60O7
674 */
675 HWTEST_F(WifiHalTest, SetPowerMode002, TestSize.Level1)
676 {
677 int32_t ret;
678 struct IWiFiAp *apFeature = nullptr;
679 const char *ifName = "eth0";
680
681 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
682 if (ret == HDF_SUCCESS) {
683 EXPECT_NE(nullptr, apFeature);
684 printf("SetPowerMode002: ifname is %s\n", apFeature->baseFeature.ifName);
685 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_SLEEPING);
686 EXPECT_NE(HDF_SUCCESS, ret);
687 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_SLEEPING);
688 EXPECT_NE(HDF_SUCCESS, ret);
689 ret = g_wifi->setPowerMode(apFeature->baseFeature.ifName, WIFI_POWER_MODE_SLEEPING);
690 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
691 ASSERT_TRUE(flag);
692 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
693 EXPECT_EQ(HDF_SUCCESS, ret);
694 }
695 }
696
697 /**
698 * @tc.name: SetPowerMode003
699 * @tc.desc: Wifi hdi set power mode function test
700 * @tc.type: FUNC
701 * @tc.require: AR000H60O7
702 */
703 HWTEST_F(WifiHalTest, SetPowerMode003, TestSize.Level1)
704 {
705 int32_t ret;
706 struct IWiFiAp *apFeature = nullptr;
707 const char *ifName = "eth0";
708
709 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
710 if (ret == HDF_SUCCESS) {
711 EXPECT_NE(nullptr, apFeature);
712 printf("SetPowerMode003: ifname is %s\n", apFeature->baseFeature.ifName);
713 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_GENERAL);
714 EXPECT_NE(HDF_SUCCESS, ret);
715 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_GENERAL);
716 EXPECT_NE(HDF_SUCCESS, ret);
717 ret = g_wifi->setPowerMode(apFeature->baseFeature.ifName, WIFI_POWER_MODE_GENERAL);
718 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
719 ASSERT_TRUE(flag);
720 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
721 EXPECT_EQ(HDF_SUCCESS, ret);
722 }
723 }
724
725 /**
726 * @tc.name: SetPowerMode004
727 * @tc.desc: Wifi hdi set power mode function test
728 * @tc.type: FUNC
729 * @tc.require: AR000H60O7
730 */
731 HWTEST_F(WifiHalTest, SetPowerMode004, TestSize.Level1)
732 {
733 int32_t ret;
734 struct IWiFiAp *apFeature = nullptr;
735 const char *ifName = "eth0";
736
737 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
738 if (ret == HDF_SUCCESS) {
739 EXPECT_NE(nullptr, apFeature);
740 printf("SetPowerMode004: ifname is %s\n", apFeature->baseFeature.ifName);
741 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_THROUGH_WALL);
742 EXPECT_NE(HDF_SUCCESS, ret);
743 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_THROUGH_WALL);
744 EXPECT_NE(HDF_SUCCESS, ret);
745 ret = g_wifi->setPowerMode(apFeature->baseFeature.ifName, WIFI_POWER_MODE_THROUGH_WALL);
746 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
747 ASSERT_TRUE(flag);
748 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
749 EXPECT_EQ(HDF_SUCCESS, ret);
750 }
751 }
752
753 /**
754 * @tc.name: SetPowerMode005
755 * @tc.desc: Wifi hdi set power mode function test
756 * @tc.type: FUNC
757 * @tc.require: AR000H60O7
758 */
759 HWTEST_F(WifiHalTest, SetPowerMode005, TestSize.Level1)
760 {
761 int32_t ret;
762 struct IWiFiSta *staFeature = nullptr;
763 const char *ifName = "eth0";
764
765 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
766 if (ret == HDF_SUCCESS) {
767 EXPECT_NE(nullptr, staFeature);
768 printf("SetPowerMode005: ifname is %s\n", staFeature->baseFeature.ifName);
769 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_NUM);
770 EXPECT_NE(HDF_SUCCESS, ret);
771 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_NUM);
772 EXPECT_NE(HDF_SUCCESS, ret);
773 ret = g_wifi->setPowerMode(staFeature->baseFeature.ifName, WIFI_POWER_MODE_NUM);
774 EXPECT_NE(HDF_SUCCESS, ret);
775 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
776 EXPECT_EQ(HDF_SUCCESS, ret);
777 }
778 }
779
780 /**
781 * @tc.name: SetPowerMode006
782 * @tc.desc: Wifi hdi set power mode function test
783 * @tc.type: FUNC
784 * @tc.require: AR000H60O7
785 */
786 HWTEST_F(WifiHalTest, SetPowerMode006, TestSize.Level1)
787 {
788 int32_t ret;
789 struct IWiFiSta *staFeature = nullptr;
790 const char *ifName = "eth0";
791
792 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
793 if (ret == HDF_SUCCESS) {
794 EXPECT_NE(nullptr, staFeature);
795 printf("SetPowerMode005: ifname is %s\n", staFeature->baseFeature.ifName);
796 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_SLEEPING);
797 EXPECT_NE(HDF_SUCCESS, ret);
798 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_SLEEPING);
799 EXPECT_NE(HDF_SUCCESS, ret);
800 ret = g_wifi->setPowerMode(staFeature->baseFeature.ifName, WIFI_POWER_MODE_SLEEPING);
801 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
802 ASSERT_TRUE(flag);
803 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
804 EXPECT_EQ(HDF_SUCCESS, ret);
805 }
806 }
807
808 /**
809 * @tc.name: SetPowerMode007
810 * @tc.desc: Wifi hdi set power mode function test
811 * @tc.type: FUNC
812 * @tc.require: AR000H60O7
813 */
814 HWTEST_F(WifiHalTest, SetPowerMode007, TestSize.Level1)
815 {
816 int32_t ret;
817 struct IWiFiSta *staFeature = nullptr;
818 const char *ifName = "eth0";
819
820 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
821 if (ret == HDF_SUCCESS) {
822 EXPECT_NE(nullptr, staFeature);
823 printf("SetPowerMode005: ifname is %s\n", staFeature->baseFeature.ifName);
824 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_GENERAL);
825 EXPECT_NE(HDF_SUCCESS, ret);
826 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_GENERAL);
827 EXPECT_NE(HDF_SUCCESS, ret);
828 ret = g_wifi->setPowerMode(staFeature->baseFeature.ifName, WIFI_POWER_MODE_GENERAL);
829 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
830 ASSERT_TRUE(flag);
831 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
832 EXPECT_EQ(HDF_SUCCESS, ret);
833 }
834 }
835
836 /**
837 * @tc.name: SetPowerMode008
838 * @tc.desc: Wifi hdi set power mode function test
839 * @tc.type: FUNC
840 * @tc.require: AR000H60O7
841 */
842 HWTEST_F(WifiHalTest, SetPowerMode008, TestSize.Level1)
843 {
844 int32_t ret;
845 struct IWiFiSta *staFeature = nullptr;
846 const char *ifName = "eth0";
847
848 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
849 if (ret == HDF_SUCCESS) {
850 EXPECT_NE(nullptr, staFeature);
851 printf("SetPowerMode005: ifname is %s\n", staFeature->baseFeature.ifName);
852 ret = g_wifi->setPowerMode(nullptr, WIFI_POWER_MODE_THROUGH_WALL);
853 EXPECT_NE(HDF_SUCCESS, ret);
854 ret = g_wifi->setPowerMode(ifName, WIFI_POWER_MODE_THROUGH_WALL);
855 EXPECT_NE(HDF_SUCCESS, ret);
856 ret = g_wifi->setPowerMode(staFeature->baseFeature.ifName, WIFI_POWER_MODE_THROUGH_WALL);
857 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
858 ASSERT_TRUE(flag);
859 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
860 EXPECT_EQ(HDF_SUCCESS, ret);
861 }
862 }
863
864 /**
865 * @tc.name: WifiHalStartScan001
866 * @tc.desc: Wifi hdi Start Scan function test
867 * @tc.type: FUNC
868 * @tc.require: AR000H60O7
869 */
870 HWTEST_F(WifiHalTest, WifiHalStartScan001, TestSize.Level1)
871 {
872 int ret;
873 struct IWiFiSta *staFeature = nullptr;
874 const char *ifName = "wlan0";
875 const char *ifNameInvalid = "wlanTest";
876 WifiScan scan = {0};
877
878 ret = g_wifi->registerEventCallback(HalCallbackEvent, ifName);
879 EXPECT_EQ(HDF_SUCCESS, ret);
880 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
881 if (ret == HDF_SUCCESS) {
882 EXPECT_NE(staFeature, nullptr);
883 ret = staFeature->startScan(nullptr, &scan);
884 EXPECT_NE(HDF_SUCCESS, ret);
885 ret = staFeature->startScan(ifName, nullptr);
886 EXPECT_NE(HDF_SUCCESS, ret);
887 ret = staFeature->startScan(ifNameInvalid, &scan);
888 EXPECT_NE(HDF_SUCCESS, ret);
889 ret = staFeature->startScan(ifName, &scan);
890 EXPECT_EQ(HDF_SUCCESS, ret);
891 sleep(SCAN_TIME);
892 }
893 }
894
895 /**
896 * @tc.name: WifiHalCreateFeature003
897 * @tc.desc: Wifi hal create feature function test
898 * @tc.type: FUNC
899 * @tc.require: AR000H603L
900 */
901 HWTEST_F(WifiHalTest, WifiHalCreateFeature003, TestSize.Level1)
902 {
903 int32_t ret;
904 struct IWiFiSta *staFeature = nullptr;
905
906 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, nullptr);
907 EXPECT_EQ(ret, HDF_FAILURE);
908 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, nullptr);
909 EXPECT_EQ(ret, HDF_FAILURE);
910
911 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_NUM, (struct IWiFiBaseFeature **)&staFeature);
912 EXPECT_NE(HDF_SUCCESS, ret);
913 ret = g_wifi->createFeature(-1, (struct IWiFiBaseFeature **)&staFeature);
914 EXPECT_NE(HDF_SUCCESS, ret);
915 }
916
917 /**
918 * @tc.name: WifiHalGetFeatureByIfName002
919 * @tc.desc: Wifi hal get feature by ifname function test
920 * @tc.type: FUNC
921 * @tc.require: AR000H603L
922 */
923 HWTEST_F(WifiHalTest, WifiHalGetFeatureByIfName002, TestSize.Level1)
924 {
925 int32_t ret;
926 struct IWiFiSta *staFeature = nullptr;
927 struct IWiFiSta *staFeatureGet = nullptr;
928 const char *ifName0 = "wlanTest";
929
930 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
931 if (ret == HDF_SUCCESS) {
932 EXPECT_NE(nullptr, staFeature);
933 ret = g_wifi->getFeatureByIfName(nullptr, (struct IWiFiBaseFeature **)&staFeature);
934 EXPECT_NE(HDF_SUCCESS, ret);
935 ret = g_wifi->getFeatureByIfName(ifName0, (struct IWiFiBaseFeature **)&staFeature);
936 EXPECT_NE(HDF_SUCCESS, ret);
937 ret = g_wifi->getFeatureByIfName(staFeature->baseFeature.ifName, (struct IWiFiBaseFeature **)&staFeatureGet);
938 EXPECT_EQ(HDF_SUCCESS, ret);
939 EXPECT_NE(nullptr, staFeatureGet);
940
941 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
942 EXPECT_EQ(HDF_SUCCESS, ret);
943 }
944 }
945
946 /**
947 * @tc.name: WifiHalRegisterEventCallback002
948 * @tc.desc: Wifi hal register event callback test
949 * @tc.type: FUNC
950 * @tc.require: AR000H603L
951 */
952 HWTEST_F(WifiHalTest, WifiHalRegisterEventCallback002, TestSize.Level1)
953 {
954 int32_t ret;
955
956 ret = g_wifi->registerEventCallback(nullptr, "wlan0");
957 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
958 ret = g_wifi->registerEventCallback(HalCallbackEvent, nullptr);
959 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
960 }
961
962 /**
963 * @tc.name: WifiHalUnRegisterEventCallback002
964 * @tc.desc: Wifi hal unregister event callback test
965 * @tc.type: FUNC
966 * @tc.require: AR000H603L
967 */
968 HWTEST_F(WifiHalTest, WifiHalUnRegisterEventCallback002, TestSize.Level1)
969 {
970 int32_t ret;
971
972 ret = g_wifi->unregisterEventCallback(nullptr, "wlan0");
973 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
974 ret = g_wifi->unregisterEventCallback(HalCallbackEvent, nullptr);
975 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
976 }
977
978 /**
979 * @tc.name: GetSupportFeature001
980 * @tc.desc: Wifi hal get supported feature test
981 * @tc.type: FUNC
982 * @tc.require: AR000H603L
983 */
984 HWTEST_F(WifiHalTest, GetSupportFeature001, TestSize.Level1)
985 {
986 int32_t ret;
987 uint8_t supType[PROTOCOL_80211_IFTYPE_NUM + 1] = {0};
988
989 ret = g_wifi->getSupportFeature(nullptr, PROTOCOL_80211_IFTYPE_NUM + 1);
990 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
991 ret = g_wifi->getSupportFeature(supType, PROTOCOL_80211_IFTYPE_NUM);
992 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
993
994 ret = g_wifi->getSupportFeature(supType, PROTOCOL_80211_IFTYPE_NUM + 1);
995 EXPECT_EQ(RET_CODE_SUCCESS, ret);
996 }
997
998 /**
999 * @tc.name: WifiHalGetNetworkIfaceName002
1000 * @tc.desc: Wifi hal get network iface name function test
1001 * @tc.type: FUNC
1002 * @tc.require: AR000H603L
1003 */
1004 HWTEST_F(WifiHalTest, WifiHalGetNetworkIfaceName002, TestSize.Level1)
1005 {
1006 int32_t ret;
1007 struct IWiFiSta *staFeature = nullptr;
1008
1009 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1010 if (ret == HDF_SUCCESS) {
1011 EXPECT_NE(nullptr, staFeature);
1012 const char *ifnameTest = staFeature->baseFeature.getNetworkIfaceName(nullptr);
1013 EXPECT_EQ(nullptr, ifnameTest);
1014 const char *ifName = staFeature->baseFeature.getNetworkIfaceName((const struct IWiFiBaseFeature *)staFeature);
1015 EXPECT_NE(nullptr, ifName);
1016 if (strncmp(ifName, "wlan", 4) == 0 || strncmp(ifName, "nan", 3) == 0 || strncmp(ifName, "p2p", 3) == 0) {
1017 ret = 0;
1018 } else {
1019 ret = -1;
1020 }
1021 EXPECT_EQ(0, ret);
1022 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1023 EXPECT_EQ(HDF_SUCCESS, ret);
1024 }
1025 }
1026
1027 /**
1028 * @tc.name: WifiHalGetGetFeatureType002
1029 * @tc.desc: Wifi hal get feature type function test
1030 * @tc.type: FUNC
1031 * @tc.require: AR000H603L
1032 */
1033 HWTEST_F(WifiHalTest, WifiHalGetGetFeatureType002, TestSize.Level1)
1034 {
1035 int32_t ret;
1036 struct IWiFiSta *staFeature = nullptr;
1037 int32_t type;
1038
1039 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1040 if (ret == HDF_SUCCESS) {
1041 EXPECT_NE(nullptr, staFeature);
1042 type = staFeature->baseFeature.getFeatureType(nullptr);
1043 EXPECT_EQ(HDF_FAILURE, type);
1044 type = staFeature->baseFeature.getFeatureType((struct IWiFiBaseFeature *)staFeature);
1045 EXPECT_EQ(PROTOCOL_80211_IFTYPE_STATION, type);
1046 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1047 EXPECT_EQ(HDF_SUCCESS, ret);
1048 }
1049 }
1050
1051 /**
1052 * @tc.name: GetDeviceMacAddress001
1053 * @tc.desc: Wifi hal get device's MAC address test
1054 * @tc.type: FUNC
1055 * @tc.require: AR000H603L
1056 */
1057 HWTEST_F(WifiHalTest, GetDeviceMacAddress001, TestSize.Level1)
1058 {
1059 int32_t ret;
1060 struct IWiFiAp *apFeature = nullptr;
1061
1062 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1063 if (ret == HDF_SUCCESS) {
1064 EXPECT_NE(nullptr, apFeature);
1065 unsigned char readMac[ETH_ADDR_LEN] = {0};
1066 ret = apFeature->baseFeature.getDeviceMacAddress(nullptr, readMac, ETH_ADDR_LEN);
1067 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1068 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, nullptr, 0);
1069 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1070 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, readMac, 0);
1071 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1072 ret = apFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)apFeature, readMac, ETH_ADDR_LEN);
1073 EXPECT_EQ(HDF_SUCCESS, ret);
1074
1075 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1076 EXPECT_EQ(HDF_SUCCESS, ret);
1077 }
1078 }
1079
1080 /**
1081 * @tc.name: GetDeviceMacAddress002
1082 * @tc.desc: Wifi hal get device's MAC address test
1083 * @tc.type: FUNC
1084 * @tc.require: AR000H603L
1085 */
1086 HWTEST_F(WifiHalTest, GetDeviceMacAddress002, TestSize.Level1)
1087 {
1088 int32_t ret;
1089 struct IWiFiSta *staFeature = nullptr;
1090
1091 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1092 if (ret == HDF_SUCCESS) {
1093 EXPECT_NE(nullptr, staFeature);
1094 unsigned char readMac[ETH_ADDR_LEN] = {0};
1095 ret = staFeature->baseFeature.getDeviceMacAddress(nullptr, readMac, ETH_ADDR_LEN);
1096 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1097 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, nullptr, 0);
1098 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1099 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, readMac, 0);
1100 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1101 ret = staFeature->baseFeature.getDeviceMacAddress((struct IWiFiBaseFeature *)staFeature, readMac, ETH_ADDR_LEN);
1102 EXPECT_EQ(HDF_SUCCESS, ret);
1103
1104 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1105 EXPECT_EQ(HDF_SUCCESS, ret);
1106 }
1107 }
1108
1109 /**
1110 * @tc.name: GetValidFreqsWithBand001
1111 * @tc.desc: Wifi hal get valid frequency with specific band test
1112 * @tc.type: FUNC
1113 * @tc.require: AR000H603L
1114 */
1115 HWTEST_F(WifiHalTest, GetValidFreqsWithBand001, TestSize.Level1)
1116 {
1117 int32_t ret;
1118 struct IWiFiSta *staFeature = nullptr;
1119 int32_t band = IEEE80211_BAND_2GHZ;
1120 int32_t bandNotSupport = IEEE80211_NUM_BANDS;
1121 int32_t freqs[MAX_CHANNEL_NUM] = {0};
1122 uint32_t size = MAX_CHANNEL_NUM;
1123 uint32_t num = 0;
1124
1125 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1126 if (ret == HDF_SUCCESS) {
1127 EXPECT_NE(nullptr, staFeature);
1128 ret = staFeature->baseFeature.getValidFreqsWithBand(nullptr, band, freqs, size, &num);
1129 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1130 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature,
1131 band, nullptr, size, &num);
1132 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1133 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature,
1134 band, freqs, 10, &num);
1135 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1136 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature,
1137 band, freqs, size, nullptr);
1138 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1139 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature,
1140 bandNotSupport, freqs, size, &num);
1141 EXPECT_NE(HDF_SUCCESS, ret);
1142 ret = staFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)staFeature,
1143 band, freqs, size, &num);
1144 EXPECT_EQ(HDF_SUCCESS, ret);
1145
1146 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1147 EXPECT_EQ(HDF_SUCCESS, ret);
1148 }
1149 }
1150
1151 /**
1152 * @tc.name: GetValidFreqsWithBand002
1153 * @tc.desc: Wifi hal get valid frequency with specific band test
1154 * @tc.type: FUNC
1155 * @tc.require: AR000H603L
1156 */
1157 HWTEST_F(WifiHalTest, GetValidFreqsWithBand002, TestSize.Level1)
1158 {
1159 int32_t ret;
1160 struct IWiFiAp *apFeature = nullptr;
1161 int32_t band = IEEE80211_BAND_2GHZ;
1162 int32_t bandNotSupport = IEEE80211_NUM_BANDS;
1163 int32_t freqs[MAX_CHANNEL_NUM] = {0};
1164 uint32_t size = MAX_CHANNEL_NUM;
1165 uint32_t num = 0;
1166
1167 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1168 if (ret == HDF_SUCCESS) {
1169 EXPECT_NE(nullptr, apFeature);
1170 ret = apFeature->baseFeature.getValidFreqsWithBand(nullptr, band, freqs, size, &num);
1171 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1172 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature,
1173 band, nullptr, size, &num);
1174 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1175 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature, band, freqs, 10, &num);
1176 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1177 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature,
1178 band, freqs, size, nullptr);
1179 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1180 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature,
1181 bandNotSupport, freqs, size, &num);
1182 EXPECT_NE(HDF_SUCCESS, ret);
1183 ret = apFeature->baseFeature.getValidFreqsWithBand((struct IWiFiBaseFeature *)apFeature,
1184 band, freqs, size, &num);
1185 EXPECT_EQ(HDF_SUCCESS, ret);
1186
1187 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1188 EXPECT_EQ(HDF_SUCCESS, ret);
1189 }
1190 }
1191
1192 /**
1193 * @tc.name: WifiHalSetTxPower002
1194 * @tc.desc: Wifi hal set transmit power function test
1195 * @tc.type: FUNC
1196 * @tc.require: AR000H603L
1197 */
1198 HWTEST_F(WifiHalTest, WifiHalSetTxPower002, TestSize.Level1)
1199 {
1200 int32_t ret;
1201 struct IWiFiSta *staFeature = nullptr;
1202
1203 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1204 if (ret == HDF_SUCCESS) {
1205 EXPECT_NE(nullptr, staFeature);
1206 ret = staFeature->baseFeature.setTxPower(nullptr, WLAN_TX_POWER);
1207 EXPECT_NE(HDF_SUCCESS, ret);
1208 ret = staFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)staFeature, -1);
1209 EXPECT_NE(HDF_SUCCESS, ret);
1210 ret = staFeature->baseFeature.setTxPower((struct IWiFiBaseFeature *)staFeature, WLAN_TX_POWER);
1211 EXPECT_EQ(HDF_SUCCESS, ret);
1212
1213 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1214 EXPECT_EQ(HDF_SUCCESS, ret);
1215 }
1216 }
1217
1218 /**
1219 * @tc.name: WifiHalGetIfNamesByChipId002
1220 * @tc.desc: Obtain all ifNames and the number of the current chip
1221 * @tc.type: FUNC
1222 * @tc.require: AR000H603L
1223 */
1224 HWTEST_F(WifiHalTest, WifiHalGetIfNamesByChipId002, TestSize.Level1)
1225 {
1226 int32_t ret;
1227 struct IWiFiAp *apFeature = nullptr;
1228 char *ifNames = nullptr;
1229 unsigned int num = 0;
1230 unsigned char chipId = 0;
1231 uint8_t i;
1232
1233 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1234 if (ret == HDF_SUCCESS) {
1235 EXPECT_NE(nullptr, apFeature);
1236 ret = apFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)apFeature, &chipId);
1237 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE);
1238 EXPECT_EQ(HDF_SUCCESS, ret);
1239
1240 ret = apFeature->baseFeature.getIfNamesByChipId(chipId, nullptr, nullptr);
1241 EXPECT_NE(HDF_SUCCESS, ret);
1242 ret = apFeature->baseFeature.getIfNamesByChipId(100, &ifNames, &num);
1243 EXPECT_NE(HDF_SUCCESS, ret);
1244 ret = apFeature->baseFeature.getIfNamesByChipId(chipId, &ifNames, &num);
1245 EXPECT_NE(nullptr, ifNames);
1246 EXPECT_EQ(HDF_SUCCESS, ret);
1247 bool flag = (num <= IFNAME_MAX_NUM && num >= IFNAME_MIN_NUM);
1248 ASSERT_TRUE(flag);
1249 for (i = 0; i < num; i++) {
1250 EXPECT_EQ(0, strncmp("wlan", ifNames + i * MAX_IF_NAME_LENGTH, SIZE));
1251 }
1252 free(ifNames);
1253
1254 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1255 EXPECT_EQ(HDF_SUCCESS, ret);
1256 }
1257 }
1258
1259 /**
1260 * @tc.name: HalGetChipId001
1261 * @tc.desc: wifi hal get chip ID function test
1262 * @tc.type: FUNC
1263 * @tc.require: AR000H603L
1264 */
1265 HWTEST_F(WifiHalTest, HalGetChipId001, TestSize.Level1)
1266 {
1267 int32_t ret;
1268 struct IWiFiSta *staFeature = nullptr;
1269 unsigned char chipId = 0;
1270
1271 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1272 if (ret == HDF_SUCCESS) {
1273 EXPECT_NE(nullptr, staFeature);
1274 ret = staFeature->baseFeature.getChipId(nullptr, &chipId);
1275 EXPECT_NE(HDF_SUCCESS, ret);
1276 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, nullptr);
1277 EXPECT_NE(HDF_SUCCESS, ret);
1278 ret = staFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)staFeature, &chipId);
1279 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE);
1280 EXPECT_EQ(HDF_SUCCESS, ret);
1281
1282 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1283 EXPECT_EQ(HDF_SUCCESS, ret);
1284 }
1285 }
1286
1287 /**
1288 * @tc.name: HalGetChipId002
1289 * @tc.desc: wifi hal get chip ID function test
1290 * @tc.type: FUNC
1291 * @tc.require: AR000H603L
1292 */
1293 HWTEST_F(WifiHalTest, HalGetChipId002, TestSize.Level1)
1294 {
1295 int32_t ret;
1296 struct IWiFiAp *apFeature = nullptr;
1297 unsigned char chipId = 0;
1298
1299 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1300 if (ret == HDF_SUCCESS) {
1301 EXPECT_NE(nullptr, apFeature);
1302 ret = apFeature->baseFeature.getChipId(nullptr, &chipId);
1303 EXPECT_NE(HDF_SUCCESS, ret);
1304 ret = apFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)apFeature, nullptr);
1305 EXPECT_NE(HDF_SUCCESS, ret);
1306 ret = apFeature->baseFeature.getChipId((struct IWiFiBaseFeature *)apFeature, &chipId);
1307 ASSERT_TRUE(chipId < MAX_WLAN_DEVICE);
1308 EXPECT_EQ(HDF_SUCCESS, ret);
1309
1310 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1311 EXPECT_EQ(HDF_SUCCESS, ret);
1312 }
1313 }
1314
1315 /**
1316 * @tc.name: GetAssociatedStas001
1317 * @tc.desc: wifi hal get association state function test
1318 * @tc.type: FUNC
1319 * @tc.require: AR000H603L
1320 */
1321 HWTEST_F(WifiHalTest, GetAssociatedStas001, TestSize.Level1)
1322 {
1323 int32_t ret;
1324 struct IWiFiAp *apFeature = nullptr;
1325 struct StaInfo staInfo[MAX_ASSOC_STA_NUM];
1326 (void)memset_s(staInfo, sizeof(StaInfo) * MAX_ASSOC_STA_NUM, 0, sizeof(StaInfo) * MAX_ASSOC_STA_NUM);
1327 uint32_t num = 0;
1328
1329 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1330 if (ret == HDF_SUCCESS) {
1331 EXPECT_NE(nullptr, apFeature);
1332 ret = apFeature->getAssociatedStas(nullptr, staInfo, MAX_ASSOC_STA_NUM, &num);
1333 EXPECT_NE(HDF_SUCCESS, ret);
1334 ret = apFeature->getAssociatedStas(apFeature, nullptr, MAX_ASSOC_STA_NUM, &num);
1335 EXPECT_NE(HDF_SUCCESS, ret);
1336 ret = apFeature->getAssociatedStas(apFeature, staInfo, 0, &num);
1337 EXPECT_NE(HDF_SUCCESS, ret);
1338 ret = apFeature->getAssociatedStas(apFeature, staInfo, MAX_ASSOC_STA_NUM, nullptr);
1339 EXPECT_NE(HDF_SUCCESS, ret);
1340 ret = apFeature->getAssociatedStas(apFeature, staInfo, MAX_ASSOC_STA_NUM, &num);
1341 EXPECT_EQ(HDF_SUCCESS, ret);
1342
1343 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1344 EXPECT_EQ(HDF_SUCCESS, ret);
1345 }
1346 }
1347
1348 /**
1349 * @tc.name: SetScanningMacAddress001
1350 * @tc.desc: wifi hal set scanning MAC address function test
1351 * @tc.type: FUNC
1352 * @tc.require: AR000H603L
1353 */
1354 HWTEST_F(WifiHalTest, SetScanningMacAddress001, TestSize.Level1)
1355 {
1356 int32_t ret;
1357 struct IWiFiSta *staFeature = nullptr;
1358 unsigned char scanMac[WIFI_MAC_ADDR_LENGTH] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
1359
1360 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1361 if (ret == HDF_SUCCESS) {
1362 EXPECT_NE(nullptr, staFeature);
1363 ret = staFeature->setScanningMacAddress(nullptr, scanMac, WIFI_MAC_ADDR_LENGTH);
1364 EXPECT_NE(HDF_SUCCESS, ret);
1365 ret = staFeature->setScanningMacAddress(staFeature, nullptr, WIFI_MAC_ADDR_LENGTH);
1366 EXPECT_NE(HDF_SUCCESS, ret);
1367 ret = staFeature->setScanningMacAddress(staFeature, scanMac, 0);
1368 EXPECT_NE(HDF_SUCCESS, ret);
1369 ret = staFeature->setScanningMacAddress(staFeature, scanMac, WIFI_MAC_ADDR_LENGTH);
1370 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
1371 ASSERT_TRUE(flag);
1372
1373 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1374 EXPECT_EQ(HDF_SUCCESS, ret);
1375 }
1376 }
1377
1378 /**
1379 * @tc.name: SetProjectionScreenParam001
1380 * @tc.desc: wifi hal config projection screen function test
1381 * @tc.type: FUNC
1382 * @tc.require: AR000HDUEE
1383 */
1384 HWTEST_F(WifiHalTest, SetProjectionScreenParam001, TestSize.Level1)
1385 {
1386 int32_t ret;
1387 bool flag;
1388 struct IWiFiAp *apFeature = nullptr;
1389 ProjectionScreenParam *param;
1390
1391 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE);
1392 EXPECT_NE(nullptr, param);
1393 param->cmdId = TEST_CMD;
1394 param->bufLen = 1;
1395 param->buf[0] = 0;
1396 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1397 if (ret == HDF_SUCCESS) {
1398 ret = g_wifi->setProjectionScreenParam(nullptr, nullptr);
1399 EXPECT_NE(ret, HDF_SUCCESS);
1400 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, nullptr);
1401 EXPECT_NE(ret, HDF_SUCCESS);
1402 ret = g_wifi->setProjectionScreenParam(nullptr, param);
1403 EXPECT_NE(ret, HDF_SUCCESS);
1404 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, param);
1405 EXPECT_NE(ret, HDF_SUCCESS);
1406
1407 param->cmdId = CMD_CLOSE_GO_CAC;
1408 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, param);
1409 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret);
1410 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
1411 ASSERT_TRUE(flag);
1412
1413 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1414 EXPECT_EQ(ret, HDF_SUCCESS);
1415 }
1416 OsalMemFree(param);
1417 }
1418
1419 /**
1420 * @tc.name: SetProjectionScreenParam002
1421 * @tc.desc: wifi hal config projection screen function test
1422 * @tc.type: FUNC
1423 * @tc.require:
1424 */
1425 HWTEST_F(WifiHalTest, SetProjectionScreenParam002, TestSize.Level1)
1426 {
1427 int32_t ret;
1428 bool flag;
1429 struct IWiFiAp *apFeature = nullptr;
1430 ProjectionScreenParam *param;
1431
1432 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE);
1433 EXPECT_NE(nullptr, param);
1434 param->bufLen = 1;
1435 param->buf[0] = 0;
1436 param->cmdId = CMD_SET_GO_CSA_CHANNEL;
1437
1438 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1439 if (ret == HDF_SUCCESS) {
1440 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, param);
1441 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret);
1442 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN);
1443 ASSERT_TRUE(flag);
1444 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1445 EXPECT_EQ(ret, HDF_SUCCESS);
1446 }
1447 OsalMemFree(param);
1448 }
1449
1450 /**
1451 * @tc.name: SetProjectionScreenParam003
1452 * @tc.desc: wifi hal config projection screen function test
1453 * @tc.type: FUNC
1454 * @tc.require:
1455 */
1456 HWTEST_F(WifiHalTest, SetProjectionScreenParam003, TestSize.Level1)
1457 {
1458 int32_t ret;
1459 bool flag;
1460 struct IWiFiAp *apFeature = nullptr;
1461 ProjectionScreenParam *param;
1462
1463 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE);
1464 EXPECT_NE(nullptr, param);
1465 param->bufLen = 1;
1466 param->buf[0] = 0;
1467 param->cmdId = CMD_SET_GO_RADAR_DETECT;
1468
1469 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1470 if (ret == HDF_SUCCESS) {
1471 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, param);
1472 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret);
1473 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN);
1474 ASSERT_TRUE(flag);
1475 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1476 EXPECT_EQ(ret, HDF_SUCCESS);
1477 }
1478 OsalMemFree(param);
1479 }
1480
1481 /**
1482 * @tc.name: SetProjectionScreenParam004
1483 * @tc.desc: wifi hal config projection screen function test
1484 * @tc.type: FUNC
1485 * @tc.require:
1486 */
1487 HWTEST_F(WifiHalTest, SetProjectionScreenParam004, TestSize.Level1)
1488 {
1489 int32_t ret;
1490 bool flag;
1491 struct IWiFiAp *apFeature = nullptr;
1492 ProjectionScreenParam *param;
1493
1494 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE);
1495 EXPECT_NE(nullptr, param);
1496 param->bufLen = 1;
1497 param->buf[0] = 0;
1498 param->cmdId = CMD_ID_MCC_STA_P2P_QUOTA_TIME;
1499
1500 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1501 if (ret == HDF_SUCCESS) {
1502 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, param);
1503 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret);
1504 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN);
1505 ASSERT_TRUE(flag);
1506 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1507 EXPECT_EQ(ret, HDF_SUCCESS);
1508 }
1509 OsalMemFree(param);
1510 }
1511
1512 /**
1513 * @tc.name: SetProjectionScreenParam005
1514 * @tc.desc: wifi hal config projection screen function test
1515 * @tc.type: FUNC
1516 * @tc.require:
1517 */
1518 HWTEST_F(WifiHalTest, SetProjectionScreenParam005, TestSize.Level1)
1519 {
1520 int32_t ret;
1521 bool flag;
1522 struct IWiFiAp *apFeature = nullptr;
1523 ProjectionScreenParam *param;
1524
1525 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE);
1526 EXPECT_NE(nullptr, param);
1527 param->bufLen = 1;
1528 param->buf[0] = 0;
1529 param->cmdId = CMD_ID_CTRL_ROAM_CHANNEL;
1530
1531 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1532 if (ret == HDF_SUCCESS) {
1533 ret = g_wifi->setProjectionScreenParam(apFeature->baseFeature.ifName, param);
1534 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret);
1535 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN);
1536 ASSERT_TRUE(flag);
1537 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1538 EXPECT_EQ(ret, HDF_SUCCESS);
1539 }
1540 OsalMemFree(param);
1541 }
1542
1543 /**
1544 * @tc.name: SetProjectionScreenParam006
1545 * @tc.desc: wifi hal config projection screen function test
1546 * @tc.type: FUNC
1547 * @tc.require:
1548 */
1549 HWTEST_F(WifiHalTest, SetProjectionScreenParam006, TestSize.Level1)
1550 {
1551 int32_t ret;
1552 bool flag;
1553 struct IWiFiSta *staFeature = nullptr;
1554 ProjectionScreenParam *param;
1555
1556 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE);
1557 EXPECT_NE(nullptr, param);
1558 param->cmdId = TEST_CMD;
1559 param->bufLen = 1;
1560 param->buf[0] = 0;
1561 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1562 if (ret == HDF_SUCCESS) {
1563 ret = g_wifi->setProjectionScreenParam(nullptr, nullptr);
1564 EXPECT_NE(ret, HDF_SUCCESS);
1565 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, nullptr);
1566 EXPECT_NE(ret, HDF_SUCCESS);
1567 ret = g_wifi->setProjectionScreenParam(nullptr, param);
1568 EXPECT_NE(ret, HDF_SUCCESS);
1569 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, param);
1570 EXPECT_NE(ret, HDF_SUCCESS);
1571
1572 param->cmdId = CMD_CLOSE_GO_CAC;
1573 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, param);
1574 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret);
1575 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
1576 ASSERT_TRUE(flag);
1577
1578 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1579 EXPECT_EQ(ret, HDF_SUCCESS);
1580 }
1581 OsalMemFree(param);
1582 }
1583
1584 /**
1585 * @tc.name: SetProjectionScreenParam007
1586 * @tc.desc: wifi hal config projection screen function test
1587 * @tc.type: FUNC
1588 * @tc.require:
1589 */
1590 HWTEST_F(WifiHalTest, SetProjectionScreenParam007, TestSize.Level1)
1591 {
1592 int32_t ret;
1593 bool flag;
1594 struct IWiFiSta *staFeature = nullptr;
1595 ProjectionScreenParam *param;
1596
1597 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE);
1598 EXPECT_NE(nullptr, param);
1599 param->bufLen = 1;
1600 param->buf[0] = 0;
1601 param->cmdId = CMD_SET_GO_CSA_CHANNEL;
1602
1603 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1604 if (ret == HDF_SUCCESS) {
1605 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, param);
1606 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret);
1607 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN);
1608 ASSERT_TRUE(flag);
1609 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1610 EXPECT_EQ(ret, HDF_SUCCESS);
1611 }
1612 OsalMemFree(param);
1613 }
1614
1615 /**
1616 * @tc.name: SetProjectionScreenParam008
1617 * @tc.desc: wifi hal config projection screen function test
1618 * @tc.type: FUNC
1619 * @tc.require:
1620 */
1621 HWTEST_F(WifiHalTest, SetProjectionScreenParam008, TestSize.Level1)
1622 {
1623 int32_t ret;
1624 bool flag;
1625 struct IWiFiSta *staFeature = nullptr;
1626 ProjectionScreenParam *param;
1627
1628 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE);
1629 EXPECT_NE(nullptr, param);
1630 param->bufLen = 1;
1631 param->buf[0] = 0;
1632 param->cmdId = CMD_SET_GO_RADAR_DETECT;
1633
1634 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1635 if (ret == HDF_SUCCESS) {
1636 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, param);
1637 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret);
1638 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN);
1639 ASSERT_TRUE(flag);
1640 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1641 EXPECT_EQ(ret, HDF_SUCCESS);
1642 }
1643 OsalMemFree(param);
1644 }
1645
1646 /**
1647 * @tc.name: SetProjectionScreenParam009
1648 * @tc.desc: wifi hal config projection screen function test
1649 * @tc.type: FUNC
1650 * @tc.require:
1651 */
1652 HWTEST_F(WifiHalTest, SetProjectionScreenParam009, TestSize.Level1)
1653 {
1654 int32_t ret;
1655 bool flag;
1656 struct IWiFiSta *staFeature = nullptr;
1657 ProjectionScreenParam *param;
1658
1659 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE);
1660 EXPECT_NE(nullptr, param);
1661 param->bufLen = 1;
1662 param->buf[0] = 0;
1663 param->cmdId = CMD_ID_MCC_STA_P2P_QUOTA_TIME;
1664
1665 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1666 if (ret == HDF_SUCCESS) {
1667 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, param);
1668 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret);
1669 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN);
1670 ASSERT_TRUE(flag);
1671 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1672 EXPECT_EQ(ret, HDF_SUCCESS);
1673 }
1674 OsalMemFree(param);
1675 }
1676
1677 /**
1678 * @tc.name: SetProjectionScreenParam010
1679 * @tc.desc: wifi hal config projection screen function test
1680 * @tc.type: FUNC
1681 * @tc.require:
1682 */
1683 HWTEST_F(WifiHalTest, SetProjectionScreenParam010, TestSize.Level1)
1684 {
1685 int32_t ret;
1686 bool flag;
1687 struct IWiFiSta *staFeature = nullptr;
1688 ProjectionScreenParam *param;
1689
1690 param = (ProjectionScreenParam *)OsalMemCalloc(sizeof(ProjectionScreenParam) + TEST_PARAM_BUF_SIZE);
1691 EXPECT_NE(nullptr, param);
1692 param->bufLen = 1;
1693 param->buf[0] = 0;
1694 param->cmdId = CMD_ID_CTRL_ROAM_CHANNEL;
1695
1696 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1697 if (ret == HDF_SUCCESS) {
1698 ret = g_wifi->setProjectionScreenParam(staFeature->baseFeature.ifName, param);
1699 printf("SetProjectionScreenParam_%d: ret = %d\n", __LINE__, ret);
1700 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN);
1701 ASSERT_TRUE(flag);
1702 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1703 EXPECT_EQ(ret, HDF_SUCCESS);
1704 }
1705 OsalMemFree(param);
1706 }
1707
1708 /**
1709 * @tc.name: SendCmdIoctl001
1710 * @tc.desc: wifi hal send ioctl command function test
1711 * @tc.type: FUNC
1712 * @tc.require: AR000HDUEE
1713 */
1714 HWTEST_F(WifiHalTest, SendCmdIoctl001, TestSize.Level1)
1715 {
1716 int32_t cmdId = 0;
1717 int32_t ret;
1718 bool flag;
1719 struct IWiFiAp *apFeature = nullptr;
1720 int8_t data[TEST_BUF_SIZE] = {0};
1721 const char *ifName = "wlan0";
1722
1723 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1724 if (ret == HDF_SUCCESS) {
1725 ret = g_wifi->sendCmdIoctl(nullptr, cmdId, nullptr, TEST_BUF_SIZE);
1726 EXPECT_NE(ret, HDF_SUCCESS);
1727 ret = g_wifi->sendCmdIoctl(ifName, cmdId, nullptr, TEST_BUF_SIZE);
1728 EXPECT_NE(ret, HDF_SUCCESS);
1729 ret = g_wifi->sendCmdIoctl(nullptr, cmdId, data, TEST_BUF_SIZE);
1730 EXPECT_NE(ret, HDF_SUCCESS);
1731 cmdId = CMD_HID2D_MODULE_INIT;
1732 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE);
1733 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret);
1734 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
1735 ASSERT_TRUE(flag);
1736
1737 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1738 EXPECT_EQ(ret, HDF_SUCCESS);
1739 }
1740 }
1741
1742 /**
1743 * @tc.name: SendCmdIoctl002
1744 * @tc.desc: wifi hal send ioctl command function test
1745 * @tc.type: FUNC
1746 * @tc.require: AR000HDUEE
1747 */
1748 HWTEST_F(WifiHalTest, SendCmdIoctl002, TestSize.Level1)
1749 {
1750 int32_t cmdId = 0;
1751 int32_t ret;
1752 bool flag;
1753 struct IWiFiAp *apFeature = nullptr;
1754 int8_t data[TEST_BUF_SIZE] = {0};
1755 const char *ifName = "wlan0";
1756
1757 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1758 if (ret == HDF_SUCCESS) {
1759 cmdId = CMD_SET_BATTERY_LEVEL;
1760 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE);
1761 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret);
1762 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
1763 ASSERT_TRUE(flag);
1764 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1765 EXPECT_EQ(ret, HDF_SUCCESS);
1766 }
1767 }
1768
1769 /**
1770 * @tc.name: SendCmdIoctl003
1771 * @tc.desc: wifi hal send ioctl command function test
1772 * @tc.type: FUNC
1773 * @tc.require:
1774 */
1775 HWTEST_F(WifiHalTest, SendCmdIoctl003, TestSize.Level1)
1776 {
1777 int32_t cmdId = 0;
1778 int32_t ret;
1779 bool flag;
1780 struct IWiFiAp *apFeature = nullptr;
1781 int8_t data[TEST_BUF_SIZE] = {0};
1782 const char *ifName = "wlan0";
1783
1784 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1785 if (ret == HDF_SUCCESS) {
1786 cmdId = CMD_SET_SUPP_COEX_CHAN_LIST;
1787 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE);
1788 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret);
1789 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN);
1790 ASSERT_TRUE(flag);
1791 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1792 EXPECT_EQ(ret, HDF_SUCCESS);
1793 }
1794 }
1795
1796 /**
1797 * @tc.name: SendCmdIoctl004
1798 * @tc.desc: wifi hal send ioctl command function test
1799 * @tc.type: FUNC
1800 * @tc.require:
1801 */
1802 HWTEST_F(WifiHalTest, SendCmdIoctl004, TestSize.Level1)
1803 {
1804 int32_t cmdId = 0;
1805 int32_t ret;
1806 bool flag;
1807 struct IWiFiAp *apFeature = nullptr;
1808 int8_t data[TEST_BUF_SIZE] = {0};
1809 const char *ifName = "wlan0";
1810
1811 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1812 if (ret == HDF_SUCCESS) {
1813 cmdId = CMD_SET_CHAN_ADJUST;
1814 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE);
1815 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret);
1816 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN);
1817 ASSERT_TRUE(flag);
1818 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1819 EXPECT_EQ(ret, HDF_SUCCESS);
1820 }
1821 }
1822
1823 /**
1824 * @tc.name: SendCmdIoctl005
1825 * @tc.desc: wifi hal send ioctl command function test
1826 * @tc.type: FUNC
1827 * @tc.require:
1828 */
1829 HWTEST_F(WifiHalTest, SendCmdIoctl005, TestSize.Level1)
1830 {
1831 int32_t cmdId = 0;
1832 int32_t ret;
1833 bool flag;
1834 struct IWiFiSta *staFeature = nullptr;
1835 int8_t data[TEST_BUF_SIZE] = {0};
1836 const char *ifName = "wlan0";
1837
1838 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1839 if (ret == HDF_SUCCESS) {
1840 ret = g_wifi->sendCmdIoctl(nullptr, cmdId, nullptr, TEST_BUF_SIZE);
1841 EXPECT_NE(ret, HDF_SUCCESS);
1842 ret = g_wifi->sendCmdIoctl(ifName, cmdId, nullptr, TEST_BUF_SIZE);
1843 EXPECT_NE(ret, HDF_SUCCESS);
1844 ret = g_wifi->sendCmdIoctl(nullptr, cmdId, data, TEST_BUF_SIZE);
1845 EXPECT_NE(ret, HDF_SUCCESS);
1846
1847 cmdId = CMD_HID2D_MODULE_INIT;
1848 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE);
1849 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret);
1850 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
1851 ASSERT_TRUE(flag);
1852
1853 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1854 EXPECT_EQ(ret, HDF_SUCCESS);
1855 }
1856 }
1857
1858 /**
1859 * @tc.name: SendCmdIoctl006
1860 * @tc.desc: wifi hal send ioctl command function test
1861 * @tc.type: FUNC
1862 * @tc.require:
1863 */
1864 HWTEST_F(WifiHalTest, SendCmdIoctl006, TestSize.Level1)
1865 {
1866 int32_t cmdId = 0;
1867 int32_t ret;
1868 bool flag;
1869 struct IWiFiSta *staFeature = nullptr;
1870 int8_t data[TEST_BUF_SIZE] = {0};
1871 const char *ifName = "wlan0";
1872
1873 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1874 if (ret == HDF_SUCCESS) {
1875 cmdId = CMD_SET_BATTERY_LEVEL;
1876 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE);
1877 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret);
1878 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
1879 ASSERT_TRUE(flag);
1880 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1881 EXPECT_EQ(ret, HDF_SUCCESS);
1882 }
1883 }
1884
1885 /**
1886 * @tc.name: SendCmdIoctl007
1887 * @tc.desc: wifi hal send ioctl command function test
1888 * @tc.type: FUNC
1889 * @tc.require:
1890 */
1891 HWTEST_F(WifiHalTest, SendCmdIoctl007, TestSize.Level1)
1892 {
1893 int32_t cmdId = 0;
1894 int32_t ret;
1895 bool flag;
1896 struct IWiFiSta *staFeature = nullptr;
1897 int8_t data[TEST_BUF_SIZE] = {0};
1898 const char *ifName = "wlan0";
1899
1900 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1901 if (ret == HDF_SUCCESS) {
1902 cmdId = CMD_SET_SUPP_COEX_CHAN_LIST;
1903 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE);
1904 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret);
1905 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN);
1906 ASSERT_TRUE(flag);
1907 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1908 EXPECT_EQ(ret, HDF_SUCCESS);
1909 }
1910 }
1911
1912 /**
1913 * @tc.name: SendCmdIoctl008
1914 * @tc.desc: wifi hal send ioctl command function test
1915 * @tc.type: FUNC
1916 * @tc.require:
1917 */
1918 HWTEST_F(WifiHalTest, SendCmdIoctl008, TestSize.Level1)
1919 {
1920 int32_t cmdId = 0;
1921 int32_t ret;
1922 bool flag;
1923 struct IWiFiSta *staFeature = nullptr;
1924 int8_t data[TEST_BUF_SIZE] = {0};
1925 const char *ifName = "wlan0";
1926
1927 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
1928 if (ret == HDF_SUCCESS) {
1929 cmdId = CMD_SET_CHAN_ADJUST;
1930 ret = g_wifi->sendCmdIoctl(ifName, cmdId, data, TEST_BUF_SIZE);
1931 printf("sendCmdIoctl_%d: ret = %d\n", __LINE__, ret);
1932 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_DEV_ERR_NETDOWN);
1933 ASSERT_TRUE(flag);
1934 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
1935 EXPECT_EQ(ret, HDF_SUCCESS);
1936 }
1937 }
1938
1939 /**
1940 * @tc.name: GetStationInfo001
1941 * @tc.desc: Wifi hdi get station information function test
1942 * @tc.type: FUNC
1943 * @tc.require:
1944 */
1945 HWTEST_F(WifiHalTest, GetStationInfo001, TestSize.Level1)
1946 {
1947 int32_t ret;
1948 StationInfo info;
1949 bool flag;
1950 uint8_t mac[ETH_ADDR_LEN] = {0};
1951 struct IWiFiAp *apFeature = nullptr;
1952 const char *ifName = "wlan0";
1953 const char *ifNameInvalid = "wlanTest";
1954
1955 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&apFeature);
1956 if (ret == HDF_SUCCESS) {
1957 ret = g_wifi->getStationInfo(nullptr, nullptr, nullptr, ETH_ADDR_LEN);
1958 EXPECT_NE(ret, HDF_SUCCESS);
1959 ret = g_wifi->getStationInfo(ifName, nullptr, nullptr, ETH_ADDR_LEN);
1960 EXPECT_NE(ret, HDF_SUCCESS);
1961 ret = g_wifi->getStationInfo(nullptr, &info, nullptr, ETH_ADDR_LEN);
1962 EXPECT_NE(ret, HDF_SUCCESS);
1963 ret = g_wifi->getStationInfo(nullptr, nullptr, mac, ETH_ADDR_LEN);
1964 EXPECT_NE(ret, HDF_SUCCESS);
1965 ret = g_wifi->getStationInfo(ifName, &info, nullptr, ETH_ADDR_LEN);
1966 EXPECT_NE(ret, HDF_SUCCESS);
1967 ret = g_wifi->getStationInfo(nullptr, &info, mac, ETH_ADDR_LEN);
1968 EXPECT_NE(ret, HDF_SUCCESS);
1969 ret = g_wifi->getStationInfo(ifName, nullptr, mac, ETH_ADDR_LEN);
1970 EXPECT_NE(ret, HDF_SUCCESS);
1971 ret = g_wifi->getStationInfo(ifNameInvalid, &info, mac, ETH_ADDR_LEN);
1972 EXPECT_NE(ret, HDF_SUCCESS);
1973 ret = g_wifi->getStationInfo(ifName, &info, mac, ETH_ADDR_LEN);
1974 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
1975 ASSERT_TRUE(flag);
1976 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)apFeature);
1977 EXPECT_EQ(ret, HDF_SUCCESS);
1978 }
1979 }
1980
1981 /**
1982 * @tc.name: GetStationInfo002
1983 * @tc.desc: Wifi hdi get station information function test
1984 * @tc.type: FUNC
1985 * @tc.require:
1986 */
1987 HWTEST_F(WifiHalTest, GetStationInfo002, TestSize.Level1)
1988 {
1989 int32_t ret;
1990 StationInfo info;
1991 bool flag;
1992 uint8_t mac[ETH_ADDR_LEN] = {0};
1993 struct IWiFiSta *staFeature = nullptr;
1994 const char *ifName = "wlan0";
1995
1996 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_AP, (struct IWiFiBaseFeature **)&staFeature);
1997 if (ret == HDF_SUCCESS) {
1998 ret = g_wifi->getStationInfo(nullptr, nullptr, nullptr, ETH_ADDR_LEN);
1999 EXPECT_NE(ret, HDF_SUCCESS);
2000 ret = g_wifi->getStationInfo(ifName, nullptr, nullptr, ETH_ADDR_LEN);
2001 EXPECT_NE(ret, HDF_SUCCESS);
2002 ret = g_wifi->getStationInfo(nullptr, &info, nullptr, ETH_ADDR_LEN);
2003 EXPECT_NE(ret, HDF_SUCCESS);
2004 ret = g_wifi->getStationInfo(nullptr, nullptr, mac, ETH_ADDR_LEN);
2005 EXPECT_NE(ret, HDF_SUCCESS);
2006 ret = g_wifi->getStationInfo(ifName, &info, nullptr, ETH_ADDR_LEN);
2007 EXPECT_NE(ret, HDF_SUCCESS);
2008 ret = g_wifi->getStationInfo(nullptr, &info, mac, ETH_ADDR_LEN);
2009 EXPECT_NE(ret, HDF_SUCCESS);
2010 ret = g_wifi->getStationInfo(ifName, nullptr, mac, ETH_ADDR_LEN);
2011 EXPECT_NE(ret, HDF_SUCCESS);
2012 ret = g_wifi->getStationInfo(ifName, &info, mac, ETH_ADDR_LEN);
2013 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
2014 ASSERT_TRUE(flag);
2015 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
2016 EXPECT_EQ(ret, HDF_SUCCESS);
2017 }
2018 }
2019
2020 /**
2021 * @tc.name: GetSignalPollInfo001
2022 * @tc.desc: wifi hal get signal information function test
2023 * @tc.type: FUNC
2024 * @tc.require:
2025 */
2026 HWTEST_F(WifiHalTest, GetSignalPollInfo001, TestSize.Level1)
2027 {
2028 int32_t ret;
2029 struct IWiFiSta *staFeature = nullptr;
2030 const char *interfaceName = "wlan0";
2031 struct SignalResult signalResult;
2032 (void)memset_s(&signalResult, sizeof(signalResult), 0, sizeof(signalResult));
2033
2034 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
2035 if (ret == HDF_SUCCESS) {
2036 EXPECT_NE(nullptr, staFeature);
2037 ret = staFeature->getSignalPollInfo(interfaceName, &signalResult);
2038 printf("getSignalPollInfo ret = %d.\n", ret);
2039 bool flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
2040 ASSERT_TRUE(flag);
2041 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
2042 EXPECT_EQ(HDF_SUCCESS, ret);
2043 }
2044 }
2045
2046 /**
2047 * @tc.name: WifiStartChannelMeas001
2048 * @tc.desc: Wifi start channel meas and get meas result test
2049 * @tc.type: FUNC
2050 * @tc.require:
2051 */
2052 HWTEST_F(WifiHalTest, StartChannelMeasTest001, TestSize.Level1)
2053 {
2054 int32_t ret;
2055 const char *ifName = "wlan0";
2056 struct MeasParam measChannelParam;
2057 struct MeasResult measChannelResult = {0};
2058 measChannelParam.channelId = 1;
2059 measChannelParam.measTime = 15;
2060
2061 ret = g_wifi->startChannelMeas(nullptr, &measChannelParam);
2062 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
2063 ret = g_wifi->startChannelMeas(ifName, nullptr);
2064 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
2065 ret = g_wifi->startChannelMeas(ifName, &measChannelParam);
2066 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2067
2068 ret = g_wifi->getChannelMeasResult(nullptr, &measChannelResult);
2069 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
2070 ret = g_wifi->getChannelMeasResult(ifName, nullptr);
2071 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
2072 ret = g_wifi->getChannelMeasResult(ifName, &measChannelResult);
2073 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2074 }
2075
2076 /**
2077 * @tc.name: HalRegisterHid2dCallback001
2078 * @tc.desc: Hal register hid2d callback test
2079 * @tc.type: FUNC
2080 * @tc.require:
2081 */
2082 HWTEST_F(WifiHalTest, HalRegisterHid2dCallback001, TestSize.Level1)
2083 {
2084 int32_t ret;
2085 const char *ifName = "wlan0";
2086
2087 ret = g_wifi->registerHid2dCallback(nullptr, ifName);
2088 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
2089 ret = g_wifi->registerHid2dCallback(Hid2dFunCb, nullptr);
2090 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
2091 ret = g_wifi->registerHid2dCallback(Hid2dFunCb, ifName);
2092 EXPECT_EQ(HDF_SUCCESS, ret);
2093 }
2094
2095 /**
2096 * @tc.name: HalUnregisterHid2dCallback001
2097 * @tc.desc: Hal unregister hid2d callback test
2098 * @tc.type: FUNC
2099 * @tc.require:
2100 */
2101 HWTEST_F(WifiHalTest, HalUnregisterHid2dCallback001, TestSize.Level1)
2102 {
2103 int32_t ret;
2104 const char *ifName = "wlan0";
2105
2106 ret = g_wifi->unregisterHid2dCallback(nullptr, ifName);
2107 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
2108 ret = g_wifi->unregisterHid2dCallback(Hid2dFunCb, nullptr);
2109 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
2110 ret = g_wifi->unregisterHid2dCallback(Hid2dFunCb, ifName);
2111 EXPECT_EQ(HDF_SUCCESS, ret);
2112 }
2113
2114 /**
2115 * @tc.name: WifiHalStartPnoScan001
2116 * @tc.desc: Wifi hal Start Scan function test
2117 * @tc.type: FUNC
2118 * @tc.require:
2119 */
2120 HWTEST_F(WifiHalTest, WifiHalStartPnoScan001, TestSize.Level1)
2121 {
2122 int32_t ret;
2123 struct IWiFiSta *staFeature = nullptr;
2124 const char *ifName = "wlan0";
2125 WifiPnoSettings pnoSettings;
2126 (void)memset_s(&pnoSettings, sizeof(pnoSettings), 0, sizeof(pnoSettings));
2127
2128 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
2129 if (ret == HDF_SUCCESS) {
2130 EXPECT_NE(staFeature, nullptr);
2131 ret = staFeature->startPnoScan(nullptr, &pnoSettings);
2132 EXPECT_NE(HDF_SUCCESS, ret);
2133 ret = staFeature->startPnoScan(ifName, nullptr);
2134 EXPECT_NE(HDF_SUCCESS, ret);
2135 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
2136 EXPECT_EQ(HDF_SUCCESS, ret);
2137 }
2138 }
2139 /**
2140 * @tc.name: WifiHalStartPnoScan002
2141 * @tc.desc: Wifi hal Start Scan function test
2142 * @tc.type: FUNC
2143 * @tc.require:
2144 */
2145 HWTEST_F(WifiHalTest, WifiHalStartPnoScan002, TestSize.Level1)
2146 {
2147 int32_t ret;
2148 bool flag;
2149 struct IWiFiSta *staFeature = nullptr;
2150 const char *ifName = "wlan0";
2151 string ssid1 = "xa-hw";
2152 string ssid2 = "xa-hw-03";
2153 WifiPnoSettings pnoSettings;
2154 (void)memset_s(&pnoSettings, sizeof(pnoSettings), 0, sizeof(pnoSettings));
2155 pnoSettings.min2gRssi = -120;
2156 pnoSettings.min5gRssi = -130;
2157 pnoSettings.scanIntervalMs = 60000;
2158 pnoSettings.scanIterations = 3;
2159
2160 pnoSettings.pnoNetworksLen = 2;
2161 pnoSettings.pnoNetworks = (WifiPnoNetwork *)OsalMemCalloc(sizeof(WifiPnoNetwork) * 2);
2162 pnoSettings.pnoNetworks[0].isHidden = 1;
2163 memcpy_s(pnoSettings.pnoNetworks[0].ssid.ssid, MAX_SSID_LEN, ssid1.c_str(), ssid1.length());
2164 pnoSettings.pnoNetworks[0].ssid.ssidLen = ssid1.length();
2165 pnoSettings.pnoNetworks[1].isHidden = 0;
2166 memcpy_s(pnoSettings.pnoNetworks[1].ssid.ssid, MAX_SSID_LEN, ssid2.c_str(), ssid2.length());
2167 pnoSettings.pnoNetworks[1].ssid.ssidLen = ssid2.length();
2168
2169 ret = g_wifi->registerEventCallback(HalCallbackEvent, ifName);
2170 EXPECT_EQ(HDF_SUCCESS, ret);
2171 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
2172 if (ret == HDF_SUCCESS) {
2173 EXPECT_NE(staFeature, nullptr);
2174 ret = staFeature->startPnoScan(ifName, &pnoSettings);
2175 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
2176 printf("ret = %d.\n", ret);
2177 ASSERT_TRUE(flag);
2178 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
2179 EXPECT_EQ(HDF_SUCCESS, ret);
2180 }
2181 ret = g_wifi->unregisterEventCallback(HalCallbackEvent, ifName);
2182 EXPECT_EQ(HDF_SUCCESS, ret);
2183 OsalMemFree(pnoSettings.pnoNetworks);
2184 }
2185
2186 /**
2187 * @tc.name: WifiHalStopPnoScan001
2188 * @tc.desc: Wifi hal stop pno scan
2189 * @tc.type: FUNC
2190 * @tc.require:
2191 */
2192 HWTEST_F(WifiHalTest, WifiHalStopPnoScan001, TestSize.Level1)
2193 {
2194 int32_t ret;
2195 bool flag;
2196 struct IWiFiSta *staFeature = nullptr;
2197 const char *ifName = "wlan0";
2198
2199 ret = g_wifi->createFeature(PROTOCOL_80211_IFTYPE_STATION, (struct IWiFiBaseFeature **)&staFeature);
2200 if (ret == HDF_SUCCESS) {
2201 EXPECT_NE(nullptr, staFeature);
2202 ret = staFeature->stopPnoScan(nullptr);
2203 EXPECT_NE(HDF_SUCCESS, ret);
2204 ret = staFeature->stopPnoScan(ifName);
2205 flag = (ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
2206 ASSERT_TRUE(flag);
2207 ret = g_wifi->destroyFeature((struct IWiFiBaseFeature *)staFeature);
2208 EXPECT_EQ(HDF_SUCCESS, ret);
2209 }
2210 }
2211 }; // namespace HalTest
2212