1 /*
2 * Copyright (c) 2024 Shenzhen Kaihong Digital Industry Development 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
16 #include "wfd_source_scene_test.h"
17 #include "common/sharing_log.h"
18 #include "wfd_session_def.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22 using namespace OHOS::Sharing;
23
24 namespace OHOS {
25 namespace Sharing {
26
SetUpTestCase(void)27 void WfdSourceSceneTest::SetUpTestCase(void)
28 {
29 sourceScene_ = std::make_shared<MockWfdSourceScene>();
30 }
31
TearDownTestCase(void)32 void WfdSourceSceneTest::TearDownTestCase(void)
33 {
34 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), RemoveGroup()).Times(1)
35 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
36 sourceScene_ = nullptr;
37 }
38
SetUp(void)39 void WfdSourceSceneTest::SetUp(void)
40 {
41 }
42
TearDown(void)43 void WfdSourceSceneTest::TearDown(void)
44 {
45 }
46
BackupConnDev(void)47 void WfdSourceSceneTest::BackupConnDev(void)
48 {
49 connectionInfo.mac = sourceScene_->connDev_->mac;
50 connectionInfo.contextId = sourceScene_->connDev_->contextId;
51 connectionInfo.agentId = sourceScene_->connDev_->agentId;
52 }
53
RestoreConnDev(void)54 void WfdSourceSceneTest::RestoreConnDev(void)
55 {
56 sourceScene_->connDev_ = std::make_unique<ConnectionInfo>();
57 sourceScene_->connDev_->mac = connectionInfo.mac;
58 sourceScene_->connDev_->contextId = connectionInfo.contextId;
59 sourceScene_->connDev_->agentId = connectionInfo.agentId;
60 }
61
62 HWTEST_F(WfdSourceSceneTest, Initialize_001, TestSize.Level1)
63 {
64 ASSERT_TRUE(sourceScene_ != nullptr);
65
66 sourceScene_->Initialize();
67 sourceScene_->MockInitialize();
68 }
69
70 HWTEST_F(WfdSourceSceneTest, HandleStartDiscovery_001, TestSize.Level1)
71 {
72 ASSERT_TRUE(sourceScene_ != nullptr);
73
74 std::shared_ptr<WfdSourceStartDiscoveryReq> msg = std::make_shared<WfdSourceStartDiscoveryReq>();
75 std::shared_ptr<WfdCommonRsp> reply = std::make_shared<WfdCommonRsp>();
76 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), GetP2pEnableStatus(_))
77 .WillOnce(DoAll(SetArgReferee<0>(static_cast<int32_t>(Wifi::P2pState::P2P_STATE_NONE)),
78 Return(Wifi::ErrCode::WIFI_OPT_SUCCESS)));
79 EXPECT_CALL(*(sourceScene_->mockIpcAdapter_), SendRequest(_, _))
80 .WillOnce(Return(0));
81
82 int32_t ret = sourceScene_->HandleStartDiscovery(msg, reply);
83 EXPECT_EQ(ret, -1);
84 }
85
86 HWTEST_F(WfdSourceSceneTest, HandleStartDiscovery_002, TestSize.Level1)
87 {
88 ASSERT_TRUE(sourceScene_ != nullptr);
89
90 std::shared_ptr<WfdSourceStartDiscoveryReq> msg = std::make_shared<WfdSourceStartDiscoveryReq>();
91 std::shared_ptr<WfdCommonRsp> reply = std::make_shared<WfdCommonRsp>();
92 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), GetP2pEnableStatus(_))
93 .WillOnce(DoAll(SetArgReferee<0>(static_cast<int32_t>(Wifi::P2pState::P2P_STATE_IDLE)),
94 Return(Wifi::ErrCode::WIFI_OPT_SUCCESS)));
95 EXPECT_CALL(*(sourceScene_->mockIpcAdapter_), SendRequest(_, _))
96 .WillOnce(Return(0));
97
98 int32_t ret = sourceScene_->HandleStartDiscovery(msg, reply);
99 EXPECT_EQ(ret, -1);
100 }
101
102 HWTEST_F(WfdSourceSceneTest, HandleStartDiscovery_003, TestSize.Level1)
103 {
104 ASSERT_TRUE(sourceScene_ != nullptr);
105
106 std::shared_ptr<WfdSourceStartDiscoveryReq> msg = std::make_shared<WfdSourceStartDiscoveryReq>();
107 std::shared_ptr<WfdCommonRsp> reply = std::make_shared<WfdCommonRsp>();
108 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), GetP2pEnableStatus(_))
109 .WillOnce(DoAll(SetArgReferee<0>(static_cast<int32_t>(Wifi::P2pState::P2P_STATE_STARTING)),
110 Return(Wifi::ErrCode::WIFI_OPT_SUCCESS)));
111 EXPECT_CALL(*(sourceScene_->mockIpcAdapter_), SendRequest(_, _))
112 .WillOnce(Return(0));
113
114 int32_t ret = sourceScene_->HandleStartDiscovery(msg, reply);
115 EXPECT_EQ(ret, -1);
116 }
117
118 HWTEST_F(WfdSourceSceneTest, HandleStartDiscovery_004, TestSize.Level1)
119 {
120 ASSERT_TRUE(sourceScene_ != nullptr);
121
122 std::shared_ptr<WfdSourceStartDiscoveryReq> msg = std::make_shared<WfdSourceStartDiscoveryReq>();
123 std::shared_ptr<WfdCommonRsp> reply = std::make_shared<WfdCommonRsp>();
124 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), GetP2pEnableStatus(_))
125 .WillOnce(DoAll(SetArgReferee<0>(static_cast<int32_t>(Wifi::P2pState::P2P_STATE_CLOSING)),
126 Return(Wifi::ErrCode::WIFI_OPT_SUCCESS)));
127 EXPECT_CALL(*(sourceScene_->mockIpcAdapter_), SendRequest(_, _))
128 .WillOnce(Return(0));
129
130 int32_t ret = sourceScene_->HandleStartDiscovery(msg, reply);
131 EXPECT_EQ(ret, -1);
132 }
133
134 HWTEST_F(WfdSourceSceneTest, HandleStartDiscovery_005, TestSize.Level1)
135 {
136 ASSERT_TRUE(sourceScene_ != nullptr);
137
138 std::shared_ptr<WfdSourceStartDiscoveryReq> msg = std::make_shared<WfdSourceStartDiscoveryReq>();
139 std::shared_ptr<WfdCommonRsp> reply = std::make_shared<WfdCommonRsp>();
140 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), GetP2pEnableStatus(_))
141 .WillOnce(DoAll(SetArgReferee<0>(static_cast<int32_t>(Wifi::P2pState::P2P_STATE_STARTED)),
142 Return(Wifi::ErrCode::WIFI_OPT_SUCCESS)));
143 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), RemoveGroup())
144 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
145 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), SetP2pWfdInfo(_))
146 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
147 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), DiscoverDevices()).Times(2)
148 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS))
149 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
150
151 int32_t ret = sourceScene_->HandleStartDiscovery(msg, reply);
152 EXPECT_EQ(ret, 0);
153 }
154
155 HWTEST_F(WfdSourceSceneTest, OnP2pStateChanged_001, TestSize.Level1)
156 {
157 ASSERT_TRUE(sourceScene_ != nullptr);
158 ASSERT_TRUE(sourceScene_->wfdP2pCallback_ != nullptr);
159
160 sptr<MockWfdSourceScene::WfdP2pCallback> wfdP2pCallback = sourceScene_->wfdP2pCallback_;
161 wfdP2pCallback->OnP2pStateChanged(static_cast<int32_t>(Wifi::P2pState::P2P_STATE_NONE));
162 }
163
164 HWTEST_F(WfdSourceSceneTest, OnP2pStateChanged_002, TestSize.Level1)
165 {
166 ASSERT_TRUE(sourceScene_ != nullptr);
167 ASSERT_TRUE(sourceScene_->wfdP2pCallback_ != nullptr);
168
169 sptr<MockWfdSourceScene::WfdP2pCallback> wfdP2pCallback = sourceScene_->wfdP2pCallback_;
170 wfdP2pCallback->OnP2pStateChanged(static_cast<int32_t>(Wifi::P2pState::P2P_STATE_IDLE));
171 }
172
173 HWTEST_F(WfdSourceSceneTest, OnP2pStateChanged_003, TestSize.Level1)
174 {
175 ASSERT_TRUE(sourceScene_ != nullptr);
176 ASSERT_TRUE(sourceScene_->wfdP2pCallback_ != nullptr);
177
178 sptr<MockWfdSourceScene::WfdP2pCallback> wfdP2pCallback = sourceScene_->wfdP2pCallback_;
179 wfdP2pCallback->OnP2pStateChanged(static_cast<int32_t>(Wifi::P2pState::P2P_STATE_STARTING));
180 }
181
182 HWTEST_F(WfdSourceSceneTest, OnP2pStateChanged_004, TestSize.Level1)
183 {
184 ASSERT_TRUE(sourceScene_ != nullptr);
185 ASSERT_TRUE(sourceScene_->wfdP2pCallback_ != nullptr);
186
187 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), RemoveGroup())
188 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
189 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), SetP2pWfdInfo(_))
190 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
191 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), DiscoverDevices())
192 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
193
194 sptr<MockWfdSourceScene::WfdP2pCallback> wfdP2pCallback = sourceScene_->wfdP2pCallback_;
195 wfdP2pCallback->OnP2pStateChanged(static_cast<int32_t>(Wifi::P2pState::P2P_STATE_STARTED));
196 }
197
198 HWTEST_F(WfdSourceSceneTest, OnP2pStateChanged_005, TestSize.Level1)
199 {
200 ASSERT_TRUE(sourceScene_ != nullptr);
201 ASSERT_TRUE(sourceScene_->wfdP2pCallback_ != nullptr);
202
203 sptr<MockWfdSourceScene::WfdP2pCallback> wfdP2pCallback = sourceScene_->wfdP2pCallback_;
204 wfdP2pCallback->OnP2pStateChanged(static_cast<int32_t>(Wifi::P2pState::P2P_STATE_CLOSING));
205 }
206
207 HWTEST_F(WfdSourceSceneTest, OnP2pStateChanged_006, TestSize.Level1)
208 {
209 ASSERT_TRUE(sourceScene_ != nullptr);
210 ASSERT_TRUE(sourceScene_->wfdP2pCallback_ != nullptr);
211
212 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), RemoveGroup()).Times(1)
213 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
214 EXPECT_CALL(*(sourceScene_->mockIpcAdapter_), SendRequest(_, _))
215 .WillOnce(Return(0));
216
217 sptr<MockWfdSourceScene::WfdP2pCallback> wfdP2pCallback = sourceScene_->wfdP2pCallback_;
218 wfdP2pCallback->OnP2pStateChanged(static_cast<int32_t>(Wifi::P2pState::P2P_STATE_CLOSED));
219 }
220
221 HWTEST_F(WfdSourceSceneTest, HandleStartDiscovery_006, TestSize.Level1)
222 {
223 ASSERT_TRUE(sourceScene_ != nullptr);
224
225 std::shared_ptr<WfdSourceStartDiscoveryReq> msg = std::make_shared<WfdSourceStartDiscoveryReq>();
226 std::shared_ptr<WfdCommonRsp> reply = std::make_shared<WfdCommonRsp>();
227 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), GetP2pEnableStatus(_))
228 .WillOnce(DoAll(SetArgReferee<0>(static_cast<int32_t>(Wifi::P2pState::P2P_STATE_CLOSED)),
229 Return(Wifi::ErrCode::WIFI_OPT_SUCCESS)));
230 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), EnableP2p())
231 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
232 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), DiscoverDevices())
233 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
234 EXPECT_CALL(*(sourceScene_->mockIpcAdapter_), SendRequest(_, _))
235 .WillOnce(Return(0));
236
237 int32_t ret = sourceScene_->HandleStartDiscovery(msg, reply);
238 EXPECT_EQ(ret, 0);
239 }
240
241 HWTEST_F(WfdSourceSceneTest, OnDeviceFound_001, TestSize.Level1)
242 {
243 std::vector<WfdCastDeviceInfo> deviceInfos;
244 sourceScene_->OnDeviceFound(deviceInfos);
245 }
246
247 HWTEST_F(WfdSourceSceneTest, OnP2pPeerConnected_001, TestSize.Level1)
248 {
249 ASSERT_TRUE(sourceScene_ != nullptr);
250
251 EXPECT_CALL(*(sourceScene_->mockIpcAdapter_), SendRequest(_, _))
252 .WillOnce(Return(0));
253
254 ConnectionInfo connectionInfo;
255 connectionInfo.mac = "AA.BB.CC.DD.EE.FF";
256 connectionInfo.state = ConnectionState::INIT;
257 sourceScene_->OnP2pPeerConnected(connectionInfo);
258 }
259
260 HWTEST_F(WfdSourceSceneTest, OnP2pPeerConnected_002, TestSize.Level1)
261 {
262 ASSERT_TRUE(sourceScene_ != nullptr);
263
264 ConnectionInfo connectionInfo;
265 connectionInfo.mac = "AA.BB.CC.DD.EE.FF";
266 sourceScene_->OnP2pPeerConnected(connectionInfo);
267 }
268
269 HWTEST_F(WfdSourceSceneTest, OnP2pPeersChanged_001, TestSize.Level1)
270 {
271 ASSERT_TRUE(sourceScene_ != nullptr);
272 ASSERT_TRUE(sourceScene_->wfdP2pCallback_ != nullptr);
273
274 std::vector<Wifi::WifiP2pDevice> devices;
275 Wifi::WifiP2pDevice device;
276 device.SetP2pDeviceStatus(Wifi::P2pDeviceStatus::PDS_AVAILABLE);
277 Wifi::WifiP2pWfdInfo info;
278 info.setSessionAvailable(true);
279 device.SetWfdInfo(info);
280 devices.emplace_back(device);
281 EXPECT_CALL(*(sourceScene_->mockIpcAdapter_), SendRequest(_, _))
282 .WillOnce(Return(0));
283
284 sptr<MockWfdSourceScene::WfdP2pCallback> wfdP2pCallback = sourceScene_->wfdP2pCallback_;
285 wfdP2pCallback->OnP2pPeersChanged(devices);
286 }
287
288 HWTEST_F(WfdSourceSceneTest, OnP2pConnectionChanged_001, TestSize.Level1)
289 {
290 ASSERT_TRUE(sourceScene_ != nullptr);
291 ASSERT_TRUE(sourceScene_->wfdP2pCallback_ != nullptr);
292
293 Wifi::WifiP2pLinkedInfo info;
294 info.SetConnectState(Wifi::P2pConnectedState::P2P_CONNECTED);
295 info.SetIsGroupOwnerAddress("1.1.1.1");
296 Wifi::WifiP2pGroupInfo group;
297 Wifi::WifiP2pDevice device;
298 device.SetDeviceAddress("AA.BB.CC.DD.EE.FF");
299 group.SetOwner(device);
300
301 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), GetCurrentGroup(_))
302 .WillOnce(DoAll(SetArgReferee<0>(group),
303 Return(Wifi::ErrCode::WIFI_OPT_SUCCESS)));
304
305 sptr<MockWfdSourceScene::WfdP2pCallback> wfdP2pCallback = sourceScene_->wfdP2pCallback_;
306 wfdP2pCallback->OnP2pConnectionChanged(info);
307 }
308
309 HWTEST_F(WfdSourceSceneTest, SetCheckWfdConnectionTimer_001, TestSize.Level1)
310 {
311 ASSERT_TRUE(sourceScene_ != nullptr);
312
313 sourceScene_->SetCheckWfdConnectionTimer();
314 }
315
316 HWTEST_F(WfdSourceSceneTest, OnCheckWfdConnection_001, TestSize.Level1)
317 {
318 ASSERT_TRUE(sourceScene_ != nullptr);
319
320 EXPECT_CALL(*(sourceScene_->mockIpcAdapter_), SendRequest(_, _))
321 .WillOnce(Return(0));
322
323 sourceScene_->OnCheckWfdConnection();
324 }
325
326 HWTEST_F(WfdSourceSceneTest, HandleStopDiscovery_001, TestSize.Level1)
327 {
328 ASSERT_TRUE(sourceScene_ != nullptr);
329
330 std::shared_ptr<WfdSourceStopDiscoveryReq> msg = std::make_shared<WfdSourceStopDiscoveryReq>();
331 std::shared_ptr<WfdCommonRsp> reply = std::make_shared<WfdCommonRsp>();
332 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), StopDiscoverDevices())
333 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
334
335 sourceScene_->HandleStopDiscovery(msg, reply);
336 }
337
338 HWTEST_F(WfdSourceSceneTest, HandleAddDevice_001, TestSize.Level1)
339 {
340 ASSERT_TRUE(sourceScene_ != nullptr);
341
342 std::shared_ptr<WfdSourceAddDeviceReq> msg = std::make_shared<WfdSourceAddDeviceReq>();
343 std::shared_ptr<WfdCommonRsp> reply = std::make_shared<WfdCommonRsp>();
344 msg->screenId = 0;
345 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), P2pConnect(_))
346 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
347
348 int32_t ret = sourceScene_->HandleAddDevice(msg, reply);
349 EXPECT_EQ(ret, Wifi::ErrCode::WIFI_OPT_SUCCESS);
350 }
351
352 HWTEST_F(WfdSourceSceneTest, HandleAddDevice_002, TestSize.Level1)
353 {
354 ASSERT_TRUE(sourceScene_ != nullptr);
355
356 std::shared_ptr<WfdSourceAddDeviceReq> msg = std::make_shared<WfdSourceAddDeviceReq>();
357 std::shared_ptr<WfdCommonRsp> reply = std::make_shared<WfdCommonRsp>();
358 msg->screenId = -1;
359
360 int32_t ret = sourceScene_->HandleAddDevice(msg, reply);
361 EXPECT_EQ(ret, ERR_BAD_PARAMETER);
362 }
363
364 HWTEST_F(WfdSourceSceneTest, CreateScreenCapture_001, TestSize.Level1)
365 {
366 ASSERT_TRUE(sourceScene_ != nullptr);
367
368 EXPECT_CALL(*(sourceScene_->mockSharingAdapter_), CreateAgent(_, _, _, _))
369 .WillOnce(DoAll(SetArgReferee<0>(INVALID_ID), SetArgReferee<1>(INVALID_ID), Return(0)));
370
371 int32_t ret = sourceScene_->CreateScreenCapture();
372 EXPECT_EQ(ret, ERR_AGENT_CREATE);
373 }
374
375 HWTEST_F(WfdSourceSceneTest, CreateScreenCapture_002, TestSize.Level1)
376 {
377 ASSERT_TRUE(sourceScene_ != nullptr);
378
379 EXPECT_CALL(*(sourceScene_->mockSharingAdapter_), CreateAgent(_, _, _, _))
380 .WillOnce(DoAll(SetArgReferee<0>(1), SetArgReferee<1>(1), Return(0)));
381 EXPECT_CALL(*(sourceScene_->mockSharingAdapter_), ForwardEvent(_, _, _, _))
382 .WillOnce(Return(0));
383 EXPECT_CALL(*(sourceScene_->mockSharingAdapter_), Start(_, _))
384 .WillOnce(Return(0));
385
386 int32_t ret = sourceScene_->CreateScreenCapture();
387 EXPECT_EQ(ret, ERR_OK);
388 }
389
390 HWTEST_F(WfdSourceSceneTest, HandleDestroyScreenCapture_001, TestSize.Level1)
391 {
392 ASSERT_TRUE(sourceScene_ != nullptr);
393
394 std::shared_ptr<DestroyScreenCaptureReq> msg = std::make_shared<DestroyScreenCaptureReq>();
395 EXPECT_CALL(*(sourceScene_->mockSharingAdapter_), DestroyAgent(_, _))
396 .WillOnce(Return(0));
397
398 int32_t ret = sourceScene_->HandleDestroyScreenCapture(msg);
399 EXPECT_EQ(ret, ERR_OK);
400 }
401
402 HWTEST_F(WfdSourceSceneTest, AppendCast_001, TestSize.Level1)
403 {
404 ASSERT_TRUE(sourceScene_ != nullptr);
405
406 EXPECT_CALL(*(sourceScene_->mockSharingAdapter_), CreateAgent(_, _, _, _))
407 .WillOnce(DoAll(SetArgReferee<0>(1), SetArgReferee<1>(2), Return(0)));
408 EXPECT_CALL(*(sourceScene_->mockSharingAdapter_), ForwardEvent(_, _, _, _))
409 .WillOnce(Return(0));
410 EXPECT_CALL(*(sourceScene_->mockSharingAdapter_), Start(_, _))
411 .WillOnce(Return(0));
412
413 int32_t ret = sourceScene_->AppendCast("AA.BB.CC.DD.EE.FF");
414 EXPECT_EQ(ret, 0);
415 }
416
417 HWTEST_F(WfdSourceSceneTest, AppendCast_002, TestSize.Level1)
418 {
419 ASSERT_TRUE(sourceScene_ != nullptr);
420
421 EXPECT_CALL(*(sourceScene_->mockIpcAdapter_), SendRequest(_, _))
422 .WillOnce(Return(0));
423
424 int32_t ret = sourceScene_->AppendCast("");
425 EXPECT_EQ(ret, -1);
426 }
427
428 HWTEST_F(WfdSourceSceneTest, WfdP2pStart_001, TestSize.Level1)
429 {
430 ASSERT_TRUE(sourceScene_ != nullptr);
431
432 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), RemoveGroup())
433 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
434 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), SetP2pWfdInfo(_))
435 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
436 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), DiscoverDevices())
437 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
438
439 sourceScene_->WfdP2pStart();
440 }
441
442 HWTEST_F(WfdSourceSceneTest, WfdP2pStop_001, TestSize.Level1)
443 {
444 ASSERT_TRUE(sourceScene_ != nullptr);
445
446 EXPECT_CALL(*(sourceScene_->mockSharingAdapter_), ForwardEvent(_, _, _, _))
447 .WillOnce(Return(0));
448 EXPECT_CALL(*(sourceScene_->mockSharingAdapter_), DestroyAgent(_, _))
449 .WillOnce(Return(0));
450 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), RemoveGroup()).Times(1)
451 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
452
453 sourceScene_->WfdP2pStop();
454 }
455
456 HWTEST_F(WfdSourceSceneTest, OnConnectionChanged_001, TestSize.Level1)
457 {
458 ASSERT_TRUE(sourceScene_ != nullptr);
459
460 ConnectionInfo connectionInfo;
461 connectionInfo.state = ConnectionState::INIT;
462
463 EXPECT_CALL(*(sourceScene_->mockIpcAdapter_), SendRequest(_, _))
464 .WillOnce(Return(0));
465
466 sourceScene_->OnConnectionChanged(connectionInfo);
467 }
468
469
470 HWTEST_F(WfdSourceSceneTest, OnP2pPeerDisconnected_001, TestSize.Level1)
471 {
472 ASSERT_TRUE(sourceScene_ != nullptr);
473
474 ConnectionInfo connectionInfo;
475 connectionInfo.mac = "";
476
477 sourceScene_->OnP2pPeerDisconnected(connectionInfo);
478 }
479
480
481 HWTEST_F(WfdSourceSceneTest, OnP2pPeerDisconnected_002, TestSize.Level1)
482 {
483 ASSERT_TRUE(sourceScene_ != nullptr);
484
485 sourceScene_->OnP2pPeerDisconnected("");
486 }
487
488 HWTEST_F(WfdSourceSceneTest, OnP2pPeerDisconnected_003, TestSize.Level1)
489 {
490 ASSERT_TRUE(sourceScene_ != nullptr);
491
492 ConnectionInfo connectionInfo;
493 connectionInfo.mac = "AA.BB.CC.DD.EE.FF";
494
495 EXPECT_CALL(*(sourceScene_->mockIpcAdapter_), SendRequest(_, _))
496 .WillOnce(Return(0));
497 EXPECT_CALL(*(sourceScene_->mockSharingAdapter_), DestroyAgent(_, _))
498 .WillOnce(Return(0));
499 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), RemoveGroup()).Times(1)
500 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
501
502 BackupConnDev();
503 sourceScene_->OnP2pPeerDisconnected(connectionInfo);
504 RestoreConnDev();
505 }
506
507 HWTEST_F(WfdSourceSceneTest, OnP2pPeerDisconnected_004, TestSize.Level1)
508 {
509 ASSERT_TRUE(sourceScene_ != nullptr);
510
511 EXPECT_CALL(*(sourceScene_->mockIpcAdapter_), SendRequest(_, _))
512 .WillOnce(Return(0));
513 EXPECT_CALL(*(sourceScene_->mockSharingAdapter_), DestroyAgent(_, _))
514 .WillOnce(Return(0));
515 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), RemoveGroup()).Times(1)
516 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
517
518 BackupConnDev();
519 sourceScene_->OnP2pPeerDisconnected("AA.BB.CC.DD.EE.FF");
520 RestoreConnDev();
521 }
522
523 HWTEST_F(WfdSourceSceneTest, OnP2pThisDeviceChanged_001, TestSize.Level1)
524 {
525 ASSERT_TRUE(sourceScene_ != nullptr);
526 ASSERT_TRUE(sourceScene_->wfdP2pCallback_ != nullptr);
527
528 Wifi::WifiP2pDevice device;
529 Wifi::WifiP2pLinkedInfo info;
530 info.SetConnectState(Wifi::P2pConnectedState::P2P_DISCONNECTED);
531 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), QueryP2pLinkedInfo(_))
532 .WillOnce(DoAll(SetArgReferee<0>(info),
533 Return(Wifi::ErrCode::WIFI_OPT_SUCCESS)));
534 EXPECT_CALL(*(sourceScene_->mockIpcAdapter_), SendRequest(_, _))
535 .WillOnce(Return(0));
536 EXPECT_CALL(*(sourceScene_->mockSharingAdapter_), DestroyAgent(_, _))
537 .WillOnce(Return(0));
538 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), RemoveGroup()).Times(1)
539 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
540
541 BackupConnDev();
542 sourceScene_->wfdP2pCallback_->OnP2pThisDeviceChanged(device);
543 RestoreConnDev();
544 }
545
546 HWTEST_F(WfdSourceSceneTest, ErrorCodeFiltering_001, TestSize.Level1)
547 {
548 ASSERT_TRUE(sourceScene_ != nullptr);
549 int32_t code = static_cast<int32_t>(ERR_PROSUMER_START);
550 sourceScene_->ErrorCodeFiltering(code);
551 }
552
553 HWTEST_F(WfdSourceSceneTest, ErrorCodeFiltering_002, TestSize.Level1)
554 {
555 ASSERT_TRUE(sourceScene_ != nullptr);
556 int32_t code = static_cast<int32_t>(ERR_PROSUMER_TIMEOUT);
557 sourceScene_->ErrorCodeFiltering(code);
558 }
559
560 HWTEST_F(WfdSourceSceneTest, ErrorCodeFiltering_003, TestSize.Level1)
561 {
562 ASSERT_TRUE(sourceScene_ != nullptr);
563 int32_t code = static_cast<int32_t>(ERR_PROSUMER_DESTROY);
564 sourceScene_->ErrorCodeFiltering(code);
565 }
566
567 HWTEST_F(WfdSourceSceneTest, OnInnerError_001, TestSize.Level1)
568 {
569 ASSERT_TRUE(sourceScene_ != nullptr);
570
571 EXPECT_CALL(*(sourceScene_->mockIpcAdapter_), SendRequest(_, _))
572 .WillOnce(Return(0));
573
574 sourceScene_->OnInnerError(0, 0, SharingErrorCode::ERR_PROSUMER_TIMEOUT, "error");
575 }
576
577 HWTEST_F(WfdSourceSceneTest, OnInnerError_002, TestSize.Level1)
578 {
579 ASSERT_TRUE(sourceScene_ != nullptr);
580
581 EXPECT_CALL(*(sourceScene_->mockIpcAdapter_), SendRequest(_, _))
582 .WillOnce(Return(0));
583
584 sourceScene_->OnInnerError(0, 0, SharingErrorCode::ERR_PROSUMER_INIT, "error");
585 }
586
587 HWTEST_F(WfdSourceSceneTest, OnInnerDestroy_001, TestSize.Level1)
588 {
589 ASSERT_TRUE(sourceScene_ != nullptr);
590
591 EXPECT_CALL(*(sourceScene_->mockIpcAdapter_), SendRequest(_, _))
592 .WillOnce(Return(0));
593
594 sourceScene_->OnInnerDestroy(1, 1, AgentType::SRC_AGENT);
595 }
596
597 HWTEST_F(WfdSourceSceneTest, OnInnerEvent_001, TestSize.Level1)
598 {
599 ASSERT_TRUE(sourceScene_ != nullptr);
600
601 SharingEvent event;
602 auto msg = std::make_shared<WfdSceneEventMsg>();
603 msg->mac = "";
604 msg->type = EventType::EVENT_WFD_NOTIFY_RTSP_PLAYED;
605 event.eventMsg = msg;
606
607 sourceScene_->OnInnerEvent(event);
608 }
609
610 HWTEST_F(WfdSourceSceneTest, OnInnerEvent_002, TestSize.Level1)
611 {
612 ASSERT_TRUE(sourceScene_ != nullptr);
613
614 SharingEvent event;
615 auto msg = std::make_shared<WfdSceneEventMsg>();
616 msg->mac = "AA.BB.CC.DD.EE.FF";
617 msg->type = EventType::EVENT_WFD_NOTIFY_RTSP_PLAYED;
618 event.eventMsg = msg;
619
620 EXPECT_CALL(*(sourceScene_->mockIpcAdapter_), SendRequest(_, _))
621 .WillOnce(Return(0));
622
623 sourceScene_->OnInnerEvent(event);
624 }
625
626 HWTEST_F(WfdSourceSceneTest, OnInnerEvent_003, TestSize.Level1)
627 {
628 ASSERT_TRUE(sourceScene_ != nullptr);
629
630 SharingEvent event;
631 auto msg = std::make_shared<WfdSceneEventMsg>();
632 msg->mac = "";
633 msg->type = EventType::EVENT_WFD_NOTIFY_RTSP_TEARDOWN;
634 event.eventMsg = msg;
635
636 sourceScene_->OnInnerEvent(event);
637 }
638
639 HWTEST_F(WfdSourceSceneTest, OnInnerEvent_004, TestSize.Level1)
640 {
641 ASSERT_TRUE(sourceScene_ != nullptr);
642
643 SharingEvent event;
644 auto msg = std::make_shared<WfdSceneEventMsg>();
645 msg->mac = "AA.BB.CC.DD.EE.FF";
646 msg->type = EventType::EVENT_WFD_NOTIFY_RTSP_TEARDOWN;
647 event.eventMsg = msg;
648
649 EXPECT_CALL(*(sourceScene_->mockIpcAdapter_), SendRequest(_, _))
650 .WillOnce(Return(0));
651 EXPECT_CALL(*(sourceScene_->mockSharingAdapter_), DestroyAgent(_, _))
652 .WillOnce(Return(0));
653 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), RemoveGroup()).Times(1)
654 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
655
656 BackupConnDev();
657 sourceScene_->OnInnerEvent(event);
658 RestoreConnDev();
659 }
660
661 HWTEST_F(WfdSourceSceneTest, OnRemoteDied_001, TestSize.Level1)
662 {
663 ASSERT_TRUE(sourceScene_ != nullptr);
664
665 EXPECT_CALL(*(sourceScene_->mockSharingAdapter_), ReleaseScene(_));
666
667 sourceScene_->OnRemoteDied();
668 }
669
670 HWTEST_F(WfdSourceSceneTest, HandleRemoveDevice_001, TestSize.Level1)
671 {
672 ASSERT_TRUE(sourceScene_ != nullptr);
673
674 std::shared_ptr<WfdSourceRemoveDeviceReq> msg = std::make_shared<WfdSourceRemoveDeviceReq>();
675 std::shared_ptr<WfdCommonRsp> reply = std::make_shared<WfdCommonRsp>();
676 msg->deviceId = "AA.BB.CC.DD.EE.FF";
677 EXPECT_CALL(*(sourceScene_->mockSharingAdapter_), ForwardEvent(_, _, _, _))
678 .WillOnce(Return(0));
679 EXPECT_CALL(*(sourceScene_->mockSharingAdapter_), DestroyAgent(_, _))
680 .WillOnce(Return(0));
681 EXPECT_CALL(*(sourceScene_->mockWifiP2pInstance_), RemoveGroup()).Times(1)
682 .WillOnce(Return(Wifi::ErrCode::WIFI_OPT_SUCCESS));
683
684 BackupConnDev();
685 int32_t ret = sourceScene_->HandleRemoveDevice(msg, reply);
686 RestoreConnDev();
687 EXPECT_EQ(ret, 0);
688 }
689
690 HWTEST_F(WfdSourceSceneTest, HandleRemoveDevice_002, TestSize.Level1)
691 {
692 ASSERT_TRUE(sourceScene_ != nullptr);
693
694 std::shared_ptr<WfdSourceRemoveDeviceReq> msg = std::make_shared<WfdSourceRemoveDeviceReq>();
695 std::shared_ptr<WfdCommonRsp> reply = std::make_shared<WfdCommonRsp>();
696 msg->deviceId = "";
697 int32_t ret = sourceScene_->HandleRemoveDevice(msg, reply);
698 EXPECT_EQ(ret, -1);
699 }
700
701 } // namespace Sharing
702 } // namespace OHOS
703