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 #include <gtest/gtest.h>
16 #include <servmgr_hdi.h>
17 #include <osal_mem.h>
18 #include "v1_3/iwlan_interface.h"
19 #include "wlan_callback_impl.h"
20 #include "securec.h"
21 #include "wlan_hdi_types.h"
22 
23 #define HDF_LOG_TAG service_manager_test
24 using namespace testing::ext;
25 
26 namespace HdiTest {
27 const int32_t WLAN_FREQ_MAX_NUM = 35;
28 const int32_t WLAN_TX_POWER = 160;
29 const int32_t DEFAULT_COMBO_SIZE = 6;
30 const int32_t WLAN_MAX_NUM_STA_WITH_AP = 4;
31 const uint32_t RESET_TIME = 3;
32 const uint32_t MEAS_CHANNEL_TIME = 1;
33 const uint32_t SCAN_TIME = 3;
34 const char *WLAN_SERVICE_NAME = "wlan_interface_service";
35 
36 class HdfWifiServiceCTest : public testing::Test {
37 public:
38     static void SetUpTestCase();
39     static void TearDownTestCase();
40     void SetUp();
41     void TearDown();
42 };
43 
44 static struct IWlanInterface *g_wlanObj = nullptr;
45 struct IWlanCallback *g_wlanCallbackObj = nullptr;
SetUpTestCase()46 void HdfWifiServiceCTest::SetUpTestCase()
47 {
48     g_wlanObj = IWlanInterfaceGetInstance(WLAN_SERVICE_NAME, false);
49     g_wlanCallbackObj = WlanCallbackServiceGet();
50     ASSERT_TRUE(g_wlanObj != nullptr);
51     ASSERT_TRUE(g_wlanCallbackObj != nullptr);
52 }
53 
TearDownTestCase()54 void HdfWifiServiceCTest::TearDownTestCase()
55 {
56     IWlanInterfaceReleaseInstance(WLAN_SERVICE_NAME, g_wlanObj, false);
57     WlanCallbackServiceRelease(g_wlanCallbackObj);
58 }
59 
SetUp()60 void HdfWifiServiceCTest::SetUp()
61 {
62     int32_t rc = g_wlanObj->Start(g_wlanObj);
63     ASSERT_EQ(rc, HDF_SUCCESS);
64 }
65 
TearDown()66 void HdfWifiServiceCTest::TearDown()
67 {
68     int32_t rc = g_wlanObj->Stop(g_wlanObj);
69     ASSERT_EQ(rc, HDF_SUCCESS);
70 }
71 
72 /**
73  * @tc.name: GetSupportFeatureComboTest_001
74  * @tc.desc: Wifi hdi get support feature and combo function test
75  * @tc.type: FUNC
76  * @tc.require: AR000FRMJB
77  */
78 HWTEST_F(HdfWifiServiceCTest, GetSupportFeatureComboTest_001, TestSize.Level1)
79 {
80     uint8_t supType[PROTOCOL_80211_IFTYPE_NUM + 1] = {0};
81     uint32_t supTypeLen = PROTOCOL_80211_IFTYPE_NUM + 1;
82     uint64_t combo[DEFAULT_COMBO_SIZE] = {0};
83     uint32_t supTypeLenInvalid = 6;
84 
85     int32_t rc = g_wlanObj->GetSupportFeature(g_wlanObj, supType, &supTypeLenInvalid);
86     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
87     rc = g_wlanObj->GetSupportFeature(g_wlanObj, supType, &supTypeLen);
88     ASSERT_EQ(rc, HDF_SUCCESS);
89     rc = g_wlanObj->GetSupportCombo(g_wlanObj, combo);
90     ASSERT_NE(rc, HDF_FAILURE);
91 }
92 
93 /**
94  * @tc.name: CreateFeatureTest_002
95  * @tc.desc: Wifi hdi create feature function test
96  * @tc.type: FUNC
97  * @tc.require: AR000FRMJB
98  */
99 HWTEST_F(HdfWifiServiceCTest, CreateFeatureTest_002, TestSize.Level1)
100 {
101     struct HdfFeatureInfo ifeature;
102     const int32_t wlanType = PROTOCOL_80211_IFTYPE_AP;
103 
104     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
105     if (rc == HDF_SUCCESS) {
106         printf("ifname = %s\n", ifeature.ifName);
107         printf("type = %d\n", ifeature.type);
108         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
109         ASSERT_EQ(rc, HDF_SUCCESS);
110     }
111 }
112 
113 /**
114  * @tc.name: GetFeatureByIfNameTest_003
115  * @tc.desc: Wifi hdi get feature by ifname function test
116  * @tc.type: FUNC
117  * @tc.require: AR000FRMJB
118  */
119 HWTEST_F(HdfWifiServiceCTest, GetFeatureByIfNameTest_003, TestSize.Level1)
120 {
121     const int32_t wlanType = PROTOCOL_80211_IFTYPE_AP;
122     struct HdfFeatureInfo ifeature;
123     const char *ifNameInvalid = "wlanTest";
124 
125     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
126     if (rc == HDF_SUCCESS) {
127         rc = g_wlanObj->GetFeatureByIfName(g_wlanObj, ifNameInvalid, &ifeature);
128         ASSERT_NE(rc, HDF_SUCCESS);
129         rc = g_wlanObj->GetFeatureByIfName(g_wlanObj, ifeature.ifName, &ifeature);
130         ASSERT_EQ(rc, HDF_SUCCESS);
131         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
132         ASSERT_EQ(rc, HDF_SUCCESS);
133     }
134 }
135 
136 /**
137  * @tc.name: GetNetworkIfaceNameTest_004
138  * @tc.desc: Wifi hdi get network interface name function test on AP feature
139  * @tc.type: FUNC
140  * @tc.require: AR000FRMJB
141  */
142 HWTEST_F(HdfWifiServiceCTest, GetNetworkIfaceNameTest_004, TestSize.Level1)
143 {
144     const int32_t wlanType = PROTOCOL_80211_IFTYPE_AP;
145     struct HdfFeatureInfo ifeature;
146     char ifNames[IFNAMSIZ] = {0};
147 
148     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
149     if (rc == HDF_SUCCESS) {
150         rc = g_wlanObj->GetNetworkIfaceName(g_wlanObj, &ifeature, ifNames, IFNAMSIZ);
151         ASSERT_EQ(rc, HDF_SUCCESS);
152         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
153         ASSERT_EQ(rc, HDF_SUCCESS);
154     }
155 }
156 
157 /**
158  * @tc.name: GetFeatureTypeTest_005
159  * @tc.desc: Wifi hdi get feature type function test on AP feature
160  * @tc.type: FUNC
161  * @tc.require: AR000FRMJB
162  */
163 HWTEST_F(HdfWifiServiceCTest, GetFeatureTypeTest_005, TestSize.Level1)
164 {
165     const int32_t wlanType = PROTOCOL_80211_IFTYPE_AP;
166     struct HdfFeatureInfo ifeature;
167     int32_t featureType;
168 
169     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
170     if (rc == HDF_SUCCESS) {
171         rc = g_wlanObj->GetFeatureType(g_wlanObj, &ifeature, &featureType);
172         ASSERT_EQ(rc, HDF_SUCCESS);
173         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
174         ASSERT_EQ(rc, HDF_SUCCESS);
175     }
176 }
177 
178 /**
179  * @tc.name: SetMacAddressTest_006
180  * @tc.desc: Wifi hdi set mac addr function test on AP feature
181  * @tc.type: FUNC
182  * @tc.require: AR000FRMJB
183  */
184 HWTEST_F(HdfWifiServiceCTest, SetMacAddressTest_006, TestSize.Level1)
185 {
186     uint8_t mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
187     const int32_t wlanType = PROTOCOL_80211_IFTYPE_AP;
188     struct HdfFeatureInfo ifeature;
189     uint32_t macLen = ETH_ADDR_LEN;
190     uint8_t errorMac[ETH_ADDR_LEN] = {0x11, 0x34, 0x56, 0x78, 0xab, 0xcd};
191 
192     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
193     if (rc == HDF_SUCCESS) {
194         rc = g_wlanObj->SetMacAddress(g_wlanObj, &ifeature, errorMac, macLen);
195         ASSERT_NE(rc, HDF_SUCCESS);
196         rc = g_wlanObj->SetMacAddress(g_wlanObj, &ifeature, mac, macLen);
197         bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT || rc == HDF_ERR_DEVICE_BUSY);
198         ASSERT_TRUE(flag);
199         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
200         ASSERT_EQ(rc, HDF_SUCCESS);
201     }
202 }
203 
204 /**
205  * @tc.name: GetDeviceMacAddressTest_007
206  * @tc.desc: Wifi hdi get device mac addr function test on AP feature
207  * @tc.type: FUNC
208  * @tc.require: AR000FRMJB
209  */
210 HWTEST_F(HdfWifiServiceCTest, GetDeviceMacAddressTest_007, TestSize.Level1)
211 {
212     const int32_t wlanType = PROTOCOL_80211_IFTYPE_AP;
213     struct HdfFeatureInfo ifeature;
214     uint8_t mac[ETH_ADDR_LEN] = {0};
215     uint32_t macLen = ETH_ADDR_LEN;
216 
217     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
218     if (rc == HDF_SUCCESS) {
219         rc = g_wlanObj->GetDeviceMacAddress(g_wlanObj, &ifeature, mac, &macLen, ETH_ADDR_LEN);
220         ASSERT_EQ(rc, HDF_SUCCESS);
221         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
222         ASSERT_EQ(rc, HDF_SUCCESS);
223     }
224 }
225 
226 /**
227  * @tc.name: GetFreqsWithBandTest_008
228  * @tc.desc: Wifi hdi get freqs function test on AP feature
229  * @tc.type: FUNC
230  * @tc.require: AR000FRMJB
231  */
232 HWTEST_F(HdfWifiServiceCTest, GetFreqsWithBandTest_008, TestSize.Level1)
233 {
234     const int32_t wlanType = PROTOCOL_80211_IFTYPE_AP;
235     struct HdfFeatureInfo ifeature;
236     struct HdfWifiInfo wifiInfo;
237     int32_t freq[WLAN_FREQ_MAX_NUM] = {0};
238     uint32_t freqLen = WLAN_FREQ_MAX_NUM ;
239     wifiInfo.band = IEEE80211_BAND_2GHZ;
240     wifiInfo.size = WLAN_FREQ_MAX_NUM;
241     struct HdfWifiInfo wifiInfoInvalid;
242     wifiInfoInvalid.band = IEEE80211_NUM_BANDS;
243     wifiInfoInvalid.size = WLAN_FREQ_MAX_NUM;
244     uint32_t i;
245 
246     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
247     if (rc == HDF_SUCCESS) {
248         rc = g_wlanObj->GetFreqsWithBand(g_wlanObj, &ifeature, &wifiInfoInvalid, freq, &freqLen);
249         ASSERT_NE(rc, HDF_SUCCESS);
250         rc = g_wlanObj->GetFreqsWithBand(g_wlanObj, &ifeature, &wifiInfo, freq, &freqLen);
251         ASSERT_EQ(rc, HDF_SUCCESS);
252         if (rc == HDF_SUCCESS) {
253             for (i = 0; i < freqLen; i++) {
254                 printf("%s: freq[%d] = %d\n", __func__, i, freq[i]);
255             }
256         }
257 
258         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
259         ASSERT_EQ(rc, HDF_SUCCESS);
260     }
261 }
262 
263 /**
264  * @tc.name: SetTxPowerTest_009
265  * @tc.desc: Wifi hdi set tx power function test on AP feature
266  * @tc.type: FUNC
267  * @tc.require: AR000FRMJB
268  */
269 HWTEST_F(HdfWifiServiceCTest, SetTxPowerTest_009, TestSize.Level1)
270 {
271     const int32_t wlanType = PROTOCOL_80211_IFTYPE_AP;
272     struct HdfFeatureInfo ifeature;
273     int32_t power = WLAN_TX_POWER;
274 
275     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
276     if (rc == HDF_SUCCESS) {
277         rc = g_wlanObj->SetTxPower(g_wlanObj, &ifeature, power);
278         ASSERT_EQ(rc, HDF_SUCCESS);
279         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
280         ASSERT_EQ(rc, HDF_SUCCESS);
281     }
282 }
283 
284 /**
285  * @tc.name: GetChipIdTest_010
286  * @tc.desc: Wifi hdi get chip id function test on STA feature
287  * @tc.type: FUNC
288  * @tc.require: AR000FRMJB
289  */
290 HWTEST_F(HdfWifiServiceCTest, GetChipIdTest_010, TestSize.Level1)
291 {
292     const int32_t wlanType = PROTOCOL_80211_IFTYPE_STATION;
293     struct HdfFeatureInfo ifeature;
294     uint8_t chipId = 0;
295     uint8_t chipIdInvalid = 100;
296     unsigned int num = 0;
297     char ifNames[IFNAMSIZ] = {0};
298 
299     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
300     if (rc == HDF_SUCCESS) {
301         rc = g_wlanObj->GetChipId(g_wlanObj, &ifeature, &chipId);
302         ASSERT_EQ(rc, HDF_SUCCESS);
303         rc = g_wlanObj->GetIfNamesByChipId(g_wlanObj, chipIdInvalid, ifNames, IFNAMSIZ, &num);
304         ASSERT_NE(rc, HDF_SUCCESS);
305         rc = g_wlanObj->GetIfNamesByChipId(g_wlanObj, chipId, ifNames, IFNAMSIZ, &num);
306         printf("ifnames = %s\n", ifNames);
307         ASSERT_EQ(rc, HDF_SUCCESS);
308         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
309         ASSERT_EQ(rc, HDF_SUCCESS);
310     }
311 }
312 
313 /**
314  * @tc.name: SetScanningMacAddressTest_011
315  * @tc.desc: Wifi hdi set scanning mac addr function test
316  * @tc.type: FUNC
317  * @tc.require: AR000FRMJB
318  */
319 HWTEST_F(HdfWifiServiceCTest, SetScanningMacAddressTest_011, TestSize.Level1)
320 {
321     const int32_t wlanType = PROTOCOL_80211_IFTYPE_STATION;
322     struct HdfFeatureInfo ifeature;
323     uint8_t scanMac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
324     uint32_t macLen = ETH_ADDR_LEN;
325 
326     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
327     if (rc == HDF_SUCCESS) {
328         rc = g_wlanObj->SetScanningMacAddress(g_wlanObj, &ifeature, scanMac, macLen);
329         ASSERT_NE(rc, HDF_FAILURE);
330         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
331         ASSERT_EQ(rc, HDF_SUCCESS);
332     }
333 }
334 
335 /**
336  * @tc.name: GetNetdevInfoTest_012
337  * @tc.desc: Wifi hdi get netdev info function test
338  * @tc.type: FUNC
339  * @tc.require: AR000FRMJB
340  */
341 HWTEST_F(HdfWifiServiceCTest, GetNetdevInfoTest_012, TestSize.Level1)
342 {
343     int32_t rc;
344     struct HdfNetDeviceInfoResult netDeviceInfoResult;
345 
346     (void)memset_s(
347         &netDeviceInfoResult, sizeof(struct HdfNetDeviceInfoResult), 0, sizeof(struct HdfNetDeviceInfoResult));
348     rc = g_wlanObj->GetNetDevInfo(g_wlanObj, (struct HdfNetDeviceInfoResult *)&netDeviceInfoResult);
349     ASSERT_EQ(rc, HDF_SUCCESS);
350 }
351 
352 /**
353  * @tc.name: GetPowerModeTest_013
354  * @tc.desc: Wifi hdi get power mode function test
355  * @tc.type: FUNC
356  * @tc.require: AR000H60O7
357  */
358 HWTEST_F(HdfWifiServiceCTest, GetPowerModeTest_013, TestSize.Level1)
359 {
360     struct HdfFeatureInfo ifeature;
361     uint8_t mode = 0;
362 
363     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, PROTOCOL_80211_IFTYPE_AP, &ifeature);
364     if (rc == HDF_SUCCESS) {
365         rc = g_wlanObj->GetPowerMode(g_wlanObj, &ifeature, &mode);
366         bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT);
367         ASSERT_TRUE(flag);
368         printf("mode = 0x%02x\n", mode);
369         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
370         ASSERT_EQ(rc, HDF_SUCCESS);
371     }
372 }
373 
374 /**
375  * @tc.name: SetPowerModeTest_014
376  * @tc.desc: Wifi hdi set power mode function test
377  * @tc.type: FUNC
378  * @tc.require: AR000H60O7
379  */
380 HWTEST_F(HdfWifiServiceCTest, SetPowerModeTest_014, TestSize.Level1)
381 {
382     struct HdfFeatureInfo ifeature;
383     uint8_t mode = WIFI_POWER_MODE_SLEEPING;
384 
385     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, PROTOCOL_80211_IFTYPE_AP, &ifeature);
386     if (rc == HDF_SUCCESS) {
387         rc = g_wlanObj->SetPowerMode(g_wlanObj, &ifeature, mode);
388         bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT);
389         ASSERT_TRUE(flag);
390         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
391         ASSERT_EQ(rc, HDF_SUCCESS);
392     }
393 }
394 
395 /**
396  * @tc.name: RegisterEventCallbackTest_015
397  * @tc.desc: Wifi hdi register event call back function test
398  * @tc.type: FUNC
399  * @tc.require: AR000FRMJB
400  */
401 HWTEST_F(HdfWifiServiceCTest, RegisterEventCallbackTest_015, TestSize.Level1)
402 {
403     const char *ifName = "wlan0";
404     int32_t rc = g_wlanObj->RegisterEventCallback(g_wlanObj, g_wlanCallbackObj, ifName);
405     ASSERT_EQ(rc, HDF_SUCCESS);
406 }
407 
408 /**
409  * @tc.name: ResetDriverTest_016
410  * @tc.desc: Wifi hdi reset driver function test
411  * @tc.type: FUNC
412  * @tc.require: AR000FRMJB
413  */
414 HWTEST_F(HdfWifiServiceCTest, ResetDriverTest_016, TestSize.Level1)
415 {
416     int32_t wlanType = PROTOCOL_80211_IFTYPE_STATION;
417     struct HdfFeatureInfo ifeature;
418     const char *ifName = "wlan0";
419     uint8_t chipId = 0;
420     int32_t rc;
421 
422     rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
423     if (rc == HDF_SUCCESS) {
424         rc = g_wlanObj->GetChipId(g_wlanObj, &ifeature, &chipId);
425         ASSERT_EQ(rc, HDF_SUCCESS);
426         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
427         ASSERT_EQ(rc, HDF_SUCCESS);
428         rc = g_wlanObj->ResetDriver(g_wlanObj, chipId, ifName);
429         ASSERT_EQ(rc, HDF_SUCCESS);
430         sleep(RESET_TIME);
431     }
432 }
433 
434 /**
435  * @tc.name: StartScanTest_017
436  * @tc.desc: Wifi hdi start scan function test
437  * @tc.type: FUNC
438  * @tc.require: AR000FRMJB
439  */
440 HWTEST_F(HdfWifiServiceCTest, StartScanTest_017, TestSize.Level1)
441 {
442     int32_t rc;
443     const int32_t wlanType = PROTOCOL_80211_IFTYPE_STATION;
444     struct HdfFeatureInfo ifeature;
445     struct HdfWifiScan scan = {0};
446 
447     rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
448     if (rc == HDF_SUCCESS) {
449         rc = g_wlanObj->StartScan(g_wlanObj, nullptr, &scan);
450         ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
451         rc = g_wlanObj->StartScan(g_wlanObj, &ifeature, nullptr);
452         ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
453         rc = g_wlanObj->StartScan(g_wlanObj, &ifeature, &scan);
454         ASSERT_EQ(rc, HDF_SUCCESS);
455         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
456         ASSERT_EQ(rc, HDF_SUCCESS);
457         sleep(SCAN_TIME);
458     }
459 }
460 
461 /**
462  * @tc.name: UnregisterEventCallbackTest_018
463  * @tc.desc: Wifi hdi unreister event call back function test
464  * @tc.type: FUNC
465  * @tc.require: AR000FRMJB
466  */
467 HWTEST_F(HdfWifiServiceCTest, UnregisterEventCallbackTest_018, TestSize.Level1)
468 {
469     const char *ifName = "wlan0";
470     int32_t rc = g_wlanObj->UnregisterEventCallback(g_wlanObj, g_wlanCallbackObj, ifName);
471     ASSERT_EQ(rc, HDF_SUCCESS);
472 }
473 
474 /**
475  * @tc.name: GetAssociatedStasTest_019
476  * @tc.desc: Wifi hdi get assoc stas function test
477  * @tc.type: FUNC
478  * @tc.require:
479  */
480 HWTEST_F(HdfWifiServiceCTest, GetAssociatedStasTest_019, TestSize.Level1)
481 {
482     const int32_t wlanType = PROTOCOL_80211_IFTYPE_AP;
483     struct HdfFeatureInfo ifeature;
484     struct HdfStaInfo staInfo[WLAN_MAX_NUM_STA_WITH_AP] = {{0}};
485     uint32_t staInfoLen = WLAN_MAX_NUM_STA_WITH_AP;
486     uint32_t num = 0;
487 
488     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
489     if (rc == HDF_SUCCESS) {
490         rc = g_wlanObj->GetAssociatedStas(g_wlanObj, &ifeature, staInfo, &staInfoLen, &num);
491         ASSERT_EQ(rc, HDF_SUCCESS);
492         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
493         ASSERT_EQ(rc, HDF_SUCCESS);
494     }
495 }
496 
497 /**
498  * @tc.name: SetCountryCodeTest_020
499  * @tc.desc: Wifi hdi set country code function test
500  * @tc.type: FUNC
501  * @tc.require:
502  */
503 HWTEST_F(HdfWifiServiceCTest, SetCountryCodeTest_020, TestSize.Level1)
504 {
505     const char *code = "CN";
506     const int32_t wlanType = PROTOCOL_80211_IFTYPE_AP;
507     struct HdfFeatureInfo ifeature;
508     const char *codeDigital = "99";
509     uint32_t size = 2;
510 
511     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
512     if (rc == HDF_SUCCESS) {
513         rc = g_wlanObj->SetCountryCode(g_wlanObj, &ifeature, codeDigital, size);
514         bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_TIMEOUT || rc == HDF_FAILURE);
515         ASSERT_TRUE(flag);
516         rc = g_wlanObj->SetCountryCode(g_wlanObj, &ifeature, code, size);
517         ASSERT_EQ(rc, HDF_ERR_TIMEOUT);
518         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
519         ASSERT_EQ(rc, HDF_SUCCESS);
520     }
521 }
522 
523 /**
524  * @tc.name: CreateFeatureTest_021
525  * @tc.desc: Wifi hdi create feature function test
526  * @tc.type: FUNC
527  * @tc.require: AR000H603L
528  */
529 HWTEST_F(HdfWifiServiceCTest, CreateFeatureTest_021, TestSize.Level1)
530 {
531     struct HdfFeatureInfo ifeature;
532     const int32_t wlanType = PROTOCOL_80211_IFTYPE_STATION;
533     int32_t wlanTypeInvalid = PROTOCOL_80211_IFTYPE_NUM;
534 
535     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanTypeInvalid, &ifeature);
536     ASSERT_EQ(rc, HDF_FAILURE);
537     rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
538     if (rc == HDF_SUCCESS) {
539         printf("ifname = %s\n", ifeature.ifName);
540         printf("type = %d\n", ifeature.type);
541         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
542         ASSERT_EQ(rc, HDF_SUCCESS);
543     }
544 }
545 
546 /**
547  * @tc.name: GetChipIdTest_022
548  * @tc.desc: Wifi hdi get chip id function test
549  * @tc.type: FUNC
550  * @tc.require: AR000H603L
551  */
552 HWTEST_F(HdfWifiServiceCTest, GetChipIdTest_022, TestSize.Level1)
553 {
554     const int32_t wlanType = PROTOCOL_80211_IFTYPE_AP;
555     struct HdfFeatureInfo ifeature;
556     uint8_t chipId = 0;
557 
558     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
559     if (rc == HDF_SUCCESS) {
560         rc = g_wlanObj->GetChipId(g_wlanObj, &ifeature, &chipId);
561         ASSERT_EQ(rc, HDF_SUCCESS);
562         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
563         ASSERT_EQ(rc, HDF_SUCCESS);
564     }
565 }
566 
567 /**
568  * @tc.name: GetDeviceMacAddressTest_023
569  * @tc.desc: Wifi hdi get device mac addr function test on STA feature
570  * @tc.type: FUNC
571  * @tc.require: AR000H603L
572  */
573 HWTEST_F(HdfWifiServiceCTest, GetDeviceMacAddressTest_023, TestSize.Level1)
574 {
575     const int32_t wlanType = PROTOCOL_80211_IFTYPE_STATION;
576     struct HdfFeatureInfo ifeature;
577     uint8_t mac[ETH_ADDR_LEN] = {0};
578     uint32_t macLen = ETH_ADDR_LEN;
579 
580     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
581     if (rc == HDF_SUCCESS) {
582         rc = g_wlanObj->GetDeviceMacAddress(g_wlanObj, &ifeature, mac, &macLen, ETH_ADDR_LEN);
583         ASSERT_EQ(rc, HDF_SUCCESS);
584         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
585         ASSERT_EQ(rc, HDF_SUCCESS);
586     }
587 }
588 
589 /**
590  * @tc.name: GetFeatureByIfNameTest_024
591  * @tc.desc: Wifi hdi get feature by ifname function test
592  * @tc.type: FUNC
593  * @tc.require: AR000H603L
594  */
595 HWTEST_F(HdfWifiServiceCTest, GetFeatureByIfNameTest_024, TestSize.Level1)
596 {
597     const int32_t wlanType = PROTOCOL_80211_IFTYPE_STATION;
598     struct HdfFeatureInfo ifeature;
599     const char *ifNameInvalid = "wlanTest";
600 
601     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
602     if (rc == HDF_SUCCESS) {
603         rc = g_wlanObj->GetFeatureByIfName(g_wlanObj, ifNameInvalid, &ifeature);
604         ASSERT_NE(rc, HDF_SUCCESS);
605         rc = g_wlanObj->GetFeatureByIfName(g_wlanObj, ifeature.ifName, &ifeature);
606         ASSERT_EQ(rc, HDF_SUCCESS);
607         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
608         ASSERT_EQ(rc, HDF_SUCCESS);
609     }
610 }
611 
612 /**
613  * @tc.name: SetMacAddressTest_025
614  * @tc.desc: Wifi hdi set mac addr function test on STA feature
615  * @tc.type: FUNC
616  * @tc.require: AR000H603L
617  */
618 HWTEST_F(HdfWifiServiceCTest, SetMacAddressTest_025, TestSize.Level1)
619 {
620     uint8_t mac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
621     const int32_t wlanType = PROTOCOL_80211_IFTYPE_STATION;
622     struct HdfFeatureInfo ifeature;
623     uint32_t macLen = ETH_ADDR_LEN;
624     uint8_t errorMac[ETH_ADDR_LEN] = {0x11, 0x34, 0x56, 0x78, 0xab, 0xcd};
625 
626     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
627     if (rc == HDF_SUCCESS) {
628         rc = g_wlanObj->SetMacAddress(g_wlanObj, &ifeature, errorMac, macLen);
629         ASSERT_NE(rc, HDF_SUCCESS);
630         rc = g_wlanObj->SetMacAddress(g_wlanObj, &ifeature, mac, macLen);
631         bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT || rc == HDF_ERR_DEVICE_BUSY);
632         ASSERT_TRUE(flag);
633         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
634         ASSERT_EQ(rc, HDF_SUCCESS);
635     }
636 }
637 
638 /**
639  * @tc.name: GetPowerModeTest_026
640  * @tc.desc: Wifi hdi get power mode function test
641  * @tc.type: FUNC
642  * @tc.require: AR000H603L
643  */
644 HWTEST_F(HdfWifiServiceCTest, GetPowerModeTest_026, TestSize.Level1)
645 {
646     struct HdfFeatureInfo ifeature;
647     uint8_t mode = 0;
648 
649     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, PROTOCOL_80211_IFTYPE_STATION, &ifeature);
650     if (rc == HDF_SUCCESS) {
651         rc = g_wlanObj->GetPowerMode(g_wlanObj, &ifeature, &mode);
652         bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT);
653         ASSERT_TRUE(flag);
654         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
655         ASSERT_EQ(rc, HDF_SUCCESS);
656     }
657 }
658 
659 /**
660  * @tc.name: SetPowerModeTest_027
661  * @tc.desc: Wifi hdi set power mode function test
662  * @tc.type: FUNC
663  * @tc.require: AR000H603L
664  */
665 HWTEST_F(HdfWifiServiceCTest, SetPowerModeTest_027, TestSize.Level1)
666 {
667     struct HdfFeatureInfo ifeature;
668     uint8_t mode = WIFI_POWER_MODE_GENERAL;
669 
670     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, PROTOCOL_80211_IFTYPE_AP, &ifeature);
671     if (rc == HDF_SUCCESS) {
672         rc = g_wlanObj->SetPowerMode(g_wlanObj, &ifeature, mode);
673         bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT);
674         ASSERT_TRUE(flag);
675         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
676         ASSERT_EQ(rc, HDF_SUCCESS);
677     }
678 }
679 
680 /**
681  * @tc.name: SetPowerModeTest_028
682  * @tc.desc: Wifi hdi set power mode function test
683  * @tc.type: FUNC
684  * @tc.require: AR000H603L
685  */
686 HWTEST_F(HdfWifiServiceCTest, SetPowerModeTest_028, TestSize.Level1)
687 {
688     struct HdfFeatureInfo ifeature;
689     uint8_t mode = WIFI_POWER_MODE_THROUGH_WALL;
690 
691     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, PROTOCOL_80211_IFTYPE_AP, &ifeature);
692     if (rc == HDF_SUCCESS) {
693         rc = g_wlanObj->SetPowerMode(g_wlanObj, &ifeature, mode);
694         bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT);
695         ASSERT_TRUE(flag);
696         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
697         ASSERT_EQ(rc, HDF_SUCCESS);
698     }
699 }
700 
701 /**
702  * @tc.name: SetPowerModeTest_029
703  * @tc.desc: Wifi hdi set power mode function test
704  * @tc.type: FUNC
705  * @tc.require: AR000H603L
706  */
707 HWTEST_F(HdfWifiServiceCTest, SetPowerModeTest_029, TestSize.Level1)
708 {
709     struct HdfFeatureInfo ifeature;
710     uint8_t mode = WIFI_POWER_MODE_NUM;
711 
712     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, PROTOCOL_80211_IFTYPE_AP, &ifeature);
713     if (rc == HDF_SUCCESS) {
714         rc = g_wlanObj->SetPowerMode(g_wlanObj, &ifeature, mode);
715         ASSERT_NE(rc, HDF_SUCCESS);
716         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
717         ASSERT_EQ(rc, HDF_SUCCESS);
718     }
719 }
720 
721 /**
722  * @tc.name: SetPowerModeTest_30
723  * @tc.desc: Wifi hdi set power mode function test
724  * @tc.type: FUNC
725  * @tc.require: AR000H603L
726  */
727 HWTEST_F(HdfWifiServiceCTest, SetPowerModeTest_030, TestSize.Level1)
728 {
729     struct HdfFeatureInfo ifeature;
730     uint8_t mode = WIFI_POWER_MODE_SLEEPING;
731 
732     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, PROTOCOL_80211_IFTYPE_STATION, &ifeature);
733     if (rc == HDF_SUCCESS) {
734         rc = g_wlanObj->SetPowerMode(g_wlanObj, &ifeature, mode);
735         bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT);
736         ASSERT_TRUE(flag);
737         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
738         ASSERT_EQ(rc, HDF_SUCCESS);
739     }
740 }
741 
742 /**
743  * @tc.name: SetPowerModeTest_031
744  * @tc.desc: Wifi hdi set power mode function test
745  * @tc.type: FUNC
746  * @tc.require: AR000H603L
747  */
748 HWTEST_F(HdfWifiServiceCTest, SetPowerModeTest_031, TestSize.Level1)
749 {
750     struct HdfFeatureInfo ifeature;
751     uint8_t mode = WIFI_POWER_MODE_GENERAL;
752 
753     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, PROTOCOL_80211_IFTYPE_STATION, &ifeature);
754     if (rc == HDF_SUCCESS) {
755         rc = g_wlanObj->SetPowerMode(g_wlanObj, &ifeature, mode);
756         bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT);
757         ASSERT_TRUE(flag);
758         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
759         ASSERT_EQ(rc, HDF_SUCCESS);
760     }
761 }
762 
763 /**
764  * @tc.name: SetPowerModeTest_032
765  * @tc.desc: Wifi hdi set power mode function test
766  * @tc.type: FUNC
767  * @tc.require: AR000H603L
768  */
769 HWTEST_F(HdfWifiServiceCTest, SetPowerModeTest_032, TestSize.Level1)
770 {
771     struct HdfFeatureInfo ifeature;
772     uint8_t mode = WIFI_POWER_MODE_THROUGH_WALL;
773 
774     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, PROTOCOL_80211_IFTYPE_STATION, &ifeature);
775     if (rc == HDF_SUCCESS) {
776         rc = g_wlanObj->SetPowerMode(g_wlanObj, &ifeature, mode);
777         bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT);
778         ASSERT_TRUE(flag);
779         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
780         ASSERT_EQ(rc, HDF_SUCCESS);
781     }
782 }
783 
784 /**
785  * @tc.name: SetPowerModeTest_033
786  * @tc.desc: Wifi hdi set power mode function test
787  * @tc.type: FUNC
788  * @tc.require: AR000H603L
789  */
790 HWTEST_F(HdfWifiServiceCTest, SetPowerModeTest_033, TestSize.Level1)
791 {
792     struct HdfFeatureInfo ifeature;
793     uint8_t mode = WIFI_POWER_MODE_NUM;
794 
795     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, PROTOCOL_80211_IFTYPE_STATION, &ifeature);
796     if (rc == HDF_SUCCESS) {
797         rc = g_wlanObj->SetPowerMode(g_wlanObj, &ifeature, mode);
798         ASSERT_NE(rc, HDF_SUCCESS);
799         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
800         ASSERT_EQ(rc, HDF_SUCCESS);
801     }
802 }
803 
804 /**
805  * @tc.name: StartChannelMeasTest_034
806  * @tc.desc: Wifi hdi start channel meas and get meas result function test
807  * @tc.type: FUNC
808  * @tc.require: AR000H603J
809  */
810 HWTEST_F(HdfWifiServiceCTest, StartChannelMeasTest_034, TestSize.Level1)
811 {
812     const char *ifName = "wlan0";
813     struct MeasChannelParam measChannelParam;
814     struct MeasChannelResult measChannelResult = {0};
815 
816     measChannelParam.channelId = 1;
817     measChannelParam.measTime = 15;
818     int32_t rc = g_wlanObj->StartChannelMeas(g_wlanObj, ifName, &measChannelParam);
819     bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT || rc == HDF_DEV_ERR_NETDOWN);
820     ASSERT_TRUE(flag);
821     sleep(MEAS_CHANNEL_TIME);
822     rc = g_wlanObj->GetChannelMeasResult(g_wlanObj, ifName, &measChannelResult);
823     flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT || rc == HDF_DEV_ERR_NODATA);
824     ASSERT_TRUE(flag);
825     rc = g_wlanObj->StartChannelMeas(g_wlanObj, nullptr, &measChannelParam);
826     ASSERT_NE(rc, HDF_SUCCESS);
827     rc = g_wlanObj->StartChannelMeas(g_wlanObj, ifName, nullptr);
828     ASSERT_NE(rc, HDF_SUCCESS);
829     rc = g_wlanObj->GetChannelMeasResult(g_wlanObj, nullptr, &measChannelResult);
830     ASSERT_NE(rc, HDF_SUCCESS);
831     rc = g_wlanObj->GetChannelMeasResult(g_wlanObj, ifName, nullptr);
832     ASSERT_NE(rc, HDF_SUCCESS);
833 }
834 
835 /**
836  * @tc.name: SetProjectionScreenParam_035
837  * @tc.desc: Wifi hdi set paramters to optimize projectino screen function test
838  * @tc.type: FUNC
839  * @tc.require: AR000HDUEE
840  */
841 HWTEST_F(HdfWifiServiceCTest, SetProjectionScreenParam_035, TestSize.Level1)
842 {
843     const char *ifName = "wlan0";
844     int32_t rc;
845     struct ProjectionScreenCmdParam param;
846     int8_t data = 0;
847     (void)memset_s(&param, sizeof(struct ProjectionScreenCmdParam), 0, sizeof(struct ProjectionScreenCmdParam));
848 
849     param.buf = &data;
850     param.bufLen = sizeof(data);
851     param.cmdId = CMD_CLOSE_GO_CAC;
852     rc = g_wlanObj->SetProjectionScreenParam(g_wlanObj, ifName, &param);
853     printf("ScreenParam = %d, rc = %d.\n", CMD_CLOSE_GO_CAC, rc);
854     bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT);
855     ASSERT_TRUE(flag);
856 }
857 
858 /**
859  * @tc.name: SetProjectionScreenParam_036
860  * @tc.desc: Wifi hdi set paramters to optimize projectino screen function test
861  * @tc.type: FUNC
862  * @tc.require:
863  */
864 HWTEST_F(HdfWifiServiceCTest, SetProjectionScreenParam_036, TestSize.Level1)
865 {
866     const char *ifName = "wlan0";
867     int32_t rc;
868     struct ProjectionScreenCmdParam param;
869     int8_t data = 0;
870     (void)memset_s(&param, sizeof(struct ProjectionScreenCmdParam), 0, sizeof(struct ProjectionScreenCmdParam));
871 
872     param.buf = &data;
873     param.bufLen = sizeof(data);
874     param.cmdId = CMD_SET_GO_CSA_CHANNEL;
875     rc = g_wlanObj->SetProjectionScreenParam(g_wlanObj, ifName, &param);
876     printf("ScreenParam = %d, rc = %d.\n", CMD_SET_GO_CSA_CHANNEL, rc);
877     bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT || rc == HDF_DEV_ERR_NETDOWN);
878     ASSERT_TRUE(flag);
879 }
880 
881 /**
882  * @tc.name: SetProjectionScreenParam_037
883  * @tc.desc: Wifi hdi set paramters to optimize projectino screen function test
884  * @tc.type: FUNC
885  * @tc.require:
886  */
887 HWTEST_F(HdfWifiServiceCTest, SetProjectionScreenParam_037, TestSize.Level1)
888 {
889     const char *ifName = "wlan0";
890     int32_t rc;
891     struct ProjectionScreenCmdParam param;
892     int8_t data = 0;
893     (void)memset_s(&param, sizeof(struct ProjectionScreenCmdParam), 0, sizeof(struct ProjectionScreenCmdParam));
894 
895     param.buf = &data;
896     param.bufLen = sizeof(data);
897     param.cmdId = CMD_SET_GO_RADAR_DETECT;
898     rc = g_wlanObj->SetProjectionScreenParam(g_wlanObj, ifName, &param);
899     printf("ScreenParam = %d, rc = %d.\n", CMD_SET_GO_RADAR_DETECT, rc);
900     bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT || rc == HDF_DEV_ERR_NETDOWN);
901     ASSERT_TRUE(flag);
902 }
903 
904 /**
905  * @tc.name: SetProjectionScreenParam_038
906  * @tc.desc: Wifi hdi set paramters to optimize projectino screen function test
907  * @tc.type: FUNC
908  * @tc.require:
909  */
910 HWTEST_F(HdfWifiServiceCTest, SetProjectionScreenParam_038, TestSize.Level1)
911 {
912     const char *ifName = "wlan0";
913     int32_t rc;
914     struct ProjectionScreenCmdParam param;
915     int8_t data = 0;
916     (void)memset_s(&param, sizeof(struct ProjectionScreenCmdParam), 0, sizeof(struct ProjectionScreenCmdParam));
917 
918     param.buf = &data;
919     param.bufLen = sizeof(data);
920     param.cmdId = CMD_ID_MCC_STA_P2P_QUOTA_TIME;
921     rc = g_wlanObj->SetProjectionScreenParam(g_wlanObj, ifName, &param);
922     printf("ScreenParam = %d, rc = %d.\n", CMD_ID_MCC_STA_P2P_QUOTA_TIME, rc);
923     bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT || rc == HDF_DEV_ERR_NETDOWN);
924     ASSERT_TRUE(flag);
925 }
926 
927 /**
928  * @tc.name: SetProjectionScreenParam_039
929  * @tc.desc: Wifi hdi set paramters to optimize projectino screen function test
930  * @tc.type: FUNC
931  * @tc.require:
932  */
933 HWTEST_F(HdfWifiServiceCTest, SetProjectionScreenParam_039, TestSize.Level1)
934 {
935     const char *ifName = "wlan0";
936     int32_t rc;
937     struct ProjectionScreenCmdParam param;
938     int8_t data = 0;
939     (void)memset_s(&param, sizeof(struct ProjectionScreenCmdParam), 0, sizeof(struct ProjectionScreenCmdParam));
940 
941     param.buf = &data;
942     param.bufLen = sizeof(data);
943     param.cmdId = CMD_ID_CTRL_ROAM_CHANNEL;
944     rc = g_wlanObj->SetProjectionScreenParam(g_wlanObj, ifName, &param);
945     printf("ScreenParam = %d, rc = %d.\n", CMD_ID_CTRL_ROAM_CHANNEL, rc);
946     bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT || rc == HDF_DEV_ERR_NETDOWN);
947     ASSERT_TRUE(flag);
948 }
949 
950 /**
951  * @tc.name: SendCmdIoctl_040
952  * @tc.desc: Wifi hdi send ioctl command function test
953  * @tc.type: FUNC
954  * @tc.require: AR000HDUEE
955  */
956 HWTEST_F(HdfWifiServiceCTest, SendCmdIoctl_040, TestSize.Level1)
957 {
958     const char *ifName = "wlan0";
959     int32_t rc;
960     bool flag;
961 
962     uint8_t deviceType = 5;
963     rc = g_wlanObj->WifiSendCmdIoctl(g_wlanObj, ifName, CMD_HID2D_MODULE_INIT, (const int8_t *)&deviceType,
964         sizeof(deviceType));
965     printf("SendCmdIoctl MODULE_INIT, rc=%d.\n", rc);
966     flag = ((rc == HDF_SUCCESS) || (rc == HDF_ERR_NOT_SUPPORT) || (rc == HDF_DEV_ERR_NETDOWN));
967     ASSERT_TRUE(flag);
968 }
969 
970 /**
971  * @tc.name: SendCmdIoctl_041
972  * @tc.desc: Wifi hdi send ioctl command function test
973  * @tc.type: FUNC
974  * @tc.require:
975  */
976 HWTEST_F(HdfWifiServiceCTest, SendCmdIoctl_041, TestSize.Level1)
977 {
978     const char *ifName = "wlan0";
979     int32_t rc;
980     bool flag;
981 
982     uint8_t batterylevel = 50;
983     rc = g_wlanObj->WifiSendCmdIoctl(g_wlanObj, ifName, CMD_SET_BATTERY_LEVEL, (const int8_t *)&batterylevel,
984         sizeof(batterylevel));
985     printf("SendCmdIoctl BATTERY_LEVEL, rc=%d.\n", rc);
986     flag = ((rc == HDF_SUCCESS) || (rc == HDF_ERR_NOT_SUPPORT) || (rc == HDF_DEV_ERR_NETDOWN));
987     ASSERT_TRUE(flag);
988 }
989 
990 /**
991  * @tc.name: SendCmdIoctl_042
992  * @tc.desc: Wifi hdi send ioctl command function test
993  * @tc.type: FUNC
994  * @tc.require:
995  */
996 HWTEST_F(HdfWifiServiceCTest, SendCmdIoctl_042, TestSize.Level1)
997 {
998     const char *ifName = "wlan0";
999     int32_t rc;
1000 
1001     struct AdjustChannelInfo chanInfo;
1002     chanInfo.msgId = 5;
1003     chanInfo.chanNumber = 36;
1004     chanInfo.bandwidth = 80;
1005     chanInfo.switchType = 0;
1006     rc = g_wlanObj->WifiSendCmdIoctl(g_wlanObj, ifName, CMD_SET_CHAN_ADJUST, (const int8_t *)&chanInfo,
1007         sizeof(chanInfo));
1008     printf("SendCmdIoctl CHAN_ADJUST, rc=%d.\n", rc);
1009     ASSERT_EQ(rc, -1);
1010 }
1011 
1012 /**
1013  * @tc.name: GetStaInfo_043
1014  * @tc.desc: Wifi hdi get station information function test
1015  * @tc.type: FUNC
1016  * @tc.require:
1017  */
1018 HWTEST_F(HdfWifiServiceCTest, GetStaInfo_043, TestSize.Level1)
1019 {
1020     const char *ifName = "wlan0";
1021     int32_t rc;
1022     struct WifiStationInfo info;
1023     bool flag;
1024     uint8_t mac[ETH_ADDR_LEN] = {0};
1025 
1026     rc = g_wlanObj->GetStaInfo(g_wlanObj, ifName, &info, mac, ETH_ADDR_LEN);
1027     flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT);
1028     ASSERT_TRUE(flag);
1029 }
1030 
1031 /**
1032  * @tc.name: GetFeatureTypeTest_044
1033  * @tc.desc: Wifi hdi get feature type function test on STA feature
1034  * @tc.type: FUNC
1035  * @tc.require:
1036  */
1037 HWTEST_F(HdfWifiServiceCTest, GetFeatureTypeTest_044, TestSize.Level1)
1038 {
1039     const int32_t wlanType = PROTOCOL_80211_IFTYPE_STATION;
1040     struct HdfFeatureInfo ifeature;
1041     int32_t featureType;
1042 
1043     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
1044     if (rc == HDF_SUCCESS) {
1045         rc = g_wlanObj->GetFeatureType(g_wlanObj, &ifeature, &featureType);
1046         ASSERT_EQ(rc, HDF_SUCCESS);
1047         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
1048         ASSERT_EQ(rc, HDF_SUCCESS);
1049     }
1050 }
1051 
1052 /**
1053  * @tc.name: GetFreqsWithBandTest_045
1054  * @tc.desc: Wifi hdi get freqs function test on STA feature
1055  * @tc.type: FUNC
1056  * @tc.require:
1057  */
1058 HWTEST_F(HdfWifiServiceCTest, GetFreqsWithBandTest_045, TestSize.Level1)
1059 {
1060     const int32_t wlanType = PROTOCOL_80211_IFTYPE_STATION;
1061     struct HdfFeatureInfo ifeature;
1062     struct HdfWifiInfo wifiInfo;
1063     int32_t freq[WLAN_FREQ_MAX_NUM] = {0};
1064     uint32_t freqLen = WLAN_FREQ_MAX_NUM;
1065     wifiInfo.band = IEEE80211_BAND_2GHZ;
1066     wifiInfo.size = WLAN_FREQ_MAX_NUM;
1067     uint32_t i;
1068 
1069     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
1070     if (rc == HDF_SUCCESS) {
1071         rc = g_wlanObj->GetFreqsWithBand(g_wlanObj, &ifeature, &wifiInfo, freq, &freqLen);
1072         ASSERT_EQ(rc, HDF_SUCCESS);
1073         if (rc == HDF_SUCCESS) {
1074             for (i = 0; i < freqLen; i++) {
1075                 printf("%s: freq[%d] = %d\n", __func__, i, freq[i]);
1076             }
1077         }
1078 
1079         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
1080         ASSERT_EQ(rc, HDF_SUCCESS);
1081     }
1082 }
1083 
1084 /**
1085  * @tc.name: GetNetworkIfaceNameTest_046
1086  * @tc.desc: Wifi hdi get network interface name function test on STA feature
1087  * @tc.type: FUNC
1088  * @tc.require:
1089  */
1090 HWTEST_F(HdfWifiServiceCTest, GetNetworkIfaceNameTest_046, TestSize.Level1)
1091 {
1092     const int32_t wlanType = PROTOCOL_80211_IFTYPE_STATION;
1093     struct HdfFeatureInfo ifeature;
1094     char ifNames[IFNAMSIZ] = {0};
1095 
1096     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
1097     if (rc == HDF_SUCCESS) {
1098         rc = g_wlanObj->GetNetworkIfaceName(g_wlanObj, &ifeature, ifNames, IFNAMSIZ);
1099         ASSERT_EQ(rc, HDF_SUCCESS);
1100         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
1101         ASSERT_EQ(rc, HDF_SUCCESS);
1102     }
1103 }
1104 
1105 /**
1106  * @tc.name: SetTxPowerTest_047
1107  * @tc.desc: Wifi hdi set tx power function test on STA feature
1108  * @tc.type: FUNC
1109  * @tc.require:
1110  */
1111 HWTEST_F(HdfWifiServiceCTest, SetTxPowerTest_047, TestSize.Level1)
1112 {
1113     const int32_t wlanType = PROTOCOL_80211_IFTYPE_STATION;
1114     struct HdfFeatureInfo ifeature;
1115     int32_t power = WLAN_TX_POWER;
1116 
1117     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
1118     if (rc == HDF_SUCCESS) {
1119         rc = g_wlanObj->SetTxPower(g_wlanObj, &ifeature, power);
1120         ASSERT_EQ(rc, HDF_SUCCESS);
1121         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
1122         ASSERT_EQ(rc, HDF_SUCCESS);
1123     }
1124 }
1125 
1126 /**
1127  * @tc.name: GetSignalPollInfo_048
1128  * @tc.desc: Wifi hdi get signal information
1129  * @tc.type: FUNC
1130  * @tc.require:
1131  */
1132 HWTEST_F(HdfWifiServiceCTest, GetSignalPollInfo_048, TestSize.Level1)
1133 {
1134     const int32_t wlanType = PROTOCOL_80211_IFTYPE_STATION;
1135     struct HdfFeatureInfo ifeature;
1136     const char *ifName = "wlan0";
1137     struct SignalPollResult signalResult;
1138     (void)memset_s(&signalResult, sizeof(struct SignalPollResult), 0, sizeof(struct SignalPollResult));
1139 
1140     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
1141     if (rc == HDF_SUCCESS) {
1142         rc = g_wlanObj->GetSignalPollInfo(g_wlanObj, ifName, &signalResult);
1143         bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT);
1144         printf("GetSignalPollInfo rc = %d.\n", rc);
1145         ASSERT_TRUE(flag);
1146         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
1147         ASSERT_EQ(rc, HDF_SUCCESS);
1148     }
1149 }
1150 
1151 /**
1152  * @tc.name: StartPnoScan_049
1153  * @tc.desc: Wifi hdi start pno scan
1154  * @tc.type: FUNC
1155  * @tc.require:
1156  */
1157 HWTEST_F(HdfWifiServiceCTest, StartPnoScan_049, TestSize.Level1)
1158 {
1159     const int32_t wlanType = PROTOCOL_80211_IFTYPE_STATION;
1160     struct HdfFeatureInfo ifeature;
1161     const char *ifName = "wlan0";
1162     string ssid1 = "xa-hw";
1163     string ssid2 = "xa-hw-03";
1164     struct PnoSettings pnoSettings;
1165     (void)memset_s(&pnoSettings, sizeof(struct PnoSettings), 0, sizeof(struct PnoSettings));
1166     pnoSettings.min2gRssi = -100;
1167     pnoSettings.min5gRssi = -120;
1168     pnoSettings.scanIntervalMs = 60000;
1169     pnoSettings.scanIterations = 3;
1170 
1171     pnoSettings.pnoNetworksLen = 2;
1172     pnoSettings.pnoNetworks = (struct PnoNetwork *)OsalMemCalloc(sizeof(struct PnoNetwork) * 2);
1173     pnoSettings.pnoNetworks[0].isHidden = 1;
1174     pnoSettings.pnoNetworks[0].ssid.ssid = const_cast<char*>(ssid1.c_str());
1175     pnoSettings.pnoNetworks[0].ssid.ssidLen = ssid1.length();
1176     pnoSettings.pnoNetworks[0].freqsLen = 2;
1177     pnoSettings.pnoNetworks[0].freqs = (int32_t *)OsalMemCalloc(sizeof(int32_t) * 2);
1178     pnoSettings.pnoNetworks[0].freqs[0] = 2412;
1179     pnoSettings.pnoNetworks[0].freqs[1] = 2447;
1180     pnoSettings.pnoNetworks[1].isHidden = 0;
1181     pnoSettings.pnoNetworks[1].ssid.ssid = const_cast<char*>(ssid2.c_str());
1182     pnoSettings.pnoNetworks[1].ssid.ssidLen = ssid2.length();
1183 
1184     int32_t rc = g_wlanObj->RegisterEventCallback(g_wlanObj, g_wlanCallbackObj, ifName);
1185     ASSERT_EQ(rc, HDF_SUCCESS);
1186     rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
1187     if (rc == HDF_SUCCESS) {
1188         rc = g_wlanObj->StartPnoScan(g_wlanObj, nullptr, &pnoSettings);
1189         ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
1190         rc = g_wlanObj->StartPnoScan(g_wlanObj, ifName, nullptr);
1191         ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
1192         rc = g_wlanObj->StartPnoScan(g_wlanObj, ifName, &pnoSettings);
1193         bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT);
1194         ASSERT_TRUE(flag);
1195         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
1196         ASSERT_EQ(rc, HDF_SUCCESS);
1197     }
1198     rc = g_wlanObj->UnregisterEventCallback(g_wlanObj, g_wlanCallbackObj, ifName);
1199     ASSERT_EQ(rc, HDF_SUCCESS);
1200     OsalMemFree(pnoSettings.pnoNetworks[0].freqs);
1201     OsalMemFree(pnoSettings.pnoNetworks);
1202 }
1203 
1204 /**
1205  * @tc.name: StopPnoScan_050
1206  * @tc.desc: Wifi hdi stop pno scan
1207  * @tc.type: FUNC
1208  * @tc.require:
1209  */
1210 HWTEST_F(HdfWifiServiceCTest, StopPnoScan_050, TestSize.Level1)
1211 {
1212     const int32_t wlanType = PROTOCOL_80211_IFTYPE_STATION;
1213     struct HdfFeatureInfo ifeature;
1214     const char *ifName = "wlan0";
1215 
1216     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
1217     if (rc == HDF_SUCCESS) {
1218         rc = g_wlanObj->StopPnoScan(g_wlanObj, nullptr);
1219         ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
1220         rc = g_wlanObj->StopPnoScan(g_wlanObj, ifName);
1221         bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT);
1222         ASSERT_TRUE(flag);
1223         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
1224         ASSERT_EQ(rc, HDF_SUCCESS);
1225     }
1226 }
1227 
1228 /**
1229  * @tc.name: StartScanTest_051
1230  * @tc.desc: Wifi hdi start scan function test
1231  * @tc.type: FUNC
1232  * @tc.require:
1233  */
1234 HWTEST_F(HdfWifiServiceCTest, StartScanTest_051, TestSize.Level1)
1235 {
1236     int32_t rc;
1237     const int32_t wlanType = PROTOCOL_80211_IFTYPE_STATION;
1238     string ssid1 = "xa-hw";
1239     struct HdfFeatureInfo ifeature;
1240     struct HdfWifiScan scan;
1241 
1242     (void)memset_s(&scan, sizeof(struct HdfWifiScan), 0, sizeof(struct HdfWifiScan));
1243     scan.ssidsLen = 1;
1244     scan.ssids = (HdfWifiDriverScanSsid *)OsalMemCalloc(sizeof(HdfWifiDriverScanSsid) * (scan.ssidsLen));
1245     scan.ssids[0].ssid = const_cast<char*>(ssid1.c_str());
1246     scan.ssids[0].ssidLen = ssid1.length();
1247     scan.freqsLen = 2;
1248     scan.freqs = (int32_t *)OsalMemCalloc(sizeof(int32_t) * (scan.freqsLen));
1249     scan.freqs[0] = 2412;
1250     scan.freqs[1] = 2447;
1251     scan.bssidLen = 6;
1252     scan.bssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (scan.bssidLen));
1253     scan.bssid[0] = 0x12;
1254     scan.bssid[1] = 0x34;
1255     scan.bssid[2] = 0x56;
1256     scan.bssid[3] = 0x78;
1257     scan.bssid[4] = 0x9A;
1258     scan.bssid[5] = 0xBC;
1259 
1260     rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
1261     if (rc == HDF_SUCCESS) {
1262         rc = g_wlanObj->StartScan(g_wlanObj, &ifeature, &scan);
1263         ASSERT_EQ(rc, HDF_SUCCESS);
1264         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
1265         ASSERT_EQ(rc, HDF_SUCCESS);
1266         sleep(SCAN_TIME);
1267     }
1268     OsalMemFree(scan.bssid);
1269     OsalMemFree(scan.freqs);
1270     OsalMemFree(scan.ssids);
1271 }
1272 
1273 /**
1274  * @tc.name: GetApBandwidthTest_052
1275  * @tc.desc: Wifi hdi get AP bandwidth function test
1276  * @tc.type: FUNC
1277  * @tc.require:
1278  */
1279 HWTEST_F(HdfWifiServiceCTest, GetApBandwidthTest_052, TestSize.Level1)
1280 {
1281     uint8_t bandwidth = 0;
1282     const char *ifName = "wlan0";
1283 
1284     struct HdfFeatureInfo ifeature;
1285     const int32_t wlanType = PROTOCOL_80211_IFTYPE_AP;
1286 
1287     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
1288     if (rc == HDF_SUCCESS) {
1289         rc = g_wlanObj->GetApBandwidth(g_wlanObj, nullptr, &bandwidth);
1290         ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
1291 
1292         rc = g_wlanObj->GetApBandwidth(g_wlanObj, ifName, &bandwidth);
1293         bool flag = (rc == HDF_SUCCESS || rc == HDF_FAILURE);
1294         ASSERT_TRUE(flag);
1295 
1296         printf("bandwidth: %u\n", bandwidth);
1297 
1298         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
1299         ASSERT_EQ(rc, HDF_SUCCESS);
1300     }
1301 }
1302 
1303 /**
1304  * @tc.name: ResetToFactoryMacAddressTest_0053
1305  * @tc.desc: Wifi hdi reset to factory maca address function test
1306  * @tc.type: FUNC
1307  * @tc.require:
1308  */
1309 HWTEST_F(HdfWifiServiceCTest, ResetToFactoryMacAddressTest_0053, TestSize.Level1)
1310 {
1311     const int32_t wlanType = PROTOCOL_80211_IFTYPE_AP;
1312     struct HdfFeatureInfo ifeature;
1313 
1314     int32_t rc = g_wlanObj->CreateFeature(g_wlanObj, wlanType, &ifeature);
1315     if (rc == HDF_SUCCESS) {
1316         uint8_t mac[ETH_ADDR_LEN] = {0};
1317         uint32_t macLen = ETH_ADDR_LEN;
1318         rc = g_wlanObj->GetDeviceMacAddress(g_wlanObj, &ifeature, mac, &macLen, ETH_ADDR_LEN);
1319         ASSERT_EQ(rc, HDF_SUCCESS);
1320 
1321         uint8_t tmpMac[ETH_ADDR_LEN] = {0x12, 0x34, 0x56, 0x78, 0xab, 0xcd};
1322         rc = g_wlanObj->SetMacAddress(g_wlanObj, &ifeature, tmpMac, macLen);
1323         bool flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT || rc == HDF_ERR_DEVICE_BUSY);
1324         ASSERT_TRUE(flag);
1325 
1326         const char *ifName = "wlan0";
1327         rc = g_wlanObj->ResetToFactoryMacAddress(g_wlanObj, ifName);
1328         flag = (rc == HDF_SUCCESS || rc == HDF_ERR_NOT_SUPPORT || rc == HDF_ERR_DEVICE_BUSY);
1329         ASSERT_TRUE(flag);
1330 
1331         rc = g_wlanObj->DestroyFeature(g_wlanObj, &ifeature);
1332         ASSERT_EQ(rc, HDF_SUCCESS);
1333     }
1334 }
1335 
1336 };
1337