1 /*
2 * Copyright (C) 2021 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 "wifi_p2p_hal_interface_test.h"
16 #include <gtest/gtest.h>
17 #include "wifi_p2p_hal_interface.h"
18 #include "wifi_p2p_msg.h"
19 #include "wifi_log.h"
20 #include "wifi_global_func.h"
21 #undef LOG_TAG
22 #define LOG_TAG "OHWIFI_IDLCLIENT_P2P_TEST"
23
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Wifi {
onConnectSupplicant(int status)28 void onConnectSupplicant(int status)
29 {
30 LOGD("onConnectSupplicant...status: %d\n", status);
31 }
32
onDeviceFound(const HalP2pDeviceFound & info)33 void onDeviceFound(const HalP2pDeviceFound &info)
34 {
35 LOGD("onDeviceFound...deviceCapabilities: %d\n", info.deviceCapabilities);
36 }
37
onDeviceLost(const std::string & address)38 void onDeviceLost(const std::string &address)
39 {
40 LOGD("onDeviceLost...address: %s\n", address.c_str());
41 }
42
onGoNegotiationRequest(const std::string & srcAddr,short passId)43 void onGoNegotiationRequest(const std::string &srcAddr, short passId)
44 {
45 LOGD("onGoNegotiationRequest...srcAddr: %s, passId: %d\n", srcAddr.c_str(), passId);
46 }
47
onGoNegotiationSuccess()48 void onGoNegotiationSuccess()
49 {
50 LOGD("onGoNegotiationSuccess...\n");
51 }
52
onGoNegotiationFailure(int status)53 void onGoNegotiationFailure(int status)
54 {
55 LOGD("onGoNegotiationFailure...status: %d\n", status);
56 }
57
onInvitationReceived(const HalP2pInvitationInfo & info)58 void onInvitationReceived(const HalP2pInvitationInfo &info)
59 {
60 LOGD("onInvitationReceived...operatingFrequency: %d\n", info.operatingFrequency);
61 }
62
onInvitationResult(const std::string & bssid,int status)63 void onInvitationResult(const std::string &bssid, int status)
64 {
65 LOGD("onInvitationResult...bssid: %s, status: %d\n", bssid.c_str(), status);
66 }
67
onGroupFormationSuccess()68 void onGroupFormationSuccess()
69 {
70 LOGD("onGroupFormationSuccess...\n");
71 }
72
onGroupFormationFailure(const std::string & reason)73 void onGroupFormationFailure(const std::string &reason)
74 {
75 LOGD("onGroupFormationFailure...reason: %s\n", reason.c_str());
76 }
77
onGroupStarted(const HalP2pGroupInfo & info)78 void onGroupStarted(const HalP2pGroupInfo &info)
79 {
80 LOGD("onGroupStarted...frequency: %d\n", info.frequency);
81 }
82
onGroupRemoved(const std::string & groupIfName,bool isGo)83 void onGroupRemoved(const std::string &groupIfName, bool isGo)
84 {
85 LOGD("onGroupRemoved...groupIfName: %s, isGo: %d\n", groupIfName.c_str(), isGo);
86 }
87
onProvisionDiscoveryPbcRequest(const std::string & address)88 void onProvisionDiscoveryPbcRequest(const std::string &address)
89 {
90 LOGD("onProvisionDiscoveryPbcRequest...address: %s\n", address.c_str());
91 }
92
onProvisionDiscoveryPbcResponse(const std::string & address)93 void onProvisionDiscoveryPbcResponse(const std::string &address)
94 {
95 LOGD("onProvisionDiscoveryPbcResponse...address: %s\n", address.c_str());
96 }
97
onProvisionDiscoveryEnterPin(const std::string & address)98 void onProvisionDiscoveryEnterPin(const std::string &address)
99 {
100 LOGD("onProvisionDiscoveryEnterPin...address: %s\n", address.c_str());
101 }
102
onProvisionDiscoveryShowPin(const std::string & address,const std::string & pin)103 void onProvisionDiscoveryShowPin(const std::string &address, const std::string &pin)
104 {
105 LOGD("onProvisionDiscoveryShowPin...address: %s, pin: %s\n", address.c_str(), pin.c_str());
106 }
107
onProvisionDiscoveryFailure()108 void onProvisionDiscoveryFailure()
109 {
110 LOGD("onProvisionDiscoveryFailure...\n");
111 }
112
onFindStopped()113 void onFindStopped()
114 {
115 LOGD("onFindStopped...\n");
116 }
117
onServiceDiscoveryResponse(const std::string & srcAddress,short updateIndicator,const std::vector<unsigned char> & tlvs)118 void onServiceDiscoveryResponse(
119 const std::string &srcAddress, short updateIndicator, const std::vector<unsigned char> &tlvs)
120 {
121 LOGD("onServiceDiscoveryResponse...address: %s, updateIndicator: %d, tlvsLength: %zu\n",
122 srcAddress.c_str(),
123 updateIndicator,
124 tlvs.size());
125 }
126
onStaDeauthorized(const std::string & address)127 void onStaDeauthorized(const std::string &address)
128 {
129 LOGD("onStaDeauthorized...address: %s\n", address.c_str());
130 }
131
onStaAuthorized(const std::string & address)132 void onStaAuthorized(const std::string &address)
133 {
134 LOGD("onStaAuthorized...address: %s\n", address.c_str());
135 }
136
connectSupplicantFailed()137 void connectSupplicantFailed()
138 {
139 LOGD("connectSupplicantFailed...\n");
140 }
141
onP2pServDiscReq(const HalP2pServDiscReqInfo & info)142 void onP2pServDiscReq(const HalP2pServDiscReqInfo &info)
143 {
144 LOGD("onP2pServDiscReq \n");
145 LOGD(" service discovery freq: %d\n", info.freq);
146 LOGD(" service discovery dialogToken: %d\n", info.dialogToken);
147 LOGD(" service discovery updateIndic: %d\n", info.updateIndic);
148 LOGD(" service discovery mac: %s\n", info.mac.c_str());
149 }
150
SetUpTestCase()151 void WifiP2pHalInterfaceTest::SetUpTestCase()
152 {
153 P2pHalCallback callbacks;
154 callbacks.onConnectSupplicant = onConnectSupplicant;
155 callbacks.onDeviceLost = onDeviceLost;
156 callbacks.onGoNegotiationRequest = onGoNegotiationRequest;
157 callbacks.onGoNegotiationSuccess = onGoNegotiationSuccess;
158 callbacks.onGoNegotiationFailure = onGoNegotiationFailure;
159 callbacks.onInvitationReceived = onInvitationReceived;
160 callbacks.onInvitationResult = onInvitationResult;
161 callbacks.onGroupFormationSuccess = onGroupFormationSuccess;
162 callbacks.onGroupFormationFailure = onGroupFormationFailure;
163 callbacks.onGroupStarted = onGroupStarted;
164 callbacks.onGroupRemoved = onGroupRemoved;
165 callbacks.onProvisionDiscoveryPbcRequest = onProvisionDiscoveryPbcRequest;
166 callbacks.onProvisionDiscoveryPbcResponse = onProvisionDiscoveryPbcResponse;
167 callbacks.onProvisionDiscoveryEnterPin = onProvisionDiscoveryEnterPin;
168 callbacks.onProvisionDiscoveryShowPin = onProvisionDiscoveryShowPin;
169 callbacks.onProvisionDiscoveryFailure = onProvisionDiscoveryFailure;
170 callbacks.onFindStopped = onFindStopped;
171 callbacks.onServiceDiscoveryResponse = onServiceDiscoveryResponse;
172 callbacks.onStaDeauthorized = onStaDeauthorized;
173 callbacks.onStaAuthorized = onStaAuthorized;
174 callbacks.connectSupplicantFailed = connectSupplicantFailed;
175 callbacks.onP2pServDiscReq = onP2pServDiscReq;
176 WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callbacks);
177 }
178
TearDownTestCase()179 void WifiP2pHalInterfaceTest::TearDownTestCase()
180 {
181 P2pHalCallback callbacks;
182 WifiP2PHalInterface::GetInstance().RegisterP2pCallback(callbacks);
183 }
184
185 HWTEST_F(WifiP2pHalInterfaceTest, P2pStart_SUCCESS, TestSize.Level1)
186 {
187 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().StartP2p());
188 }
189
190 HWTEST_F(WifiP2pHalInterfaceTest, SetupWpsPbc_SUCCESS, TestSize.Level1)
191 {
192 std::string groupInterface = "groupInterface";
193 std::string bssid = "bssid";
194
195 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().StartWpsPbc(groupInterface, bssid));
196 }
197
198 HWTEST_F(WifiP2pHalInterfaceTest, SetupWpsPin_SUCCESS, TestSize.Level1)
199 {
200 std::string groupInterface = "groupInterface";
201 std::string bssid;
202 std::string pin = "adc123456";
203 std::string result;
204
205 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_INVALID_PARAM,
206 WifiP2PHalInterface::GetInstance().StartWpsPin(groupInterface, bssid, pin, result));
207 pin.clear();
208 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK,
209 WifiP2PHalInterface::GetInstance().StartWpsPin(groupInterface, bssid, pin, result));
210 }
211
212 HWTEST_F(WifiP2pHalInterfaceTest, RemoveNetwork_SUCCESS, TestSize.Level1)
213 {
214 int networkId = 0;
215 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_FAILED, WifiP2PHalInterface::GetInstance().RemoveNetwork(networkId));
216 }
217
218 HWTEST_F(WifiP2pHalInterfaceTest, ListNetworksTest, TestSize.Level1)
219 {
220 std::map<int, WifiP2pGroupInfo> mapGroups;
221 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().ListNetworks(mapGroups));
222 }
223
224 HWTEST_F(WifiP2pHalInterfaceTest, SetWpsDeviceName_SUCCESS, TestSize.Level1)
225 {
226 std::string name = "testName";
227 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().SetP2pDeviceName(name));
228 }
229
230 HWTEST_F(WifiP2pHalInterfaceTest, SetWpsDeviceType_SUCCESS, TestSize.Level1)
231 {
232 std::string type = "testType";
233 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_FAILED, WifiP2PHalInterface::GetInstance().SetP2pDeviceType(type));
234 }
235
236 HWTEST_F(WifiP2pHalInterfaceTest, SetWpsConfigMethods_SUCCESS, TestSize.Level1)
237 {
238 std::string config = "testConfig";
239 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().SetP2pConfigMethods(config));
240 }
241
242 HWTEST_F(WifiP2pHalInterfaceTest, SetSsidPostfixName_SUCCESS, TestSize.Level1)
243 {
244 std::string postfixName = "testPostfixName";
245 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().SetP2pSsidPostfix(postfixName));
246 }
247
248 HWTEST_F(WifiP2pHalInterfaceTest, SetGroupMaxIdle_SUCCESS, TestSize.Level1)
249 {
250 std::string groupInterface = "testGroupName";
251 size_t time = 0;
252 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().SetP2pGroupIdle(groupInterface, time));
253 }
254
255 HWTEST_F(WifiP2pHalInterfaceTest, SetPowerSave_SUCCESS, TestSize.Level1)
256 {
257 std::string groupInterface;
258 bool enable = false;
259 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().SetP2pPowerSave(groupInterface, enable));
260 }
261
262 HWTEST_F(WifiP2pHalInterfaceTest, SetWfdEnable_SUCCESS, TestSize.Level1)
263 {
264 bool enable = false;
265 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_FAILED, WifiP2PHalInterface::GetInstance().SetWfdEnable(enable));
266 }
267
268 HWTEST_F(WifiP2pHalInterfaceTest, SetWfdDeviceConfig_SUCCESS, TestSize.Level1)
269 {
270 std::string config;
271 EXPECT_NE(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().SetWfdDeviceConfig(config));
272 }
273
274 HWTEST_F(WifiP2pHalInterfaceTest, StartP2pFind_SUCCESS, TestSize.Level1)
275 {
276 size_t timeout = 0;
277 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().P2pFind(timeout));
278 }
279
280 HWTEST_F(WifiP2pHalInterfaceTest, StopP2pFind_SUCCESS, TestSize.Level1)
281 {
282 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().P2pStopFind());
283 }
284
285 HWTEST_F(WifiP2pHalInterfaceTest, SetExtListen_SUCCESS, TestSize.Level1)
286 {
287 bool enable = false;
288 size_t period = 0;
289 size_t interval = 0;
290 EXPECT_EQ(
291 WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().P2pConfigureListen(enable, period, interval));
292 enable = true;
293 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_INVALID_PARAM,
294 WifiP2PHalInterface::GetInstance().P2pConfigureListen(enable, period, interval));
295 period = 65536;
296 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_INVALID_PARAM,
297 WifiP2PHalInterface::GetInstance().P2pConfigureListen(enable, period, interval));
298 period = 10;
299 interval = 65536;
300 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_INVALID_PARAM,
301 WifiP2PHalInterface::GetInstance().P2pConfigureListen(enable, period, interval));
302 interval = 60;
303 EXPECT_EQ(
304 WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().P2pConfigureListen(enable, period, interval));
305 }
306
307 HWTEST_F(WifiP2pHalInterfaceTest, SetListenChannel_SUCCESS, TestSize.Level1)
308 {
309 size_t channel = 0;
310 unsigned char regClass = 0;
311 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_FAILED, WifiP2PHalInterface::GetInstance().SetListenChannel(channel, regClass));
312 }
313
314 HWTEST_F(WifiP2pHalInterfaceTest, P2pFlush_SUCCESS, TestSize.Level1)
315 {
316 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().P2pFlush());
317 }
318
319 HWTEST_F(WifiP2pHalInterfaceTest, Connect_SUCCESS, TestSize.Level1)
320 {
321 WifiP2pConfigInternal config;
322 bool isJoinExistingGroup = false;
323 std::string pin;
324 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_INVALID_PARAM,
325 WifiP2PHalInterface::GetInstance().Connect(config, isJoinExistingGroup, pin));
326 config.SetDeviceAddress("00:00:00:00:00:00");
327 WpsInfo wpsInfo;
328 wpsInfo.SetPin("12345678");
329 wpsInfo.SetWpsMethod(WpsMethod::WPS_METHOD_PBC);
330 config.SetWpsInfo(wpsInfo);
331 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_INVALID_PARAM,
332 WifiP2PHalInterface::GetInstance().Connect(config, isJoinExistingGroup, pin));
333 wpsInfo.SetPin("");
334 config.SetWpsInfo(wpsInfo);
335 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_FAILED,
336 WifiP2PHalInterface::GetInstance().Connect(config, isJoinExistingGroup, pin));
337 isJoinExistingGroup = true;
338 EXPECT_EQ(
339 WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().Connect(config, isJoinExistingGroup, pin));
340 }
341
342 HWTEST_F(WifiP2pHalInterfaceTest, CancelConnect_SUCCESS, TestSize.Level1)
343 {
344 WifiP2PHalInterface::GetInstance().CancelConnect();
345 }
346
347 HWTEST_F(WifiP2pHalInterfaceTest, ProvisionDiscovery_SUCCESS, TestSize.Level1)
348 {
349 WifiP2pConfigInternal config;
350 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_FAILED, WifiP2PHalInterface::GetInstance().ProvisionDiscovery(config));
351 }
352
353 HWTEST_F(WifiP2pHalInterfaceTest, AddToGroup_SUCCESS, TestSize.Level1)
354 {
355 bool isPersistent = false;
356 int networkId = 0;
357 int freq = 0;
358 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK,
359 WifiP2PHalInterface::GetInstance().GroupAdd(isPersistent, networkId, freq));
360 }
361
362 HWTEST_F(WifiP2pHalInterfaceTest, RemoveGroup_SUCCESS, TestSize.Level1)
363 {
364 std::string groupInterface;
365 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_FAILED, WifiP2PHalInterface::GetInstance().GroupRemove(groupInterface));
366 }
367
368 HWTEST_F(WifiP2pHalInterfaceTest, Invite_SUCCESS, TestSize.Level1)
369 {
370 WifiP2pGroupInfo group;
371 std::string deviceAddr;
372 EXPECT_NE(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().Invite(group, deviceAddr));
373 }
374
375 HWTEST_F(WifiP2pHalInterfaceTest, Reinvoke_SUCCESS, TestSize.Level1)
376 {
377 int networkId = 13;
378 std::string deviceAddr;
379 EXPECT_NE(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().Reinvoke(networkId, deviceAddr));
380 }
381
382 HWTEST_F(WifiP2pHalInterfaceTest, GetDeviceAddress_SUCCESS, TestSize.Level1)
383 {
384 std::string deviceAddress;
385 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().GetDeviceAddress(deviceAddress));
386 }
387
388 HWTEST_F(WifiP2pHalInterfaceTest, GetGroupCapability_SUCCESS, TestSize.Level1)
389 {
390 std::string deviceAddress;
391 uint32_t capacity = 0;
392 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_FAILED,
393 WifiP2PHalInterface::GetInstance().GetGroupCapability(deviceAddress, capacity));
394 }
395
396 HWTEST_F(WifiP2pHalInterfaceTest, P2pServiceAddTest, TestSize.Level1)
397 {
398 WifiP2pServiceInfo info;
399 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().P2pServiceAdd(info));
400 std::vector<std::string> vec;
401 vec.push_back("upnp 0");
402 info.SetQueryList(vec);
403 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_FAILED, WifiP2PHalInterface::GetInstance().P2pServiceAdd(info));
404 vec.clear();
405 vec.push_back("upnpp 1 letusplaygame");
406 info.SetQueryList(vec);
407 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_FAILED, WifiP2PHalInterface::GetInstance().P2pServiceAdd(info));
408 vec.clear();
409 vec.push_back("upnp 0 letusplaygames");
410 vec.push_back("bonjour from china");
411 info.SetQueryList(vec);
412 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_FAILED, WifiP2PHalInterface::GetInstance().P2pServiceAdd(info));
413 }
414
415 HWTEST_F(WifiP2pHalInterfaceTest, P2pServiceRemoveTest, TestSize.Level1)
416 {
417 WifiP2pServiceInfo info;
418 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().P2pServiceRemove(info));
419 std::vector<std::string> vec;
420 vec.push_back("upnp 0");
421 info.SetQueryList(vec);
422 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_FAILED, WifiP2PHalInterface::GetInstance().P2pServiceRemove(info));
423 vec.clear();
424 vec.push_back("upnpp 1 letusplaygame");
425 info.SetQueryList(vec);
426 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_FAILED, WifiP2PHalInterface::GetInstance().P2pServiceRemove(info));
427 vec.clear();
428 vec.push_back("upnp 0 letusplaygames");
429 vec.push_back("bonjour from china");
430 info.SetQueryList(vec);
431 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_FAILED, WifiP2PHalInterface::GetInstance().P2pServiceRemove(info));
432 }
433
434 HWTEST_F(WifiP2pHalInterfaceTest, FlushService_SUCCESS, TestSize.Level1)
435 {
436 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().FlushService());
437 }
438
439 HWTEST_F(WifiP2pHalInterfaceTest, ReqServiceDiscovery_SUCCESS, TestSize.Level1)
440 {
441 std::string macAddr;
442 std::vector<unsigned char> tlvs;
443 std::string reqID;
444 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_INVALID_PARAM,
445 WifiP2PHalInterface::GetInstance().ReqServiceDiscovery(macAddr, tlvs, reqID));
446 macAddr = "00:00:00:00:00:00";
447 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_INVALID_PARAM,
448 WifiP2PHalInterface::GetInstance().ReqServiceDiscovery(macAddr, tlvs, reqID));
449 tlvs.push_back('a');
450 EXPECT_EQ(
451 WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().ReqServiceDiscovery(macAddr, tlvs, reqID));
452 }
453
454 HWTEST_F(WifiP2pHalInterfaceTest, CancalReqServiceDiscovery_SUCCESS, TestSize.Level1)
455 {
456 std::string id;
457 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_FAILED, WifiP2PHalInterface::GetInstance().CancelReqServiceDiscovery(id));
458 }
459
460 /**
461 * @tc.name: Save p2p config test
462 * @tc.desc: Save config of persistent group test function.
463 * @tc.type: FUNC
464 * @tc.require: issueI5EDUG
465 */
466 HWTEST_F(WifiP2pHalInterfaceTest, StoreConfig_SUCCESS, TestSize.Level1)
467 {
468 WifiP2PHalInterface::GetInstance().SaveConfig();
469 }
470
471 HWTEST_F(WifiP2pHalInterfaceTest, SetRandomMacAddr_SUCCESS, TestSize.Level1)
472 {
473 bool enable = false;
474 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_FAILED, WifiP2PHalInterface::GetInstance().SetRandomMacAddr(enable));
475 }
476
477 HWTEST_F(WifiP2pHalInterfaceTest, SetMiracastType_SUCCESS, TestSize.Level1)
478 {
479 int type = 0;
480 EXPECT_NE(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().SetMiracastMode(type));
481 }
482
483 HWTEST_F(WifiP2pHalInterfaceTest, SetPersistentReconnectTest, TestSize.Level1)
484 {
485 int mode = 0;
486 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().SetPersistentReconnect(mode));
487 }
488
489 HWTEST_F(WifiP2pHalInterfaceTest, RespServiceDiscoveryTest, TestSize.Level1)
490 {
491 WifiP2pDevice device;
492 int frequency = 0;
493 int dialogToken = 0;
494 std::vector<unsigned char> tlvs;
495 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_INVALID_PARAM,
496 WifiP2PHalInterface::GetInstance().RespServiceDiscovery(device, frequency, dialogToken, tlvs));
497 tlvs.push_back(0x01);
498 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_FAILED,
499 WifiP2PHalInterface::GetInstance().RespServiceDiscovery(device, frequency, dialogToken, tlvs));
500 }
501
502 HWTEST_F(WifiP2pHalInterfaceTest, SetServiceDiscoveryExternalTest, TestSize.Level1)
503 {
504 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().SetServiceDiscoveryExternal(false));
505 }
506
507 HWTEST_F(WifiP2pHalInterfaceTest, P2pStop_SUCCESS, TestSize.Level1)
508 {
509 EXPECT_EQ(WifiErrorNo::WIFI_HAL_OPT_OK, WifiP2PHalInterface::GetInstance().StopP2p());
510 }
511 } // namespace Wifi
512 } // namespace OHOS