1 /*
2  * Copyright (C) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include <cstddef>
16 #include <cstdint>
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 #include "securec.h"
20 #include "wifi_ap_hal_interface.h"
21 #include "wifi_ap_event_callback.h"
22 #include "wifi_event_callback.h"
23 #include "wifi_idl_inner_interface.h"
24 #include "wifi_p2p_hal_interface.h"
25 #include "wifi_sta_hal_interface.h"
26 #include "wifi_log.h"
27 
28 #undef LOG_TAG
29 #define LOG_TAG "WifiIdlInnerInterfaceTest"
30 using namespace testing::ext;
31 
32 namespace OHOS {
33 namespace Wifi {
34 constexpr int LENTH = 16;
35 constexpr int LENTH1 = 11;
36 
OnConnectChangedMock(int status,int networkId,const std::string & bssid)37 static void OnConnectChangedMock(int status, int networkId, const std::string &bssid)
38 {
39     LOGI("OnConnectChangedMock");
40 }
41 
OnBssidChangedMock(const std::string & reason,const std::string & bssid)42 static void OnBssidChangedMock(const std::string &reason, const std::string &bssid)
43 {
44     LOGI("OnBssidChangedMock");
45 }
46 
OnWpaStateChangedMock(int status)47 static void OnWpaStateChangedMock(int status)
48 {
49     LOGI("OnWpaStateChangedMock");
50 }
51 
OnWpaSsidWrongKeyMock()52 static void OnWpaSsidWrongKeyMock()
53 {
54     LOGI("OnWpaSsidWrongKeyMock");
55 }
56 
OnWpsOverlapMock(int status)57 static void OnWpsOverlapMock(int status)
58 {
59     LOGI("OnWpsOverlapMock");
60 }
61 
OnWpsTimeOutMock(int status)62 static void OnWpsTimeOutMock(int status)
63 {
64     LOGI("OnWpsTimeOutMock");
65 }
66 
OnWpaConnectionFullMock(int status)67 static void OnWpaConnectionFullMock(int status)
68 {
69     LOGI("OnWpaConnectionFullMock");
70 }
71 
OnWpaConnectionRejectMock(int status)72 static void OnWpaConnectionRejectMock(int status)
73 {
74     LOGI("OnWpaConnectionRejectMock");
75 }
76 
OnStaJoinOrLeaveMock(const WifiHalApConnectionNofify & info)77 static void OnStaJoinOrLeaveMock(const WifiHalApConnectionNofify &info)
78 {
79     LOGI("OnStaJoinOrLeaveMock");
80 }
81 
OnApEnableOrDisableMock(int state)82 static void OnApEnableOrDisableMock(int state)
83 {
84     LOGI("OnApEnableOrDisableMock");
85 }
86 
OnConnectSupplicantMock(int status)87 static void OnConnectSupplicantMock(int status)
88 {
89     LOGI("OnConnectSupplicantMock");
90 }
91 
OnDeviceFoundMock(const HalP2pDeviceFound & info)92 static void OnDeviceFoundMock(const HalP2pDeviceFound &info)
93 {
94     LOGI("OnDeviceFoundMock");
95 }
96 
OnDeviceLostMock(const std::string & address)97 static void OnDeviceLostMock(const std::string &address)
98 {
99     LOGI("OnDeviceLostMock");
100 }
101 
OnGoNegotiationRequestMock(const std::string & srcAddr,short passId)102 static void OnGoNegotiationRequestMock(const std::string &srcAddr, short passId)
103 {
104     LOGI("OnGoNegotiationRequestMock");
105 }
106 
OnGoNegotiationSuccessMock()107 static void OnGoNegotiationSuccessMock()
108 {
109     LOGI("OnGoNegotiationSuccessMock");
110 }
111 
OnGoNegotiationFailureMock(int status)112 static void OnGoNegotiationFailureMock(int status)
113 {
114     LOGI("OnGoNegotiationFailureMock");
115 }
116 
OnInvitationReceivedMock(const HalP2pInvitationInfo & info)117 static void OnInvitationReceivedMock(const HalP2pInvitationInfo &info)
118 {
119     LOGI("OnInvitationReceivedMock");
120 }
121 
OnInvitationResultMock(const std::string & bssid,int status)122 static void OnInvitationResultMock(const std::string &bssid, int status)
123 {
124     LOGI("OnInvitationResultMock");
125 }
126 
OnGroupFormationSuccessMock()127 static void OnGroupFormationSuccessMock()
128 {
129     LOGI("OnGroupFormationSuccessMock");
130 }
131 
OnGroupFormationFailureMock(const std::string & reason)132 static void OnGroupFormationFailureMock(const std::string &reason)
133 {
134     LOGI("OnGroupFormationFailureMock");
135 }
136 
OnProvisionDiscoveryPbcRequestMock(const std::string & address)137 static void OnProvisionDiscoveryPbcRequestMock(const std::string &address)
138 {
139     LOGI("OnProvisionDiscoveryPbcRequestMock");
140 }
141 
OnProvisionDiscoveryPbcResponseMock(const std::string & address)142 static void OnProvisionDiscoveryPbcResponseMock(const std::string &address)
143 {
144     LOGI("OnProvisionDiscoveryPbcResponseMock");
145 }
146 
OnProvisionDiscoveryEnterPinMock(const std::string & address)147 static void OnProvisionDiscoveryEnterPinMock(const std::string &address)
148 {
149     LOGI("OnProvisionDiscoveryEnterPinMock");
150 }
151 
OnProvisionDiscoveryShowPinMock(const std::string & address,const std::string & pin)152 static void OnProvisionDiscoveryShowPinMock(const std::string &address, const std::string &pin)
153 {
154     LOGI("OnProvisionDiscoveryShowPinMock");
155 }
156 
OnProvisionDiscoveryFailureMock()157 static void OnProvisionDiscoveryFailureMock()
158 {
159     LOGI("OnProvisionDiscoveryFailureMock");
160 }
161 
OnServiceDiscoveryResponseMock(const std::string & srcAddress,short updateIndicator,const std::vector<unsigned char> & tlvs)162 static void OnServiceDiscoveryResponseMock(
163     const std::string &srcAddress, short updateIndicator, const std::vector<unsigned char> &tlvs)
164 {
165     LOGI("OnServiceDiscoveryResponseMock");
166 }
167 
OnStaDeauthorizedMock(const std::string & address)168 static void OnStaDeauthorizedMock(const std::string &address)
169 {
170     LOGI("OnStaDeauthorizedMock");
171 }
172 
OnStaAuthorizedMock(const std::string & address,const std::string & address1)173 static void OnStaAuthorizedMock(const std::string &address, const std::string &address1)
174 {
175     LOGI("OnStaAuthorizedMock");
176 }
177 
ConnectSupplicantFailedMock()178 static void ConnectSupplicantFailedMock()
179 {
180     LOGI("ConnectSupplicantFailedMock");
181 }
182 
OnP2pServDiscReqMock(const HalP2pServDiscReqInfo & info)183 static void OnP2pServDiscReqMock(const HalP2pServDiscReqInfo &info)
184 {
185     LOGI("OnP2pServDiscReqMock");
186 }
187 
OnP2pIfaceCreatedMock(const std::string & ifName,int isGo)188 static void OnP2pIfaceCreatedMock(const std::string &ifName, int isGo)
189 {
190     LOGI("OnP2pIfaceCreatedMock");
191 }
192 
193 class WifiIdlInnerInterfaceTest : public testing::Test {
194 public:
SetUpTestCase()195     static void SetUpTestCase()
196     {}
TearDownTestCase()197     static void TearDownTestCase()
198     {}
SetUp()199     virtual void SetUp()
200     {}
TearDown()201     virtual void TearDown()
202     {}
RegisterStaCallbackMock(WifiEventCallback * callback)203     void RegisterStaCallbackMock(WifiEventCallback *callback)
204     {
205         callback->onConnectChanged = OnConnectChangedMock;
206         callback->onBssidChanged = OnBssidChangedMock;
207         callback->onWpaStateChanged = OnWpaStateChangedMock;
208         callback->onWpaSsidWrongKey = OnWpaSsidWrongKeyMock;
209         callback->onWpsOverlap = OnWpsOverlapMock;
210         callback->onWpsTimeOut = OnWpsTimeOutMock;
211         callback->onWpaConnectionFull = OnWpaConnectionFullMock;
212         callback->onWpaConnectionReject = OnWpaConnectionRejectMock;
213     }
214 
UnRegisterStaCallbackMock(WifiEventCallback * callback)215     void UnRegisterStaCallbackMock(WifiEventCallback *callback)
216     {
217         callback->onConnectChanged = nullptr;
218         callback->onBssidChanged = nullptr;
219         callback->onWpaStateChanged = nullptr;
220         callback->onWpaSsidWrongKey = nullptr;
221         callback->onWpsOverlap = nullptr;
222         callback->onWpsTimeOut = nullptr;
223         callback->onWpaConnectionFull = nullptr;
224         callback->onWpaConnectionReject = nullptr;
225     }
226 
RegisterApCallbackMock(IWifiApMonitorEventCallback * callback)227     void RegisterApCallbackMock(IWifiApMonitorEventCallback *callback)
228     {
229         callback->onStaJoinOrLeave = OnStaJoinOrLeaveMock;
230         callback->onApEnableOrDisable = OnApEnableOrDisableMock;
231     }
232 
UnRegisterApCallbackMock(IWifiApMonitorEventCallback * callback)233     void UnRegisterApCallbackMock(IWifiApMonitorEventCallback *callback)
234     {
235         callback->onStaJoinOrLeave = nullptr;
236         callback->onApEnableOrDisable = nullptr;
237     }
238 
RegisterP2pCallbackMock(P2pHalCallback * callback)239     void RegisterP2pCallbackMock(P2pHalCallback *callback)
240     {
241         callback->onConnectSupplicant = OnConnectSupplicantMock;
242         callback->onDeviceFound = OnDeviceFoundMock;
243         callback->onDeviceLost = OnDeviceLostMock;
244         callback->onGoNegotiationRequest = OnGoNegotiationRequestMock;
245         callback->onGoNegotiationSuccess = OnGoNegotiationSuccessMock;
246         callback->onGoNegotiationFailure = OnGoNegotiationFailureMock;
247         callback->onInvitationReceived = OnInvitationReceivedMock;
248         callback->onInvitationResult = OnInvitationResultMock;
249         callback->onGroupFormationSuccess = OnGroupFormationSuccessMock;
250         callback->onGroupFormationFailure = OnGroupFormationFailureMock;
251         callback->onProvisionDiscoveryPbcRequest = OnProvisionDiscoveryPbcRequestMock;
252         callback->onProvisionDiscoveryPbcResponse = OnProvisionDiscoveryPbcResponseMock;
253         callback->onProvisionDiscoveryEnterPin = OnProvisionDiscoveryEnterPinMock;
254         callback->onProvisionDiscoveryShowPin = OnProvisionDiscoveryShowPinMock;
255         callback->onProvisionDiscoveryFailure = OnProvisionDiscoveryFailureMock;
256         callback->onServiceDiscoveryResponse = OnServiceDiscoveryResponseMock;
257         callback->onStaDeauthorized = OnStaDeauthorizedMock;
258         callback->onStaAuthorized = OnStaAuthorizedMock;
259         callback->connectSupplicantFailed = ConnectSupplicantFailedMock;
260         callback->onP2pServDiscReq = OnP2pServDiscReqMock;
261         callback->onP2pIfaceCreated = OnP2pIfaceCreatedMock;
262     }
263 
UnRegisterP2pCallbackMock(P2pHalCallback * callback)264     void UnRegisterP2pCallbackMock(P2pHalCallback *callback)
265     {
266         callback->onConnectSupplicant = nullptr;
267         callback->onDeviceFound = nullptr;
268         callback->onDeviceLost = nullptr;
269         callback->onGoNegotiationRequest = nullptr;
270         callback->onGoNegotiationSuccess = nullptr;
271         callback->onGoNegotiationFailure = nullptr;
272         callback->onInvitationReceived = nullptr;
273         callback->onInvitationResult = nullptr;
274         callback->onGroupFormationSuccess = nullptr;
275         callback->onGroupFormationFailure = nullptr;
276         callback->onProvisionDiscoveryPbcRequest = nullptr;
277         callback->onProvisionDiscoveryPbcResponse = nullptr;
278         callback->onProvisionDiscoveryEnterPin = nullptr;
279         callback->onProvisionDiscoveryShowPin = nullptr;
280         callback->onProvisionDiscoveryFailure = nullptr;
281         callback->onServiceDiscoveryResponse = nullptr;
282         callback->onStaDeauthorized = nullptr;
283         callback->onStaAuthorized = nullptr;
284         callback->connectSupplicantFailed = nullptr;
285         callback->onP2pServDiscReq = nullptr;
286         callback->onP2pIfaceCreated = nullptr;
287     }
288 };
289 /**
290  * @tc.name: OnApStaJoinOrLeaveTest
291  * @tc.desc: OnApStaJoinOrLeaveTest
292  * @tc.type: FUNC
293  * @tc.require: issue
294 */
295 HWTEST_F(WifiIdlInnerInterfaceTest, OnApStaJoinOrLeaveTest, TestSize.Level1)
296 {
297     LOGI("OnApStaJoinOrLeaveTest enter");
298     CStationInfo* info = nullptr;
299     int id = 1;
300     OnApStaJoinOrLeave(info, id);
301     CStationInfo infomation;
302     infomation.type = 1;
303     if (memcpy_s(infomation.mac, WIFI_MAX_MAC_ADDR_LENGTH, "00:00:AA:BB:CC:DD", WIFI_MAX_MAC_ADDR_LENGTH - 1) != EOK) {
304         return;
305     }
306     IWifiApMonitorEventCallback callback;
307     RegisterApCallbackMock(&callback);
308     WifiApHalInterface::GetInstance().RegisterApEvent(callback);
309     OnApStaJoinOrLeave(&infomation, id);
310     UnRegisterApCallbackMock(&callback);
311     WifiApHalInterface::GetInstance().RegisterApEvent(callback);
312     OnApStaJoinOrLeave(&infomation, id);
313 }
314 /**
315  * @tc.name: OnApEnableOrDisableTest
316  * @tc.desc: OnApEnableOrDisableTest
317  * @tc.type: FUNC
318  * @tc.require: issue
319 */
320 HWTEST_F(WifiIdlInnerInterfaceTest, OnApEnableOrDisableTest, TestSize.Level1)
321 {
322     LOGI("OnApEnableOrDisableTest enter");
323     int status = 1;
324     int id = 1;
325     IWifiApMonitorEventCallback callback;
326     RegisterApCallbackMock(&callback);
327     WifiApHalInterface::GetInstance().RegisterApEvent(callback);
328     OnApEnableOrDisable(status, id);
329     UnRegisterApCallbackMock(&callback);
330     WifiApHalInterface::GetInstance().RegisterApEvent(callback);
331     OnApEnableOrDisable(status, id);
332 }
333 /**
334  * @tc.name: OnConnectChangedTest
335  * @tc.desc: Sta OnConnectChangedTest
336  * @tc.type: FUNC
337  * @tc.require: issue
338 */
339 HWTEST_F(WifiIdlInnerInterfaceTest, OnConnectChangedTest, TestSize.Level1)
340 {
341     LOGI("OnConnectChangedTest enter");
342     int status = 1;
343     int networkId = 1;
344     char *mac = nullptr;
345     OnConnectChanged(status, networkId, mac);
346     char mac1[] = "00:00:AA:BB:CC:DD";
347     std::string ifaceName = "wlan0";
348     WifiEventCallback callback;
349     RegisterStaCallbackMock(&callback);
350     WifiStaHalInterface::GetInstance().RegisterStaEventCallback(callback, ifaceName);
351     OnConnectChanged(status, networkId, mac1);
352     UnRegisterStaCallbackMock(&callback);
353     WifiStaHalInterface::GetInstance().RegisterStaEventCallback(callback, ifaceName);
354     OnConnectChanged(status, networkId, mac1);
355 }
356 
357 /**
358  * @tc.name: OnDisConnectReasonCallbackTest
359  * @tc.desc: Sta OnDisConnectReasonCallbackTest
360  * @tc.type: FUNC
361  * @tc.require: issue
362 */
363 HWTEST_F(WifiIdlInnerInterfaceTest, OnDisConnectReasonCallbackTest, TestSize.Level1)
364 {
365     LOGI("OnDisConnectReasonCallbackTest enter");
366     int reason = 1;
367     char *mac = nullptr;
368     OnDisConnectReasonCallback(reason, mac);
369     char mac1[] = "00:00:AA:BB:CC:DD";
370     std::string ifaceName = "wlan0";
371     WifiEventCallback callback;
372     RegisterStaCallbackMock(&callback);
373     WifiStaHalInterface::GetInstance().RegisterStaEventCallback(callback, ifaceName);
374     OnDisConnectReasonCallback(reason, mac1);
375     UnRegisterStaCallbackMock(&callback);
376     WifiStaHalInterface::GetInstance().RegisterStaEventCallback(callback, ifaceName);
377     OnDisConnectReasonCallback(reason, mac1);
378 }
379 
380 /**
381  * @tc.name: OnBssidChangedTest
382  * @tc.desc: OnBssidChangedTest
383  * @tc.type: FUNC
384  * @tc.require: issue
385 */
386 HWTEST_F(WifiIdlInnerInterfaceTest, OnBssidChangedTest, TestSize.Level1)
387 {
388     LOGI("OnBssidChangedTest enter");
389     char *rea = nullptr;
390     char *bss = nullptr;
391     OnBssidChanged(rea, bss);
392     char reason[] = "none";
393     OnBssidChanged(reason, bss);
394     char bssid[] = "00:00:AA:BB:CC:DD";
395     WifiEventCallback callback;
396     std::string ifaceName = "wlan0";
397     RegisterStaCallbackMock(&callback);
398     WifiStaHalInterface::GetInstance().RegisterStaEventCallback(callback, ifaceName);
399     OnBssidChanged(reason, bssid);
400     UnRegisterStaCallbackMock(&callback);
401     WifiStaHalInterface::GetInstance().RegisterStaEventCallback(callback, ifaceName);
402     OnBssidChanged(reason, bssid);
403 }
404 /**
405  * @tc.name: OnWpaStateChangedTest
406  * @tc.desc: OnWpaStateChangedTest
407  * @tc.type: FUNC
408  * @tc.require: issue
409 */
410 HWTEST_F(WifiIdlInnerInterfaceTest, OnWpaStateChangedTest, TestSize.Level1)
411 {
412     LOGI("OnWpaStateChangedTest enter");
413     int status = 1;
414     WifiEventCallback callback;
415     RegisterStaCallbackMock(&callback);
416     std::string ifaceName = "wlan0";
417     WifiStaHalInterface::GetInstance().RegisterStaEventCallback(callback, ifaceName);
418     OnWpaStateChanged(status);
419     OnWpaSsidWrongKey();
420     OnWpaConnectionFull(status);
421     OnWpaConnectionReject(status);
422     OnWpsOverlap(status);
423     OnWpsTimeOut(status);
424     UnRegisterStaCallbackMock(&callback);
425     WifiStaHalInterface::GetInstance().RegisterStaEventCallback(callback, ifaceName);
426     OnWpaStateChanged(status);
427     OnWpaSsidWrongKey();
428     OnWpaConnectionFull(status);
429     OnWpaConnectionReject(status);
430     OnWpsOverlap(status);
431     OnWpsTimeOut(status);
432 }
433 /**
434  * @tc.name: OnP2pDeviceFoundTest
435  * @tc.desc: OnP2pDeviceFoundTest
436  * @tc.type: FUNC
437  * @tc.require: issue
438 */
439 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pDeviceFoundTest, TestSize.Level1)
440 {
441     LOGI("OnP2pDeviceFoundTest enter");
442     P2pDeviceInfo* info = nullptr;
443     OnP2pDeviceFound(info);
444     P2pDeviceInfo information;
445     if (memcpy_s(information.wfdDeviceInfo, WIFI_P2P_WFD_DEVICE_INFO_LENGTH, "watchpannel", LENTH1) != EOK) {
446         return;
447     }
448     information.wfdLength = LENTH1;
449     P2pHalCallback callback;
450     RegisterP2pCallbackMock(&callback);
451     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
452     OnP2pDeviceFound(&information);
453     UnRegisterP2pCallbackMock(&callback);
454     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
455     OnP2pDeviceFound(&information);
456 }
457 /**
458  * @tc.name: OnP2pDeviceLostTest
459  * @tc.desc: OnP2pDeviceLostTest
460  * @tc.type: FUNC
461  * @tc.require: issue
462 */
463 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pDeviceLostTest, TestSize.Level1)
464 {
465     LOGI("OnP2pDeviceLostTest enter");
466     char *p2pDevic = nullptr;
467     OnP2pDeviceLost(p2pDevic);
468     char p2pDeviceAddress[] = "00:00:AA:BB:CC:DD";
469     P2pHalCallback callback;
470     RegisterP2pCallbackMock(&callback);
471     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
472     OnP2pDeviceLost(p2pDeviceAddress);
473     UnRegisterP2pCallbackMock(&callback);
474     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
475     OnP2pDeviceLost(p2pDeviceAddress);
476 }
477 /**
478  * @tc.name: OnP2pGoNegotiationRequestTest
479  * @tc.desc: OnP2pGoNegotiationRequestTest
480  * @tc.type: FUNC
481  * @tc.require: issue
482 */
483 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pGoNegotiationRequestTest, TestSize.Level1)
484 {
485     LOGI("OnP2pGoNegotiationRequestTest enter");
486     char *srcAdd = nullptr;
487     short passwordId = 1;
488     OnP2pGoNegotiationRequest(srcAdd, passwordId);
489     char srcAddress[] = "00:00:AA:BB:CC:DD";
490     P2pHalCallback callback;
491     RegisterP2pCallbackMock(&callback);
492     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
493     OnP2pGoNegotiationRequest(srcAddress, passwordId);
494     UnRegisterP2pCallbackMock(&callback);
495     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
496     OnP2pGoNegotiationRequest(srcAddress, passwordId);
497 }
498 /**
499  * @tc.name: OnP2pGoNegotiationSuccessTest
500  * @tc.desc: OnP2pGoNegotiationSuccessTest
501  * @tc.type: FUNC
502  * @tc.require: issue
503 */
504 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pGoNegotiationSuccessTest, TestSize.Level1)
505 {
506     LOGI("OnP2pGoNegotiationSuccessTest enter");
507     P2pHalCallback callback;
508     RegisterP2pCallbackMock(&callback);
509     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
510     OnP2pGoNegotiationSuccess();
511     UnRegisterP2pCallbackMock(&callback);
512     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
513     OnP2pGoNegotiationSuccess();
514 }
515 /**
516  * @tc.name: OnP2pGoNegotiationFailureTest
517  * @tc.desc: OnP2pGoNegotiationFailureTest
518  * @tc.type: FUNC
519  * @tc.require: issue
520 */
521 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pGoNegotiationFailureTest, TestSize.Level1)
522 {
523     LOGI("OnP2pGoNegotiationFailureTest enter");
524     int status = 1;
525     P2pHalCallback callback;
526     RegisterP2pCallbackMock(&callback);
527     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
528     OnP2pGoNegotiationFailure(status);
529     UnRegisterP2pCallbackMock(&callback);
530     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
531     OnP2pGoNegotiationFailure(status);
532 }
533 /**
534  * @tc.name: OnP2pInvitationResultTest
535  * @tc.desc: OnP2pInvitationResultTest
536  * @tc.type: FUNC
537  * @tc.require: issue
538 */
539 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pInvitationResultTest, TestSize.Level1)
540 {
541     LOGI("OnP2pInvitationResultTest enter");
542     char *bss = nullptr;
543     int status = 1;
544     OnP2pInvitationResult(bss, status);
545     char bssid[] = "00:00:AA:BB:CC:DD";
546     P2pHalCallback callback;
547     RegisterP2pCallbackMock(&callback);
548     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
549     OnP2pInvitationResult(bssid, status);
550     UnRegisterP2pCallbackMock(&callback);
551     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
552     OnP2pInvitationResult(bssid, status);
553 }
554 /**
555  * @tc.name: OnP2pInvitationReceivedTest
556  * @tc.desc: OnP2pInvitationReceivedTest
557  * @tc.type: FUNC
558  * @tc.require: issue
559 */
560 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pInvitationReceivedTest, TestSize.Level1)
561 {
562     LOGI("OnP2pInvitationReceivedTest enter");
563     P2pInvitationInfo *info = nullptr;
564     OnP2pInvitationReceived(info);
565     P2pInvitationInfo information;
566     information.type = 1;
567     information.persistentNetworkId = 1;
568     information.operatingFrequency = 1;
569     P2pHalCallback callback;
570     RegisterP2pCallbackMock(&callback);
571     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
572     OnP2pInvitationReceived(&information);
573     UnRegisterP2pCallbackMock(&callback);
574     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
575     OnP2pInvitationReceived(&information);
576 }
577 /**
578  * @tc.name: OnP2pGroupFormationSuccessTest
579  * @tc.desc: OnP2pGroupFormationSuccessTest
580  * @tc.type: FUNC
581  * @tc.require: issue
582 */
583 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pGroupFormationSuccessTest, TestSize.Level1)
584 {
585     LOGI("OnP2pGroupFormationSuccessTest enter");
586     P2pHalCallback callback;
587     RegisterP2pCallbackMock(&callback);
588     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
589     OnP2pGroupFormationSuccess();
590     UnRegisterP2pCallbackMock(&callback);
591     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
592     OnP2pGroupFormationSuccess();
593 }
594 /**
595  * @tc.name: OnP2pGroupFormationFailureTest
596  * @tc.desc: OnP2pGroupFormationFailureTest
597  * @tc.type: FUNC
598  * @tc.require: issue
599 */
600 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pGroupFormationFailureTest, TestSize.Level1)
601 {
602     LOGI("OnP2pGroupFormationFailureTest enter");
603     char *failure = nullptr;
604     OnP2pGroupFormationFailure(failure);
605     char failureReason[] = "test";
606     P2pHalCallback callback;
607     RegisterP2pCallbackMock(&callback);
608     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
609     OnP2pGroupFormationFailure(failureReason);
610     UnRegisterP2pCallbackMock(&callback);
611     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
612     OnP2pGroupFormationFailure(failureReason);
613 }
614 /**
615  * @tc.name: OnP2pGroupStartedTest
616  * @tc.desc: OnP2pGroupStartedTest
617  * @tc.type: FUNC
618  * @tc.require: issue
619 */
620 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pGroupStartedTest, TestSize.Level1)
621 {
622     LOGI("OnP2pGroupStartedTest enter");
623     P2pGroupInfo *group = nullptr;
624     OnP2pGroupStarted(group);
625     P2pGroupInfo groupInfo;
626     groupInfo.isGo = 1;
627     groupInfo.isPersistent = 0;
628     groupInfo.frequency = 1;
629     P2pHalCallback callback;
630     RegisterP2pCallbackMock(&callback);
631     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
632     OnP2pGroupStarted(&groupInfo);
633     UnRegisterP2pCallbackMock(&callback);
634     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
635     OnP2pGroupStarted(&groupInfo);
636 }
637 /**
638  * @tc.name: OnP2pGroupRemovedTest
639  * @tc.desc: OnP2pGroupRemovedTest
640  * @tc.type: FUNC
641  * @tc.require: issue
642 */
643 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pGroupRemovedTest, TestSize.Level1)
644 {
645     LOGI("OnP2pGroupRemovedTest enter");
646     char *groupIf = nullptr;
647     int isGo = 1;
648     OnP2pGroupRemoved(groupIf, isGo);
649     char groupIfName[] = "P2pGroupRemoved";
650     P2pHalCallback callback;
651     RegisterP2pCallbackMock(&callback);
652     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
653     OnP2pGroupRemoved(groupIfName, isGo);
654     UnRegisterP2pCallbackMock(&callback);
655     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
656     OnP2pGroupRemoved(groupIfName, isGo);
657 }
658 /**
659  * @tc.name: OnP2pProvisionDiscoveryTest
660  * @tc.desc: OnP2pProvisionDiscoveryTest
661  * @tc.type: FUNC
662  * @tc.require: issue
663 */
664 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pProvisionDiscoveryTest, TestSize.Level1)
665 {
666     LOGI("OnP2pProvisionDiscoveryTest enter");
667     char *p2pDeviceAdd = nullptr;
668     OnP2pProvisionDiscoveryPbcRequest(p2pDeviceAdd);
669     OnP2pProvisionDiscoveryPbcResponse(p2pDeviceAdd);
670     OnP2pProvisionDiscoveryEnterPin(p2pDeviceAdd);
671     char p2pDeviceAddress[] = "00:22:AA:BB:CC:DD";
672     P2pHalCallback callback;
673     RegisterP2pCallbackMock(&callback);
674     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
675     OnP2pProvisionDiscoveryPbcRequest(p2pDeviceAddress);
676     OnP2pProvisionDiscoveryPbcResponse(p2pDeviceAddress);
677     OnP2pProvisionDiscoveryEnterPin(p2pDeviceAddress);
678     UnRegisterP2pCallbackMock(&callback);
679     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
680     OnP2pProvisionDiscoveryPbcRequest(p2pDeviceAddress);
681     OnP2pProvisionDiscoveryPbcResponse(p2pDeviceAddress);
682     OnP2pProvisionDiscoveryEnterPin(p2pDeviceAddress);
683 }
684 /**
685  * @tc.name: OnP2pProvisionDiscoveryShowPinTest
686  * @tc.desc: OnP2pProvisionDiscoveryShowPinTest
687  * @tc.type: FUNC
688  * @tc.require: issue
689 */
690 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pProvisionDiscoveryShowPinTest, TestSize.Level1)
691 {
692     LOGI("OnP2pProvisionDiscoveryShowPinTest enter");
693     char *p2pDeviceAddress = nullptr;
694     char *generatedPin = nullptr;
695     OnP2pProvisionDiscoveryShowPin(p2pDeviceAddress, generatedPin);
696     char p2pDeviceAdd[] = "00:22:AA:BB:CC:DD";
697     OnP2pProvisionDiscoveryShowPin(p2pDeviceAdd, generatedPin);
698     char pin[] = "test";
699     P2pHalCallback callback;
700     RegisterP2pCallbackMock(&callback);
701     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
702     OnP2pProvisionDiscoveryShowPin(p2pDeviceAdd, pin);
703     UnRegisterP2pCallbackMock(&callback);
704     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
705     OnP2pProvisionDiscoveryShowPin(p2pDeviceAdd, pin);
706 }
707 /**
708  * @tc.name: OnP2pProvisionDiscoveryFailureTest
709  * @tc.desc: OnP2pProvisionDiscoveryFailureTest
710  * @tc.type: FUNC
711  * @tc.require: issue
712 */
713 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pProvisionDiscoveryFailureTest, TestSize.Level1)
714 {
715     LOGI("OnP2pProvisionDiscoveryFailureTest enter");
716     P2pHalCallback callback;
717     RegisterP2pCallbackMock(&callback);
718     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
719     OnP2pProvisionDiscoveryFailure();
720     UnRegisterP2pCallbackMock(&callback);
721     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
722     OnP2pProvisionDiscoveryFailure();
723 }
724 /**
725  * @tc.name: OnP2pFindStoppedTest
726  * @tc.desc: OnP2pFindStoppedTest
727  * @tc.type: FUNC
728  * @tc.require: issue
729 */
730 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pFindStoppedTest, TestSize.Level1)
731 {
732     LOGI("OnP2pFindStoppedTest enter");
733     P2pHalCallback callback;
734     RegisterP2pCallbackMock(&callback);
735     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
736     OnP2pFindStopped();
737     UnRegisterP2pCallbackMock(&callback);
738     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
739     OnP2pFindStopped();
740 }
741 /**
742  * @tc.name: OnP2pServiceDiscoveryResponseTest
743  * @tc.desc: OnP2pServiceDiscoveryResponseTest
744  * @tc.type: FUNC
745  * @tc.require: issue
746 */
747 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pServiceDiscoveryResponseTest, TestSize.Level1)
748 {
749     LOGI("OnP2pServiceDiscoveryResponseTest enter");
750     char *srcAdd = nullptr;
751     short updateIndicator = 1;
752     unsigned char tlvs[] = "test";
753     size_t tlvsLength = 1;
754     OnP2pServiceDiscoveryResponse(srcAdd, updateIndicator, tlvs, tlvsLength);
755     char srcAddress[] = "AA:BB:CC:DD:EE:FF";
756     P2pHalCallback callback;
757     RegisterP2pCallbackMock(&callback);
758     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
759     OnP2pServiceDiscoveryResponse(srcAddress, updateIndicator, tlvs, tlvsLength);
760     UnRegisterP2pCallbackMock(&callback);
761     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
762     OnP2pServiceDiscoveryResponse(srcAddress, updateIndicator, tlvs, tlvsLength);
763 }
764 /**
765  * @tc.name: OnP2pStaDeauthorizedTest
766  * @tc.desc: OnP2pStaDeauthorizedTest
767  * @tc.type: FUNC
768  * @tc.require: issue
769 */
770 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pStaDeauthorizedTest, TestSize.Level1)
771 {
772     LOGI("OnP2pStaDeauthorizedTest enter");
773     char *p2pDeviceAddress = nullptr;
774     char *p2pRandomDeviceAddress  = nullptr;
775     OnP2pStaDeauthorized(p2pDeviceAddress);
776     OnP2pStaAuthorized(p2pDeviceAddress, p2pRandomDeviceAddress);
777     char p2pDeviceAdd[] = "AA:BB:CC:DD:EE:FF";
778     P2pHalCallback callback;
779     RegisterP2pCallbackMock(&callback);
780     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
781     OnP2pStaDeauthorized(p2pDeviceAdd);
782     OnP2pStaAuthorized(p2pDeviceAdd, p2pDeviceAdd);
783     UnRegisterP2pCallbackMock(&callback);
784     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
785     OnP2pStaDeauthorized(p2pDeviceAdd);
786     OnP2pStaAuthorized(p2pDeviceAdd, p2pDeviceAdd);
787 }
788 /**
789  * @tc.name: OnP2pConnectSupplicantFailedTest
790  * @tc.desc: OnP2pConnectSupplicantFailedTest
791  * @tc.type: FUNC
792  * @tc.require: issue
793 */
794 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pConnectSupplicantFailedTest, TestSize.Level1)
795 {
796     LOGI("OnP2pConnectSupplicantFailedTest enter");
797     P2pHalCallback callback;
798     RegisterP2pCallbackMock(&callback);
799     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
800     OnP2pConnectSupplicantFailed();
801     UnRegisterP2pCallbackMock(&callback);
802     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
803     OnP2pConnectSupplicantFailed();
804 }
805 /**
806  * @tc.name: OnP2pServDiscReqTest
807  * @tc.desc: OnP2pServDiscReqTest
808  * @tc.type: FUNC
809  * @tc.require: issue
810 */
811 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pServDiscReqTest, TestSize.Level1)
812 {
813     LOGI("OnP2pServDiscReqTest enter");
814     P2pServDiscReqInfo *info = nullptr;
815     OnP2pServDiscReq(info);
816     P2pServDiscReqInfo infomation;
817     infomation.tlvsLength = LENTH;
818     if (memcpy_s(infomation.tlvs, WIFI_MAX_MAC_ADDR_LENGTH, "AABBCCDDEEFFGGHH", LENTH) != EOK) {
819         return;
820     }
821     P2pHalCallback callback;
822     RegisterP2pCallbackMock(&callback);
823     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
824     OnP2pServDiscReq(&infomation);
825     UnRegisterP2pCallbackMock(&callback);
826     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
827     OnP2pServDiscReq(&infomation);
828 }
829 /**
830  * @tc.name: OnP2pIfaceCreatedTest
831  * @tc.desc: OnP2pIfaceCreatedTest
832  * @tc.type: FUNC
833  * @tc.require: issue
834 */
835 HWTEST_F(WifiIdlInnerInterfaceTest, OnP2pIfaceCreatedTest, TestSize.Level1)
836 {
837     LOGI("OnP2pIfaceCreatedTest enter");
838     char ifName[] = "TV";
839     int isGo = 1;
840     P2pHalCallback callback;
841     RegisterP2pCallbackMock(&callback);
842     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
843     OnP2pIfaceCreated(ifName, isGo);
844     UnRegisterP2pCallbackMock(&callback);
845     WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callback);
846     OnP2pIfaceCreated(ifName, isGo);
847 }
848 }  // namespace Wifi
849 }  // namespace OHOS