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 "p2p-dev-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 HdiP2pDirectTest {
29 const char *g_wlanServiceNameP2p = "wpa_interface_service";
30 
31 class HdfP2pHostDirectTest : 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 HdfP2pHostDirectTest::SetUpTestCase()
42 {
43     g_wpaObj = IWpaInterfaceGetInstance(g_wlanServiceNameP2p, true);
44     g_wpaCallbackObj = P2pCallbackServiceGet();
45     ASSERT_TRUE(g_wpaObj != nullptr);
46     ASSERT_TRUE(g_wpaCallbackObj != nullptr);
47 }
48 
TearDownTestCase()49 void HdfP2pHostDirectTest::TearDownTestCase()
50 {
51     IWpaInterfaceReleaseInstance(g_wlanServiceNameP2p, g_wpaObj, true);
52     P2pCallbackServiceRelease(g_wpaCallbackObj);
53 }
54 
SetUp()55 void HdfP2pHostDirectTest::SetUp()
56 {
57 }
58 
TearDown()59 void HdfP2pHostDirectTest::TearDown()
60 {
61 }
62 
63 HWTEST_F(HdfP2pHostDirectTest, P2pSetSsidPostfixNameTest_001, TestSize.Level1)
64 {
65     int32_t rc = g_wpaObj->P2pSetSsidPostfixName(g_wpaObj, nullptr, "test");
66     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
67     rc = g_wpaObj->P2pSetSsidPostfixName(g_wpaObj, IFNAME, nullptr);
68     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
69     rc = g_wpaObj->P2pSetSsidPostfixName(g_wpaObj, IFNAME, "test");
70     ASSERT_EQ(rc, HDF_FAILURE);
71 }
72 
73 HWTEST_F(HdfP2pHostDirectTest, P2pSetWpsDeviceTypeTest_002, TestSize.Level1)
74 {
75     int32_t rc = g_wpaObj->P2pSetWpsDeviceType(g_wpaObj, nullptr, "test");
76     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
77     rc = g_wpaObj->P2pSetWpsDeviceType(g_wpaObj, IFNAME, nullptr);
78     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
79     rc = g_wpaObj->P2pSetWpsDeviceType(g_wpaObj, IFNAME, "test");
80     ASSERT_EQ(rc, HDF_FAILURE);
81 }
82 
83 HWTEST_F(HdfP2pHostDirectTest, P2pSetWpsConfigMethodsTest_003, TestSize.Level1)
84 {
85     int32_t rc = g_wpaObj->P2pSetWpsConfigMethods(g_wpaObj, nullptr, "test");
86     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
87     rc = g_wpaObj->P2pSetWpsConfigMethods(g_wpaObj, IFNAME, nullptr);
88     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
89     rc = g_wpaObj->P2pSetWpsConfigMethods(g_wpaObj, IFNAME, "test");
90     ASSERT_EQ(rc, HDF_FAILURE);
91 }
92 
93 HWTEST_F(HdfP2pHostDirectTest, P2pSetGroupMaxIdleTest_004, TestSize.Level1)
94 {
95     int32_t rc = g_wpaObj->P2pSetGroupMaxIdle(g_wpaObj, nullptr, 1);
96     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
97     rc = g_wpaObj->P2pSetGroupMaxIdle(g_wpaObj, IFNAME, 1);
98     ASSERT_EQ(rc, HDF_FAILURE);
99 }
100 
101 HWTEST_F(HdfP2pHostDirectTest, P2pSetWfdEnableTest_005, TestSize.Level1)
102 {
103     int32_t rc = g_wpaObj->P2pSetWfdEnable(g_wpaObj, nullptr, 1);
104     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
105     rc = g_wpaObj->P2pSetWfdEnable(g_wpaObj, IFNAME, 1);
106     ASSERT_EQ(rc, HDF_FAILURE);
107 }
108 
109 HWTEST_F(HdfP2pHostDirectTest, P2pSetPersistentReconnectTest_006, TestSize.Level1)
110 {
111     int32_t rc = g_wpaObj->P2pSetPersistentReconnect(g_wpaObj, nullptr, 1);
112     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
113     rc = g_wpaObj->P2pSetPersistentReconnect(g_wpaObj, IFNAME, 1);
114     ASSERT_EQ(rc, HDF_FAILURE);
115 }
116 
117 HWTEST_F(HdfP2pHostDirectTest, P2pSetWpsSecondaryDeviceTypeTest_007, TestSize.Level1)
118 {
119     int32_t rc = g_wpaObj->P2pSetWpsSecondaryDeviceType(g_wpaObj, nullptr, "test");
120     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
121     rc = g_wpaObj->P2pSetWpsSecondaryDeviceType(g_wpaObj, IFNAME, nullptr);
122     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
123     rc = g_wpaObj->P2pSetWpsSecondaryDeviceType(g_wpaObj, IFNAME, "test");
124     ASSERT_EQ(rc, HDF_FAILURE);
125 }
126 
127 HWTEST_F(HdfP2pHostDirectTest, P2pSetupWpsPbcTest_008, TestSize.Level1)
128 {
129     int32_t rc = g_wpaObj->P2pSetupWpsPbc(g_wpaObj, nullptr, "00:00:00:00:00:00");
130     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
131     rc = g_wpaObj->P2pSetupWpsPbc(g_wpaObj, IFNAME, nullptr);
132     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
133     rc = g_wpaObj->P2pSetupWpsPbc(g_wpaObj, IFNAME, "00:00:00:00:00:00");
134     ASSERT_EQ(rc, HDF_FAILURE);
135 }
136 
137 HWTEST_F(HdfP2pHostDirectTest, P2pSetupWpsPinTest_009, TestSize.Level1)
138 {
139     const char *pin = "00000000";
140     char *resultBuf = (char *)calloc(REPLY_SIZE, sizeof(char));
141     uint32_t resultBufLen = REPLY_SIZE;
142     int32_t rc = g_wpaObj->P2pSetupWpsPin(g_wpaObj, nullptr, "00:00:00:00:00:00", pin, resultBuf, resultBufLen);
143     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
144     rc = g_wpaObj->P2pSetupWpsPin(g_wpaObj, IFNAME, "00:00:00:00:00:00", pin, nullptr, resultBufLen);
145     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
146     rc = g_wpaObj->P2pSetupWpsPin(g_wpaObj, IFNAME, "00:00:00:00:00:00", pin, resultBuf, resultBufLen);
147     ASSERT_EQ(rc, HDF_FAILURE);
148     free(resultBuf);
149 }
150 
151 HWTEST_F(HdfP2pHostDirectTest, P2pSetPowerSaveTest_010, TestSize.Level1)
152 {
153     int32_t rc = g_wpaObj->P2pSetPowerSave(g_wpaObj, nullptr, 1);
154     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
155     rc = g_wpaObj->P2pSetPowerSave(g_wpaObj, IFNAME, 1);
156     ASSERT_EQ(rc, HDF_FAILURE);
157 }
158 
159 HWTEST_F(HdfP2pHostDirectTest, P2pSetDeviceNameTest_011, TestSize.Level1)
160 {
161     int32_t rc = g_wpaObj->P2pSetDeviceName(g_wpaObj, nullptr, "test");
162     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
163     rc = g_wpaObj->P2pSetDeviceName(g_wpaObj, IFNAME, nullptr);
164     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
165     rc = g_wpaObj->P2pSetDeviceName(g_wpaObj, IFNAME, "test");
166     ASSERT_EQ(rc, HDF_FAILURE);
167 }
168 
169 HWTEST_F(HdfP2pHostDirectTest, P2pSetWfdDeviceConfigTest_012, TestSize.Level1)
170 {
171     int32_t rc = g_wpaObj->P2pSetWfdDeviceConfig(g_wpaObj, nullptr, "test");
172     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
173     rc = g_wpaObj->P2pSetWfdDeviceConfig(g_wpaObj, IFNAME, nullptr);
174     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
175     rc = g_wpaObj->P2pSetWfdDeviceConfig(g_wpaObj, IFNAME, "test");
176     ASSERT_EQ(rc, HDF_FAILURE);
177 }
178 
179 HWTEST_F(HdfP2pHostDirectTest, P2pSetRandomMacTest_013, TestSize.Level1)
180 {
181     int networkId = 1;
182     int32_t rc = g_wpaObj->P2pSetRandomMac(g_wpaObj, nullptr, networkId);
183     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
184     rc = g_wpaObj->P2pSetRandomMac(g_wpaObj, IFNAME, networkId);
185     ASSERT_EQ(rc, HDF_FAILURE);
186 }
187 
188 HWTEST_F(HdfP2pHostDirectTest, P2pStartFindTest_014, TestSize.Level1)
189 {
190     const int time = 120;
191     int32_t rc = g_wpaObj->P2pSetRandomMac(g_wpaObj, nullptr, time);
192     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
193     rc = g_wpaObj->P2pSetRandomMac(g_wpaObj, IFNAME, time);
194     ASSERT_EQ(rc, HDF_FAILURE);
195 }
196 
197 HWTEST_F(HdfP2pHostDirectTest, P2pSetExtListenTest_015, TestSize.Level1)
198 {
199     int32_t rc = g_wpaObj->P2pSetExtListen(g_wpaObj, nullptr, 0, 1, 1);
200     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
201     rc = g_wpaObj->P2pSetExtListen(g_wpaObj, IFNAME, 0, 1, 1);
202     ASSERT_EQ(rc, HDF_FAILURE);
203 }
204 
205 HWTEST_F(HdfP2pHostDirectTest, P2pSetListenChannelTest_016, TestSize.Level1)
206 {
207     const int channel = 44;
208     int32_t rc = g_wpaObj->P2pSetListenChannel(g_wpaObj, nullptr, channel, 0);
209     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
210     rc = g_wpaObj->P2pSetListenChannel(g_wpaObj, IFNAME, channel, 0);
211     ASSERT_EQ(rc, HDF_FAILURE);
212 }
213 
214 HWTEST_F(HdfP2pHostDirectTest, P2pProvisionDiscoveryTest_017, TestSize.Level1)
215 {
216     int32_t rc = g_wpaObj->P2pProvisionDiscovery(g_wpaObj, nullptr, "00:00:00:00:00:00", 0);
217     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
218     rc = g_wpaObj->P2pProvisionDiscovery(g_wpaObj, IFNAME, nullptr, 0);
219     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
220     rc = g_wpaObj->P2pProvisionDiscovery(g_wpaObj, IFNAME, "00:00:00:00:00:00", 0);
221     ASSERT_EQ(rc, HDF_FAILURE);
222 }
223 
224 HWTEST_F(HdfP2pHostDirectTest, P2pAddGroupTest_018, TestSize.Level1)
225 {
226     int networkId = 1;
227     const int freq = 5220;
228     int32_t rc = g_wpaObj->P2pAddGroup(g_wpaObj, nullptr, 0, networkId, freq);
229     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
230     rc = g_wpaObj->P2pAddGroup(g_wpaObj, IFNAME, 0, networkId, freq);
231     ASSERT_EQ(rc, HDF_FAILURE);
232 }
233 
234 HWTEST_F(HdfP2pHostDirectTest, P2pAddServiceTest_019, TestSize.Level1)
235 {
236     struct HdiP2pServiceInfo info;
237     (void)memset_s(
238         &info, sizeof(struct HdiP2pServiceInfo), 0, sizeof(struct HdiP2pServiceInfo));
239     int32_t rc = g_wpaObj->P2pAddService(g_wpaObj, IFNAME, nullptr);
240     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
241     rc = g_wpaObj->P2pAddService(g_wpaObj, nullptr, &info);
242     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
243     rc = g_wpaObj->P2pAddService(g_wpaObj, IFNAME, &info);
244     ASSERT_EQ(rc, HDF_FAILURE);
245 }
246 
247 HWTEST_F(HdfP2pHostDirectTest, P2pRemoveServiceTest_020, TestSize.Level1)
248 {
249     struct HdiP2pServiceInfo info;
250     (void)memset_s(
251         &info, sizeof(struct HdiP2pServiceInfo), 0, sizeof(struct HdiP2pServiceInfo));
252 
253     int32_t rc = g_wpaObj->P2pRemoveService(g_wpaObj, IFNAME, nullptr);
254     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
255     rc = g_wpaObj->P2pRemoveService(g_wpaObj, nullptr, &info);
256     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
257     rc = g_wpaObj->P2pRemoveService(g_wpaObj, IFNAME, &info);
258     ASSERT_EQ(rc, HDF_FAILURE);
259 }
260 
261 HWTEST_F(HdfP2pHostDirectTest, P2pStopFindTest_021, TestSize.Level1)
262 {
263     int32_t rc = g_wpaObj->P2pStopFind(g_wpaObj, nullptr);
264     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
265     rc = g_wpaObj->P2pStopFind(g_wpaObj, IFNAME);
266     ASSERT_EQ(rc, HDF_FAILURE);
267 }
268 
269 HWTEST_F(HdfP2pHostDirectTest, P2pFlushTest_022, TestSize.Level1)
270 {
271     int32_t rc = g_wpaObj->P2pFlush(g_wpaObj, nullptr);
272     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
273     rc = g_wpaObj->P2pFlush(g_wpaObj, IFNAME);
274     ASSERT_EQ(rc, HDF_FAILURE);
275 }
276 
277 HWTEST_F(HdfP2pHostDirectTest, P2pFlushServiceTest_023, TestSize.Level1)
278 {
279     int32_t rc = g_wpaObj->P2pFlushService(g_wpaObj, nullptr);
280     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
281     rc = g_wpaObj->P2pFlushService(g_wpaObj, IFNAME);
282     ASSERT_EQ(rc, HDF_FAILURE);
283 }
284 
285 HWTEST_F(HdfP2pHostDirectTest, P2pRemoveNetworkTest_024, TestSize.Level1)
286 {
287     int networkId = 1;
288     int32_t rc = g_wpaObj->P2pRemoveNetwork(g_wpaObj, nullptr, networkId);
289     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
290     rc = g_wpaObj->P2pRemoveNetwork(g_wpaObj, IFNAME, networkId);
291     ASSERT_EQ(rc, HDF_FAILURE);
292 }
293 
294 HWTEST_F(HdfP2pHostDirectTest, P2pSetGroupConfigTest_025, TestSize.Level1)
295 {
296     int networkId = 1;
297     int32_t rc = g_wpaObj->P2pSetGroupConfig(g_wpaObj, nullptr, networkId, "test_name", "test_value");
298     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
299     rc = g_wpaObj->P2pSetGroupConfig(g_wpaObj, IFNAME, networkId, nullptr, "test_value");
300     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
301     rc = g_wpaObj->P2pSetGroupConfig(g_wpaObj, IFNAME, networkId, "test_name", nullptr);
302     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
303     rc = g_wpaObj->P2pSetGroupConfig(g_wpaObj, IFNAME, networkId, "test_name", "test_value");
304     ASSERT_EQ(rc, HDF_FAILURE);
305 }
306 
307 HWTEST_F(HdfP2pHostDirectTest, P2pInviteTest_026, TestSize.Level1)
308 {
309     int32_t rc = g_wpaObj->P2pInvite(g_wpaObj, nullptr, "00:00:00:00:00:00", "11:11:11:11:11:11");
310     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
311     rc = g_wpaObj->P2pInvite(g_wpaObj, IFNAME, nullptr, "11:11:11:11:11:11");
312     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
313     rc = g_wpaObj->P2pInvite(g_wpaObj, IFNAME, "00:00:00:00:00:00", nullptr);
314     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
315     rc = g_wpaObj->P2pInvite(g_wpaObj, IFNAME, "00:00:00:00:00:00", "11:11:11:11:11:11");
316     ASSERT_EQ(rc, HDF_FAILURE);
317 }
318 
319 HWTEST_F(HdfP2pHostDirectTest, P2pReinvokeTest_027, TestSize.Level1)
320 {
321     int networkId = 1;
322     int32_t rc = g_wpaObj->P2pReinvoke(g_wpaObj, nullptr, networkId, "00:00:00:00:00:00");
323     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
324     rc = g_wpaObj->P2pReinvoke(g_wpaObj, IFNAME, networkId, nullptr);
325     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
326     rc = g_wpaObj->P2pReinvoke(g_wpaObj, IFNAME, networkId, "00:00:00:00:00:00");
327     ASSERT_EQ(rc, HDF_FAILURE);
328 }
329 
330 HWTEST_F(HdfP2pHostDirectTest, P2pGetDeviceAddressTest_028, TestSize.Level1)
331 {
332     char *deviceAddress = (char *)calloc(WPA_CMD_BUF_LEN, sizeof(char));
333     uint32_t deviceAddressLen = WPA_CMD_BUF_LEN;
334     int32_t rc = g_wpaObj->P2pGetDeviceAddress(g_wpaObj, nullptr, deviceAddress, deviceAddressLen);
335     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
336     rc = g_wpaObj->P2pGetDeviceAddress(g_wpaObj, IFNAME, nullptr, deviceAddressLen);
337     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
338     rc = g_wpaObj->P2pGetDeviceAddress(g_wpaObj, IFNAME, deviceAddress, deviceAddressLen);
339     ASSERT_EQ(rc, HDF_FAILURE);
340     free(deviceAddress);
341 }
342 
343 HWTEST_F(HdfP2pHostDirectTest, P2pReqServiceDiscoveryTest_029, TestSize.Level1)
344 {
345     char *replyDisc = (char *)calloc(REPLY_SIZE, sizeof(char));
346     uint32_t replyDiscLen = REPLY_SIZE;
347     struct HdiP2pReqService reqService;
348     (void)memset_s(
349         &reqService, sizeof(struct HdiP2pReqService), 0, sizeof(struct HdiP2pReqService));
350 
351     int32_t rc = g_wpaObj->P2pReqServiceDiscovery(g_wpaObj, nullptr, &reqService, replyDisc, replyDiscLen);
352     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
353     rc = g_wpaObj->P2pReqServiceDiscovery(g_wpaObj, IFNAME, nullptr, replyDisc, replyDiscLen);
354     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
355     rc = g_wpaObj->P2pReqServiceDiscovery(g_wpaObj, IFNAME, &reqService, nullptr, replyDiscLen);
356     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
357     rc = g_wpaObj->P2pReqServiceDiscovery(g_wpaObj, IFNAME, &reqService, replyDisc, replyDiscLen);
358     ASSERT_EQ(rc, HDF_FAILURE);
359     free(replyDisc);
360 }
361 
362 HWTEST_F(HdfP2pHostDirectTest, P2pCancelServiceDiscoveryTest_030, TestSize.Level1)
363 {
364     int32_t rc = g_wpaObj->P2pCancelServiceDiscovery(g_wpaObj, nullptr, "test");
365     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
366     rc = g_wpaObj->P2pCancelServiceDiscovery(g_wpaObj, IFNAME, nullptr);
367     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
368     rc = g_wpaObj->P2pCancelServiceDiscovery(g_wpaObj, IFNAME, "test");
369     ASSERT_EQ(rc, HDF_FAILURE);
370 }
371 
372 HWTEST_F(HdfP2pHostDirectTest, P2pRespServerDiscoveryTest_031, TestSize.Level1)
373 {
374     struct HdiP2pServDiscReqInfo info;
375     (void)memset_s(
376         &info, sizeof(struct HdiP2pServDiscReqInfo), 0, sizeof(struct HdiP2pServDiscReqInfo));
377     int32_t rc = g_wpaObj->P2pRespServerDiscovery(g_wpaObj, nullptr, &info);
378     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
379     rc = g_wpaObj->P2pRespServerDiscovery(g_wpaObj, IFNAME, nullptr);
380     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
381     rc = g_wpaObj->P2pRespServerDiscovery(g_wpaObj, IFNAME, &info);
382     ASSERT_EQ(rc, HDF_FAILURE);
383 }
384 
385 HWTEST_F(HdfP2pHostDirectTest, P2pConnectTest_032, TestSize.Level1)
386 {
387     struct HdiP2pConnectInfo info;
388     (void)memset_s(
389         &info, sizeof(struct HdiP2pConnectInfo), 0, sizeof(struct HdiP2pConnectInfo));
390     char *replyPin = (char *)calloc(REPLY_SIZE, sizeof(char));
391     uint32_t replyPinLen = REPLY_SIZE;
392 
393     int32_t rc = g_wpaObj->P2pConnect(g_wpaObj, nullptr, &info, replyPin, replyPinLen);
394     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
395     rc = g_wpaObj->P2pConnect(g_wpaObj, IFNAME, nullptr, replyPin, replyPinLen);
396     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
397     rc = g_wpaObj->P2pConnect(g_wpaObj, IFNAME, &info, nullptr, replyPinLen);
398     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
399     rc = g_wpaObj->P2pConnect(g_wpaObj, IFNAME, &info, replyPin, replyPinLen);
400     ASSERT_EQ(rc, HDF_FAILURE);
401     free(replyPin);
402 }
403 
404 HWTEST_F(HdfP2pHostDirectTest, P2pHid2dConnectTest_033, TestSize.Level1)
405 {
406     struct HdiHid2dConnectInfo info;
407     (void)memset_s(
408         &info, sizeof(struct HdiHid2dConnectInfo), 0, sizeof(struct HdiHid2dConnectInfo));
409     int32_t rc = g_wpaObj->P2pHid2dConnect(g_wpaObj, nullptr, &info);
410     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
411     rc = g_wpaObj->P2pHid2dConnect(g_wpaObj, IFNAME, nullptr);
412     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
413     rc = g_wpaObj->P2pHid2dConnect(g_wpaObj, IFNAME, &info);
414     ASSERT_EQ(rc, HDF_FAILURE);
415 }
416 
417 HWTEST_F(HdfP2pHostDirectTest, P2pSetServDiscExternalTest_034, TestSize.Level1)
418 {
419     int32_t rc = g_wpaObj->P2pSetServDiscExternal(g_wpaObj, nullptr, 0);
420     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
421     rc = g_wpaObj->P2pSetServDiscExternal(g_wpaObj, IFNAME, 0);
422     ASSERT_EQ(rc, HDF_FAILURE);
423 }
424 
425 HWTEST_F(HdfP2pHostDirectTest, P2pRemoveGroupTest_035, TestSize.Level1)
426 {
427     int32_t rc = g_wpaObj->P2pRemoveGroup(g_wpaObj, nullptr, "test");
428     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
429     rc = g_wpaObj->P2pRemoveGroup(g_wpaObj, IFNAME, nullptr);
430     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
431     rc = g_wpaObj->P2pRemoveGroup(g_wpaObj, IFNAME, "test");
432     ASSERT_EQ(rc, HDF_FAILURE);
433 }
434 
435 HWTEST_F(HdfP2pHostDirectTest, P2pCancelConnectTest_036, TestSize.Level1)
436 {
437     int32_t rc = g_wpaObj->P2pCancelConnect(g_wpaObj, nullptr);
438     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
439     rc = g_wpaObj->P2pCancelConnect(g_wpaObj, IFNAME);
440     ASSERT_EQ(rc, HDF_FAILURE);
441 }
442 
443 HWTEST_F(HdfP2pHostDirectTest, P2pGetGroupConfigTest_037, TestSize.Level1)
444 {
445     int networkId = 1;
446     char *value = (char *)calloc(REPLY_SIZE, sizeof(char));
447     uint32_t valueLen = REPLY_SIZE;
448 
449     int32_t rc = g_wpaObj->P2pGetGroupConfig(g_wpaObj, nullptr, networkId, "ssid", value, valueLen);
450     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
451     rc = g_wpaObj->P2pGetGroupConfig(g_wpaObj, IFNAME, networkId, nullptr, value, valueLen);
452     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
453     rc = g_wpaObj->P2pGetGroupConfig(g_wpaObj, IFNAME, networkId, "ssid", nullptr, valueLen);
454     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
455     rc = g_wpaObj->P2pGetGroupConfig(g_wpaObj, IFNAME, networkId, "ssid", value, valueLen);
456     ASSERT_EQ(rc, HDF_FAILURE);
457     free(value);
458 }
459 
460 HWTEST_F(HdfP2pHostDirectTest, P2pAddNetworkTest_038, TestSize.Level1)
461 {
462     int networkId = 0;
463     int32_t rc = g_wpaObj->P2pAddNetwork(g_wpaObj, nullptr, &networkId);
464     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
465     rc = g_wpaObj->P2pAddNetwork(g_wpaObj, IFNAME, nullptr);
466     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
467     rc = g_wpaObj->P2pAddNetwork(g_wpaObj, IFNAME, &networkId);
468     ASSERT_EQ(rc, HDF_FAILURE);
469 }
470 
471 HWTEST_F(HdfP2pHostDirectTest, P2pGetPeerTest_039, TestSize.Level1)
472 {
473     struct HdiP2pDeviceInfo info;
474     (void)memset_s(
475         &info, sizeof(struct HdiP2pDeviceInfo), 0, sizeof(struct HdiP2pDeviceInfo));
476     int32_t rc = g_wpaObj->P2pGetPeer(g_wpaObj, nullptr, "00:00:00:00:00:00", &info);
477     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
478     rc = g_wpaObj->P2pGetPeer(g_wpaObj, IFNAME, nullptr, &info);
479     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
480     rc = g_wpaObj->P2pGetPeer(g_wpaObj, IFNAME, "00:00:00:00:00:00", nullptr);
481     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
482     rc = g_wpaObj->P2pGetPeer(g_wpaObj, IFNAME, "00:00:00:00:00:00", &info);
483     ASSERT_EQ(rc, HDF_FAILURE);
484 }
485 
486 HWTEST_F(HdfP2pHostDirectTest, P2pGetGroupCapabilityTest_040, TestSize.Level1)
487 {
488     int cap = 0;
489     int32_t rc = g_wpaObj->P2pGetGroupCapability(g_wpaObj, nullptr, "00:00:00:00:00:00", &cap);
490     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
491     rc = g_wpaObj->P2pGetGroupCapability(g_wpaObj, IFNAME, nullptr, &cap);
492     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
493     rc = g_wpaObj->P2pGetGroupCapability(g_wpaObj, IFNAME, "00:00:00:00:00:00", nullptr);
494     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
495     rc = g_wpaObj->P2pGetGroupCapability(g_wpaObj, IFNAME, "00:00:00:00:00:00", &cap);
496     ASSERT_EQ(rc, HDF_FAILURE);
497 }
498 
499 HWTEST_F(HdfP2pHostDirectTest, P2pListNetworksTest_041, TestSize.Level1)
500 {
501     struct HdiP2pNetworkList infoList;
502     (void)memset_s(
503         &infoList, sizeof(struct HdiP2pNetworkList), 0, sizeof(struct HdiP2pNetworkList));
504 
505     int32_t rc = g_wpaObj->P2pListNetworks(g_wpaObj, nullptr, &infoList);
506     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
507     rc = g_wpaObj->P2pListNetworks(g_wpaObj, IFNAME, nullptr);
508     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
509     rc = g_wpaObj->P2pListNetworks(g_wpaObj, IFNAME, &infoList);
510     ASSERT_EQ(rc, HDF_FAILURE);
511 }
512 
513 HWTEST_F(HdfP2pHostDirectTest, P2pSaveConfigTest_042, TestSize.Level1)
514 {
515     int32_t rc = g_wpaObj->P2pSaveConfig(g_wpaObj, nullptr);
516     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
517     rc = g_wpaObj->P2pSaveConfig(g_wpaObj, IFNAME);
518     ASSERT_EQ(rc, HDF_FAILURE);
519 }
520 
521 HWTEST_F(HdfP2pHostDirectTest, VendorProcessCmdTest_043, TestSize.Level1)
522 {
523     int32_t rc = g_wpaObj->VendorProcessCmd(g_wpaObj, nullptr, nullptr);
524     ASSERT_EQ(rc, HDF_ERR_INVALID_PARAM);
525     rc = g_wpaObj->VendorProcessCmd(g_wpaObj, IFNAME, nullptr);
526     ASSERT_EQ(rc, HDF_FAILURE);
527 }
528 };
529 
530