1 /*
2  * Copyright (c) 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_1/iwpa_interface.h"
19 #include "p2p_callback_impl.h"
20 #include "securec.h"
21 
22 #define IFNAME "wlan0"
23 #define CONFNAME "/data/service/el1/public/wifi/wpa_supplicant/wpa_supplicant.conf"
24 
25 #define HDF_LOG_TAG service_manager_test
26 using namespace testing::ext;
27 
28 namespace HdiP2pTest {
29 const char *g_wlanServiceNameP2p = "wpa_interface_service";
30 
31 class HdfP2pHostCTest : public testing::Test {
32 public:
33     static void SetUpTestCase();
34     static void TearDownTestCase();
35     void SetUp();
36     void TearDown();
37 };
38 
39 static struct IWpaInterface *g_wpaObj = nullptr;
40 struct IWpaCallback *g_wpaCallbackObj = nullptr;
SetUpTestCase()41 void HdfP2pHostCTest::SetUpTestCase()
42 {
43     g_wpaObj = IWpaInterfaceGetInstance(g_wlanServiceNameP2p, false);
44     g_wpaCallbackObj = P2pCallbackServiceGet();
45     ASSERT_TRUE(g_wpaObj != nullptr);
46     ASSERT_TRUE(g_wpaCallbackObj != nullptr);
47 }
48 
TearDownTestCase()49 void HdfP2pHostCTest::TearDownTestCase()
50 {
51     IWpaInterfaceReleaseInstance(g_wlanServiceNameP2p, g_wpaObj, false);
52     P2pCallbackServiceRelease(g_wpaCallbackObj);
53 }
54 
SetUp()55 void HdfP2pHostCTest::SetUp()
56 {
57     int32_t rc = g_wpaObj->Start(g_wpaObj);
58     ASSERT_EQ(rc, HDF_SUCCESS);
59 }
60 
TearDown()61 void HdfP2pHostCTest::TearDown()
62 {
63     int32_t rc = g_wpaObj->Stop(g_wpaObj);
64     ASSERT_EQ(rc, HDF_SUCCESS);
65 }
66 
67 HWTEST_F(HdfP2pHostCTest, P2pSetSsidPostfixNameTest_001, TestSize.Level1)
68 {
69     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
70     ASSERT_EQ(rc, HDF_SUCCESS);
71     if (rc == HDF_SUCCESS) {
72         rc = g_wpaObj->P2pSetSsidPostfixName(g_wpaObj, "p2p-dev-wlan0", "test");
73         ASSERT_EQ(rc, HDF_SUCCESS);
74         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
75         ASSERT_EQ(rc, HDF_SUCCESS);
76     }
77 }
78 
79 HWTEST_F(HdfP2pHostCTest, P2pSetWpsDeviceTypeTest_002, TestSize.Level1)
80 {
81     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
82     ASSERT_EQ(rc, HDF_SUCCESS);
83     if (rc == HDF_SUCCESS) {
84         rc = g_wpaObj->P2pSetWpsDeviceType(g_wpaObj, "p2p-dev-wlan0", "1-0050F204-1");
85         ASSERT_EQ(rc, HDF_SUCCESS);
86         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
87         ASSERT_EQ(rc, HDF_SUCCESS);
88     }
89 }
90 
91 HWTEST_F(HdfP2pHostCTest, P2pSetWpsConfigMethodsTest_003, TestSize.Level1)
92 {
93     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
94     ASSERT_EQ(rc, HDF_SUCCESS);
95     if (rc == HDF_SUCCESS) {
96         rc = g_wpaObj->P2pSetWpsConfigMethods(g_wpaObj, "p2p-dev-wlan0", "test");
97         ASSERT_EQ(rc, HDF_SUCCESS);
98         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
99         ASSERT_EQ(rc, HDF_SUCCESS);
100     }
101 }
102 
103 HWTEST_F(HdfP2pHostCTest, P2pSetGroupMaxIdleTest_004, TestSize.Level1)
104 {
105     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
106     ASSERT_EQ(rc, HDF_SUCCESS);
107     if (rc == HDF_SUCCESS) {
108         rc = g_wpaObj->P2pSetGroupMaxIdle(g_wpaObj, "p2p-dev-wlan0", 1);
109         ASSERT_EQ(rc, HDF_SUCCESS);
110         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
111         ASSERT_EQ(rc, HDF_SUCCESS);
112     }
113 }
114 
115 HWTEST_F(HdfP2pHostCTest, P2pSetWfdEnableTest_005, TestSize.Level1)
116 {
117     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
118     ASSERT_EQ(rc, HDF_SUCCESS);
119     if (rc == HDF_SUCCESS) {
120         rc = g_wpaObj->P2pSetWfdEnable(g_wpaObj, "p2p-dev-wlan0", 0);
121         ASSERT_EQ(rc, HDF_SUCCESS);
122         rc = g_wpaObj->P2pSetWfdEnable(g_wpaObj, "p2p-dev-wlan0", 1);
123         ASSERT_EQ(rc, HDF_SUCCESS);
124         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
125         ASSERT_EQ(rc, HDF_SUCCESS);
126     }
127 }
128 
129 HWTEST_F(HdfP2pHostCTest, P2pSetPersistentReconnectTest_006, TestSize.Level1)
130 {
131     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
132     ASSERT_EQ(rc, HDF_SUCCESS);
133     if (rc == HDF_SUCCESS) {
134         rc = g_wpaObj->P2pSetPersistentReconnect(g_wpaObj, "p2p-dev-wlan0", 1);
135         ASSERT_EQ(rc, HDF_SUCCESS);
136         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
137         ASSERT_EQ(rc, HDF_SUCCESS);
138     }
139 }
140 
141 HWTEST_F(HdfP2pHostCTest, P2pSetWpsSecondaryDeviceTypeTest_007, TestSize.Level1)
142 {
143     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
144     ASSERT_EQ(rc, HDF_SUCCESS);
145     if (rc == HDF_SUCCESS) {
146         rc = g_wpaObj->P2pSetWpsSecondaryDeviceType(g_wpaObj, "p2p-dev-wlan0", "1-0050F204-1");
147         ASSERT_EQ(rc, HDF_SUCCESS);
148         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
149         ASSERT_EQ(rc, HDF_SUCCESS);
150     }
151 }
152 
153 HWTEST_F(HdfP2pHostCTest, P2pSetupWpsPbcTest_008, TestSize.Level1)
154 {
155     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
156     ASSERT_EQ(rc, HDF_SUCCESS);
157     if (rc == HDF_SUCCESS) {
158         rc = g_wpaObj->P2pSetupWpsPbc(g_wpaObj, "p2p-dev-wlan0", "00:00:00:00:00:00");
159         ASSERT_EQ(rc, HDF_SUCCESS);
160         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
161         ASSERT_EQ(rc, HDF_SUCCESS);
162     }
163 }
164 
165 HWTEST_F(HdfP2pHostCTest, P2pSetupWpsPinTest_009, TestSize.Level1)
166 {
167     const char *pin = "00000000";
168     char *resultBuf = (char *)calloc(REPLY_SIZE, sizeof(char));
169     uint32_t resultBufLen = REPLY_SIZE;
170     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
171     ASSERT_EQ(rc, HDF_SUCCESS);
172     if (rc == HDF_SUCCESS) {
173         rc = g_wpaObj->P2pSetupWpsPin(g_wpaObj, "p2p-dev-wlan0", "00:00:00:00:00:00", pin, resultBuf, resultBufLen);
174         printf("resultBuf: %s", resultBuf);
175         ASSERT_EQ(rc, HDF_SUCCESS);
176         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
177         ASSERT_EQ(rc, HDF_SUCCESS);
178     }
179     free(resultBuf);
180 }
181 
182 HWTEST_F(HdfP2pHostCTest, P2pSetPowerSaveTest_010, TestSize.Level1)
183 {
184     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
185     ASSERT_EQ(rc, HDF_SUCCESS);
186     if (rc == HDF_SUCCESS) {
187         rc = g_wpaObj->P2pSetPowerSave(g_wpaObj, "p2p-dev-wlan0", 0);
188         ASSERT_EQ(rc, HDF_FAILURE);
189         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
190         ASSERT_EQ(rc, HDF_SUCCESS);
191     }
192 }
193 
194 HWTEST_F(HdfP2pHostCTest, P2pSetDeviceNameTest_011, TestSize.Level1)
195 {
196     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
197     ASSERT_EQ(rc, HDF_SUCCESS);
198     if (rc == HDF_SUCCESS) {
199         rc = g_wpaObj->P2pSetDeviceName(g_wpaObj, "p2p-dev-wlan0", "test");
200         ASSERT_EQ(rc, HDF_SUCCESS);
201         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
202         ASSERT_EQ(rc, HDF_SUCCESS);
203     }
204 }
205 
206 HWTEST_F(HdfP2pHostCTest, P2pSetWfdDeviceConfigTest_012, TestSize.Level1)
207 {
208     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
209     ASSERT_EQ(rc, HDF_SUCCESS);
210     if (rc == HDF_SUCCESS) {
211         rc = g_wpaObj->P2pSetWfdDeviceConfig(g_wpaObj, "p2p-dev-wlan0", "all 0123456");
212         ASSERT_EQ(rc, HDF_FAILURE);
213         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
214         ASSERT_EQ(rc, HDF_SUCCESS);
215     }
216 }
217 
218 HWTEST_F(HdfP2pHostCTest, P2pSetRandomMacTest_013, TestSize.Level1)
219 {
220     int networkId = 1;
221     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
222     ASSERT_EQ(rc, HDF_SUCCESS);
223     if (rc == HDF_SUCCESS) {
224         rc = g_wpaObj->P2pSetRandomMac(g_wpaObj, "p2p-dev-wlan0", networkId);
225         ASSERT_EQ(rc, HDF_SUCCESS);
226         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
227         ASSERT_EQ(rc, HDF_SUCCESS);
228     }
229 }
230 
231 HWTEST_F(HdfP2pHostCTest, P2pStartFindTest_014, TestSize.Level1)
232 {
233     const int time = 120;
234     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
235     ASSERT_EQ(rc, HDF_SUCCESS);
236     if (rc == HDF_SUCCESS) {
237         rc = g_wpaObj->P2pStartFind(g_wpaObj, "p2p-dev-wlan0", time);
238         ASSERT_EQ(rc, HDF_SUCCESS);
239         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
240         ASSERT_EQ(rc, HDF_SUCCESS);
241     }
242 }
243 
244 HWTEST_F(HdfP2pHostCTest, P2pSetExtListenTest_015, TestSize.Level1)
245 {
246     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
247     ASSERT_EQ(rc, HDF_SUCCESS);
248     if (rc == HDF_SUCCESS) {
249         rc = g_wpaObj->P2pSetExtListen(g_wpaObj, "p2p-dev-wlan0", 0, 1, 1);
250         ASSERT_EQ(rc, HDF_SUCCESS);
251         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
252         ASSERT_EQ(rc, HDF_SUCCESS);
253     }
254 }
255 
256 HWTEST_F(HdfP2pHostCTest, P2pSetListenChannelTest_016, TestSize.Level1)
257 {
258     const int channel = 24;
259     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
260     ASSERT_EQ(rc, HDF_SUCCESS);
261     if (rc == HDF_SUCCESS) {
262         rc = g_wpaObj->P2pSetListenChannel(g_wpaObj, "p2p-dev-wlan0", channel, 1);
263         ASSERT_EQ(rc, HDF_FAILURE);
264         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
265         ASSERT_EQ(rc, HDF_SUCCESS);
266     }
267 }
268 
269 HWTEST_F(HdfP2pHostCTest, P2pProvisionDiscoveryTest_017, TestSize.Level1)
270 {
271     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
272     ASSERT_EQ(rc, HDF_SUCCESS);
273     if (rc == HDF_SUCCESS) {
274         rc = g_wpaObj->P2pProvisionDiscovery(g_wpaObj, "p2p-dev-wlan0", "00:00:00:00:00:00", 0);
275         ASSERT_EQ(rc, HDF_FAILURE);
276         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
277         ASSERT_EQ(rc, HDF_SUCCESS);
278     }
279 }
280 
281 HWTEST_F(HdfP2pHostCTest, P2pAddGroupTest_018, TestSize.Level1)
282 {
283     int networkId = 1;
284     const int freq = 5220;
285     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
286     ASSERT_EQ(rc, HDF_SUCCESS);
287     if (rc == HDF_SUCCESS) {
288         rc = g_wpaObj->P2pAddGroup(g_wpaObj, "p2p-dev-wlan0", 0, networkId, freq);
289         ASSERT_EQ(rc, HDF_SUCCESS);
290         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
291         ASSERT_EQ(rc, HDF_SUCCESS);
292     }
293 }
294 
295 HWTEST_F(HdfP2pHostCTest, P2pAddServiceTest_019, TestSize.Level1)
296 {
297     struct HdiP2pServiceInfo info;
298     (void)memset_s(
299         &info, sizeof(struct HdiP2pServiceInfo), 0, sizeof(struct HdiP2pServiceInfo));
300     info.mode = 0;
301     info.version = 0;
302     const int nameLen = 32;
303     info.nameLen = nameLen;
304     info.name = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * nameLen);
305     strcpy_s((char *)info.name, sizeof(info.name), "p2p0");
306     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
307     ASSERT_EQ(rc, HDF_SUCCESS);
308     if (rc == HDF_SUCCESS) {
309         rc = g_wpaObj->P2pAddService(g_wpaObj, "p2p-dev-wlan0", &info);
310         ASSERT_EQ(rc, HDF_FAILURE);
311         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
312         ASSERT_EQ(rc, HDF_SUCCESS);
313     }
314     OsalMemFree(info.name);
315 }
316 
317 HWTEST_F(HdfP2pHostCTest, P2pRemoveServiceTest_020, TestSize.Level1)
318 {
319     struct HdiP2pServiceInfo info;
320     (void)memset_s(
321         &info, sizeof(struct HdiP2pServiceInfo), 0, sizeof(struct HdiP2pServiceInfo));
322 
323     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
324     ASSERT_EQ(rc, HDF_SUCCESS);
325     if (rc == HDF_SUCCESS) {
326         rc = g_wpaObj->P2pRemoveService(g_wpaObj, "p2p-dev-wlan0", &info);
327         ASSERT_EQ(rc, HDF_FAILURE);
328         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
329         ASSERT_EQ(rc, HDF_SUCCESS);
330     }
331 }
332 
333 HWTEST_F(HdfP2pHostCTest, P2pStopFindTest_021, TestSize.Level1)
334 {
335     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
336     ASSERT_EQ(rc, HDF_SUCCESS);
337     if (rc == HDF_SUCCESS) {
338         rc = g_wpaObj->P2pStopFind(g_wpaObj, "p2p-dev-wlan0");
339         ASSERT_EQ(rc, HDF_SUCCESS);
340         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
341         ASSERT_EQ(rc, HDF_SUCCESS);
342     }
343 }
344 
345 HWTEST_F(HdfP2pHostCTest, P2pFlushTest_022, TestSize.Level1)
346 {
347     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
348     ASSERT_EQ(rc, HDF_SUCCESS);
349     if (rc == HDF_SUCCESS) {
350         rc = g_wpaObj->P2pFlush(g_wpaObj, "p2p-dev-wlan0");
351         ASSERT_EQ(rc, HDF_SUCCESS);
352         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
353         ASSERT_EQ(rc, HDF_SUCCESS);
354     }
355 }
356 
357 HWTEST_F(HdfP2pHostCTest, P2pFlushServiceTest_023, TestSize.Level1)
358 {
359     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
360     ASSERT_EQ(rc, HDF_SUCCESS);
361     if (rc == HDF_SUCCESS) {
362         rc = g_wpaObj->P2pFlushService(g_wpaObj, "p2p-dev-wlan0");
363         ASSERT_EQ(rc, HDF_SUCCESS);
364         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
365         ASSERT_EQ(rc, HDF_SUCCESS);
366     }
367 }
368 
369 HWTEST_F(HdfP2pHostCTest, P2pRemoveNetworkTest_024, TestSize.Level1)
370 {
371     int networkId = -1;
372     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
373     ASSERT_EQ(rc, HDF_SUCCESS);
374     if (rc == HDF_SUCCESS) {
375         rc = g_wpaObj->P2pRemoveNetwork(g_wpaObj, "p2p-dev-wlan0", networkId);
376         ASSERT_EQ(rc, HDF_SUCCESS);
377         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
378         ASSERT_EQ(rc, HDF_SUCCESS);
379     }
380 }
381 
382 HWTEST_F(HdfP2pHostCTest, P2pSetGroupConfigTest_025, TestSize.Level1)
383 {
384     int networkId = 1;
385     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
386     ASSERT_EQ(rc, HDF_SUCCESS);
387     if (rc == HDF_SUCCESS) {
388         rc = g_wpaObj->P2pSetGroupConfig(g_wpaObj, "p2p-dev-wlan0", networkId, "test_name", "test_value");
389         ASSERT_EQ(rc, HDF_FAILURE);
390         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
391         ASSERT_EQ(rc, HDF_SUCCESS);
392     }
393 }
394 
395 HWTEST_F(HdfP2pHostCTest, P2pInviteTest_026, TestSize.Level1)
396 {
397     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
398     ASSERT_EQ(rc, HDF_SUCCESS);
399     if (rc == HDF_SUCCESS) {
400         rc = g_wpaObj->P2pInvite(g_wpaObj, "p2p-dev-wlan0", "00:00:00:00:00:00", "11:11:11:11:11:11");
401         ASSERT_EQ(rc, HDF_FAILURE);
402         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
403         ASSERT_EQ(rc, HDF_SUCCESS);
404     }
405 }
406 
407 HWTEST_F(HdfP2pHostCTest, P2pReinvokeTest_027, TestSize.Level1)
408 {
409     int networkId = 1;
410     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
411     ASSERT_EQ(rc, HDF_SUCCESS);
412     if (rc == HDF_SUCCESS) {
413         rc = g_wpaObj->P2pReinvoke(g_wpaObj, "p2p-dev-wlan0", networkId, "00:00:00:00:00:00");
414         ASSERT_EQ(rc, HDF_FAILURE);
415         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
416         ASSERT_EQ(rc, HDF_SUCCESS);
417     }
418 }
419 
420 HWTEST_F(HdfP2pHostCTest, P2pGetDeviceAddressTest_028, TestSize.Level1)
421 {
422     char *deviceAddress = (char *)calloc(WPA_CMD_BUF_LEN, sizeof(char));
423     uint32_t deviceAddressLen = WPA_CMD_BUF_LEN;
424     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
425     ASSERT_EQ(rc, HDF_SUCCESS);
426     if (rc == HDF_SUCCESS) {
427         rc = g_wpaObj->P2pGetDeviceAddress(g_wpaObj, "p2p-dev-wlan0", deviceAddress, deviceAddressLen);
428         printf("deviceAddress: %s", deviceAddress);
429         ASSERT_EQ(rc, HDF_SUCCESS);
430         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
431         ASSERT_EQ(rc, HDF_SUCCESS);
432     }
433     free(deviceAddress);
434 }
435 
436 HWTEST_F(HdfP2pHostCTest, P2pReqServiceDiscoveryTest_029, TestSize.Level1)
437 {
438     char *replyDisc = (char *)calloc(REPLY_SIZE, sizeof(char));
439     uint32_t replyDiscLen = REPLY_SIZE;
440     struct HdiP2pReqService reqService;
441     (void)memset_s(
442         &reqService, sizeof(struct HdiP2pReqService), 0, sizeof(struct HdiP2pReqService));
443     reqService.bssidLen = ETH_ADDR_LEN;
444     reqService.bssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (reqService.bssidLen));
445     reqService.bssid[0] = 0x12;
446     reqService.bssid[1] = 0x34;
447     reqService.bssid[2] = 0x56;
448     reqService.bssid[3] = 0x78;
449     reqService.bssid[4] = 0xab;
450     reqService.bssid[5] = 0xcd;
451 
452     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
453     ASSERT_EQ(rc, HDF_SUCCESS);
454     if (rc == HDF_SUCCESS) {
455         rc = g_wpaObj->P2pReqServiceDiscovery(g_wpaObj, "p2p-dev-wlan0", &reqService, replyDisc, replyDiscLen);
456         ASSERT_EQ(rc, HDF_FAILURE);
457         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
458         ASSERT_EQ(rc, HDF_SUCCESS);
459     }
460     free(replyDisc);
461     OsalMemFree(reqService.bssid);
462 }
463 
464 HWTEST_F(HdfP2pHostCTest, P2pCancelServiceDiscoveryTest_030, TestSize.Level1)
465 {
466     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
467     ASSERT_EQ(rc, HDF_SUCCESS);
468     if (rc == HDF_SUCCESS) {
469         rc = g_wpaObj->P2pCancelServiceDiscovery(g_wpaObj, "p2p-dev-wlan0", "test");
470         ASSERT_EQ(rc, HDF_FAILURE);
471         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
472         ASSERT_EQ(rc, HDF_SUCCESS);
473     }
474 }
475 
476 HWTEST_F(HdfP2pHostCTest, P2pRespServerDiscoveryTest_031, TestSize.Level1)
477 {
478     struct HdiP2pServDiscReqInfo info;
479     (void)memset_s(
480         &info, sizeof(struct HdiP2pServDiscReqInfo), 0, sizeof(struct HdiP2pServDiscReqInfo));
481     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
482     ASSERT_EQ(rc, HDF_SUCCESS);
483     if (rc == HDF_SUCCESS) {
484         rc = g_wpaObj->P2pRespServerDiscovery(g_wpaObj, "p2p-dev-wlan0", &info);
485         ASSERT_EQ(rc, HDF_FAILURE);
486         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
487         ASSERT_EQ(rc, HDF_SUCCESS);
488     }
489 }
490 
491 HWTEST_F(HdfP2pHostCTest, P2pConnectTest_032, TestSize.Level1)
492 {
493     struct HdiP2pConnectInfo info;
494     (void)memset_s(
495         &info, sizeof(struct HdiP2pConnectInfo), 0, sizeof(struct HdiP2pConnectInfo));
496     char *replyPin = (char *)calloc(REPLY_SIZE, sizeof(char));
497     uint32_t replyPinLen = REPLY_SIZE;
498 
499     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
500     ASSERT_EQ(rc, HDF_SUCCESS);
501     if (rc == HDF_SUCCESS) {
502         rc = g_wpaObj->P2pConnect(g_wpaObj, "p2p-dev-wlan0", &info, replyPin, replyPinLen);
503         ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
504         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
505         ASSERT_EQ(rc, HDF_SUCCESS);
506     }
507     free(replyPin);
508 }
509 
510 HWTEST_F(HdfP2pHostCTest, P2pHid2dConnectTest_033, TestSize.Level1)
511 {
512     struct HdiHid2dConnectInfo info;
513     (void)memset_s(
514         &info, sizeof(struct HdiHid2dConnectInfo), 0, sizeof(struct HdiHid2dConnectInfo));
515 
516     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
517     ASSERT_EQ(rc, HDF_SUCCESS);
518     if (rc == HDF_SUCCESS) {
519         rc = g_wpaObj->P2pHid2dConnect(g_wpaObj, "p2p-dev-wlan0", &info);
520         ASSERT_EQ(rc, HDF_FAILURE);
521         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
522         ASSERT_EQ(rc, HDF_SUCCESS);
523     }
524 }
525 
526 HWTEST_F(HdfP2pHostCTest, P2pSetServDiscExternalTest_034, TestSize.Level1)
527 {
528     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
529     ASSERT_EQ(rc, HDF_SUCCESS);
530     if (rc == HDF_SUCCESS) {
531         rc = g_wpaObj->P2pSetServDiscExternal(g_wpaObj, "p2p-dev-wlan0", 0);
532         ASSERT_EQ(rc, HDF_SUCCESS);
533         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
534         ASSERT_EQ(rc, HDF_SUCCESS);
535     }
536 }
537 
538 HWTEST_F(HdfP2pHostCTest, P2pRemoveGroupTest_035, TestSize.Level1)
539 {
540     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
541     ASSERT_EQ(rc, HDF_SUCCESS);
542     if (rc == HDF_SUCCESS) {
543         rc = g_wpaObj->P2pRemoveGroup(g_wpaObj, "p2p-dev-wlan0", "test");
544         ASSERT_EQ(rc, HDF_SUCCESS);
545         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
546         ASSERT_EQ(rc, HDF_SUCCESS);
547     }
548 }
549 
550 HWTEST_F(HdfP2pHostCTest, P2pCancelConnectTest_036, TestSize.Level1)
551 {
552     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
553     ASSERT_EQ(rc, HDF_SUCCESS);
554     if (rc == HDF_SUCCESS) {
555         rc = g_wpaObj->P2pCancelConnect(g_wpaObj, "p2p-dev-wlan0");
556         ASSERT_EQ(rc, HDF_FAILURE);
557         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
558         ASSERT_EQ(rc, HDF_SUCCESS);
559     }
560 }
561 
562 HWTEST_F(HdfP2pHostCTest, P2pGetGroupConfigTest_037, TestSize.Level1)
563 {
564     int networkId = 1;
565     char *value = (char *)calloc(REPLY_SIZE, sizeof(char));
566     uint32_t valueLen = REPLY_SIZE;
567     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
568     ASSERT_EQ(rc, HDF_SUCCESS);
569     if (rc == HDF_SUCCESS) {
570         rc = g_wpaObj->P2pGetGroupConfig(g_wpaObj, "p2p-dev-wlan0", networkId, "ssid", value, valueLen);
571         ASSERT_EQ(rc, HDF_FAILURE);
572         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
573         ASSERT_EQ(rc, HDF_SUCCESS);
574     }
575     free(value);
576 }
577 
578 HWTEST_F(HdfP2pHostCTest, P2pAddNetworkTest_038, TestSize.Level1)
579 {
580     int networkId = 0;
581     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
582     ASSERT_EQ(rc, HDF_SUCCESS);
583     if (rc == HDF_SUCCESS) {
584         rc = g_wpaObj->P2pAddNetwork(g_wpaObj, "p2p-dev-wlan0", &networkId);
585         ASSERT_EQ(rc, HDF_SUCCESS);
586         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
587         ASSERT_EQ(rc, HDF_SUCCESS);
588     }
589 }
590 
591 HWTEST_F(HdfP2pHostCTest, P2pGetPeerTest_039, TestSize.Level1)
592 {
593     struct HdiP2pDeviceInfo info;
594     (void)memset_s(
595         &info, sizeof(struct HdiP2pDeviceInfo), 0, sizeof(struct HdiP2pDeviceInfo));
596 
597     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
598     ASSERT_EQ(rc, HDF_SUCCESS);
599     if (rc == HDF_SUCCESS) {
600         rc = g_wpaObj->P2pGetPeer(g_wpaObj, "p2p-dev-wlan0", "00:00:00:00:00:00", &info);
601         ASSERT_EQ(rc, HDF_FAILURE);
602         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
603         ASSERT_EQ(rc, HDF_SUCCESS);
604     }
605 }
606 
607 HWTEST_F(HdfP2pHostCTest, P2pGetGroupCapabilityTest_040, TestSize.Level1)
608 {
609     int cap = 0;
610     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
611     ASSERT_EQ(rc, HDF_SUCCESS);
612     if (rc == HDF_SUCCESS) {
613         rc = g_wpaObj->P2pGetGroupCapability(g_wpaObj, "p2p-dev-wlan0", "00:00:00:00:00:00", &cap);
614         ASSERT_EQ(rc, HDF_FAILURE);
615         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
616         ASSERT_EQ(rc, HDF_SUCCESS);
617     }
618 }
619 
620 HWTEST_F(HdfP2pHostCTest, P2pListNetworksTest_041, TestSize.Level1)
621 {
622     struct HdiP2pNetworkList infoList;
623     (void)memset_s(
624         &infoList, sizeof(struct HdiP2pNetworkList), 0, sizeof(struct HdiP2pNetworkList));
625 
626     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
627     ASSERT_EQ(rc, HDF_SUCCESS);
628     if (rc == HDF_SUCCESS) {
629         rc = g_wpaObj->P2pListNetworks(g_wpaObj, "p2p-dev-wlan0", &infoList);
630         ASSERT_EQ(rc, HDF_SUCCESS);
631         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
632         ASSERT_EQ(rc, HDF_SUCCESS);
633     }
634 }
635 
636 HWTEST_F(HdfP2pHostCTest, P2pSaveConfigTest_042, TestSize.Level1)
637 {
638     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
639     ASSERT_EQ(rc, HDF_SUCCESS);
640     if (rc == HDF_SUCCESS) {
641         rc = g_wpaObj->P2pSaveConfig(g_wpaObj, "p2p-dev-wlan0");
642         ASSERT_EQ(rc, HDF_SUCCESS);
643         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
644         ASSERT_EQ(rc, HDF_SUCCESS);
645     }
646 }
647 
648 HWTEST_F(HdfP2pHostCTest, VendorProcessCmdTest_043, TestSize.Level1)
649 {
650     int32_t rc = g_wpaObj->AddWpaIface(g_wpaObj, IFNAME, CONFNAME);
651     ASSERT_EQ(rc, HDF_SUCCESS);
652     if (rc == HDF_SUCCESS) {
653         rc = g_wpaObj->VendorProcessCmd(g_wpaObj, IFNAME, "test");
654         ASSERT_EQ(rc, HDF_FAILURE);
655         rc = g_wpaObj->RemoveWpaIface(g_wpaObj, IFNAME);
656         ASSERT_EQ(rc, HDF_SUCCESS);
657     }
658 }
659 
660 };
661