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_session_test.h"
17 #include "wfd_message.h"
18
19 using namespace testing;
20 using namespace testing::ext;
21 using namespace OHOS::Sharing;
22
23 namespace OHOS {
24 namespace Sharing {
25
SetUpTestCase(void)26 void WfdSourceSessionTest::SetUpTestCase(void)
27 {
28 server_ = std::make_shared<MockServer>();
29 session_ = std::make_shared<MockWfdSourceSession>();
30 listener_ = std::make_shared<MockSessionListener>();
31 networkSession_ = std::make_shared<MockNetworkSession>();
32 networkSessionCb_ = std::make_shared<WfdSourceSession::WfdSourceNetworkSession>(networkSession_, session_);
33 session_->InitSession();
34 session_->SetServer(server_);
35 session_->SetSessionListener(listener_);
36 networkSession_->RegisterCallback(networkSessionCb_);
37 }
38
TearDownTestCase(void)39 void WfdSourceSessionTest::TearDownTestCase(void)
40 {
41 EXPECT_CALL(*server_, Stop());
42
43 server_ = nullptr;
44 session_ = nullptr;
45 listener_ = nullptr;
46 networkSession_ = nullptr;
47 networkSessionCb_ = nullptr;
48 }
49
SetUp(void)50 void WfdSourceSessionTest::SetUp(void)
51 {
52 }
53
TearDown(void)54 void WfdSourceSessionTest::TearDown(void)
55 {
56 }
57
58 HWTEST_F(WfdSourceSessionTest, SetKeepAliveTimer_001, TestSize.Level1)
59 {
60 ASSERT_TRUE(networkSessionCb_ != nullptr);
61 networkSessionCb_->SetKeepAliveTimer();
62 }
63
64 HWTEST_F(WfdSourceSessionTest, UnsetKeepAliveTimer_001, TestSize.Level1)
65 {
66 ASSERT_TRUE(networkSessionCb_ != nullptr);
67 networkSessionCb_->UnsetKeepAliveTimer();
68 }
69
70 HWTEST_F(WfdSourceSessionTest, OnSessionWriteable_001, TestSize.Level1)
71 {
72 ASSERT_TRUE(networkSessionCb_ != nullptr);
73 networkSessionCb_->OnSessionWriteable(0);
74 }
75
76 HWTEST_F(WfdSourceSessionTest, OnSessionClose_001, TestSize.Level1)
77 {
78 ASSERT_TRUE(networkSessionCb_ != nullptr);
79 ASSERT_TRUE(listener_ != nullptr);
80
81 EXPECT_CALL(*listener_, OnSessionNotify(_));
82
83 networkSessionCb_->OnSessionClose(0);
84 }
85
86 HWTEST_F(WfdSourceSessionTest, OnSessionException_001, TestSize.Level1)
87 {
88 ASSERT_TRUE(networkSessionCb_ != nullptr);
89 ASSERT_TRUE(listener_ != nullptr);
90
91 EXPECT_CALL(*listener_, OnSessionNotify(_));
92
93 networkSessionCb_->OnSessionException(0);
94 }
95
96 HWTEST_F(WfdSourceSessionTest, OnSendKeepAlive_001, TestSize.Level1)
97 {
98 ASSERT_TRUE(networkSessionCb_ != nullptr);
99 ASSERT_TRUE(networkSession_ != nullptr);
100
101 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(false));
102
103 networkSessionCb_->OnSendKeepAlive();
104 }
105
106 HWTEST_F(WfdSourceSessionTest, NotifyServiceError_001, TestSize.Level1)
107 {
108 ASSERT_TRUE(session_ != nullptr);
109 ASSERT_TRUE(listener_ != nullptr);
110
111 EXPECT_CALL(*listener_, OnSessionNotify(_));
112
113 session_->NotifyServiceError();
114 }
115
116 HWTEST_F(WfdSourceSessionTest, UpdateOperation_001, TestSize.Level1)
117 {
118 ASSERT_TRUE(session_ != nullptr);
119 ASSERT_TRUE(listener_ != nullptr);
120
121 EXPECT_CALL(*listener_, OnSessionNotify(_));
122
123 auto statusMsg = std::make_shared<SessionStatusMsg>();
124 statusMsg->status = STATE_SESSION_STOPED;
125 auto msg = std::make_shared<EventMsg>();
126 statusMsg->msg = msg;
127 session_->UpdateOperation(statusMsg);
128 }
129
130 HWTEST_F(WfdSourceSessionTest, UpdateOperation_002, TestSize.Level1)
131 {
132 ASSERT_TRUE(session_ != nullptr);
133 ASSERT_TRUE(listener_ != nullptr);
134
135 EXPECT_CALL(*listener_, OnSessionNotify(_));
136
137 auto statusMsg = std::make_shared<SessionStatusMsg>();
138 statusMsg->status = STATE_SESSION_PAUSED;
139 auto msg = std::make_shared<EventMsg>();
140 statusMsg->msg = msg;
141 session_->UpdateOperation(statusMsg);
142 }
143
144 HWTEST_F(WfdSourceSessionTest, UpdateOperation_003, TestSize.Level1)
145 {
146 ASSERT_TRUE(session_ != nullptr);
147 ASSERT_TRUE(listener_ != nullptr);
148
149 EXPECT_CALL(*listener_, OnSessionNotify(_));
150
151 auto statusMsg = std::make_shared<SessionStatusMsg>();
152 statusMsg->status = STATE_SESSION_RESUMED;
153 auto msg = std::make_shared<EventMsg>();
154 statusMsg->msg = msg;
155 session_->UpdateOperation(statusMsg);
156 }
157
158 HWTEST_F(WfdSourceSessionTest, UpdateOperation_004, TestSize.Level1)
159 {
160 ASSERT_TRUE(session_ != nullptr);
161 ASSERT_TRUE(listener_ != nullptr);
162
163 EXPECT_CALL(*listener_, OnSessionNotify(_));
164
165 auto statusMsg = std::make_shared<SessionStatusMsg>();
166 statusMsg->status = STATE_SESSION_DESTROYED;
167 auto msg = std::make_shared<EventMsg>();
168 statusMsg->msg = msg;
169 session_->UpdateOperation(statusMsg);
170 }
171
172 HWTEST_F(WfdSourceSessionTest, NotifyProsumerInit_001, TestSize.Level1)
173 {
174 ASSERT_TRUE(session_ != nullptr);
175 ASSERT_TRUE(listener_ != nullptr);
176
177 EXPECT_CALL(*listener_, OnSessionNotify(_));
178
179 auto statusMsg = std::make_shared<SessionStatusMsg>();
180 statusMsg->status = STATE_SESSION_DESTROYED;
181 auto msg = std::make_shared<EventMsg>();
182 statusMsg->msg = msg;
183 session_->NotifyProsumerInit(statusMsg);
184 }
185
186 HWTEST_F(WfdSourceSessionTest, HandleEvent_001, TestSize.Level1)
187 {
188 ASSERT_TRUE(session_ != nullptr);
189
190 SharingEvent event;
191 auto msg = std::make_shared<WfdSourceSessionEventMsg>();
192 msg->type = EventType::EVENT_SESSION_INIT;
193 event.eventMsg = msg;
194 int32_t ret = session_->HandleEvent(event);
195 EXPECT_EQ(ret, 0);
196 }
197
198 HWTEST_F(WfdSourceSessionTest, HandleEvent_002, TestSize.Level1)
199 {
200 ASSERT_TRUE(session_ != nullptr);
201 ASSERT_TRUE(listener_ != nullptr);
202
203 EXPECT_CALL(*listener_, OnSessionNotify(_));
204
205 SharingEvent event;
206 auto msg = std::make_shared<WfdSourceSessionEventMsg>();
207 msg->type = EventType::EVENT_WFD_STATE_MEDIA_INIT;
208 event.eventMsg = msg;
209 int32_t ret = session_->HandleEvent(event);
210 EXPECT_EQ(ret, 0);
211 }
212
213 HWTEST_F(WfdSourceSessionTest, HandleEvent_003, TestSize.Level1)
214 {
215 ASSERT_TRUE(session_ != nullptr);
216
217 SharingEvent event;
218 auto msg = std::make_shared<WfdSourceSessionEventMsg>();
219 msg->type = EventType::EVENT_AGENT_KEYMODE_STOP;
220 event.eventMsg = msg;
221 int32_t ret = session_->HandleEvent(event);
222 EXPECT_EQ(ret, 0);
223 }
224
225 HWTEST_F(WfdSourceSessionTest, HandleEvent_004, TestSize.Level1)
226 {
227 ASSERT_TRUE(session_ != nullptr);
228
229 SharingEvent event;
230 auto msg = std::make_shared<WfdSourceSessionEventMsg>();
231 msg->type = EventType::EVENT_SESSION_TEARDOWN;
232 event.eventMsg = msg;
233 int32_t ret = session_->HandleEvent(event);
234 EXPECT_EQ(ret, 0);
235 }
236
237 HWTEST_F(WfdSourceSessionTest, OnServerReadData_001, TestSize.Level1)
238 {
239 ASSERT_TRUE(session_ != nullptr);
240 ASSERT_TRUE(networkSession_ != nullptr);
241
242 RtspResponse response;
243 std::string rspMsg(response.Stringify());
244 auto buf = std::make_shared<DataBuffer>();
245 buf->Assign(rspMsg.c_str(), rspMsg.size());
246
247 session_->OnServerReadData(1, buf, networkSession_);
248 }
249
250 HWTEST_F(WfdSourceSessionTest, OnServerReadData_002, TestSize.Level1)
251 {
252 ASSERT_TRUE(session_ != nullptr);
253 ASSERT_TRUE(networkSession_ != nullptr);
254
255 EXPECT_CALL(*networkSession_, Send(_, _)).Times(2)
256 .WillOnce(Return(true))
257 .WillOnce(Return(true));
258
259 RtspRequest request;
260 request.SetMethod(RTSP_METHOD_OPTIONS);
261 std::string reqMsg(request.Stringify());
262 auto buf = std::make_shared<DataBuffer>();
263 buf->Assign(reqMsg.c_str(), reqMsg.size());
264
265 session_->OnServerReadData(1, buf, networkSession_);
266 }
267
268 HWTEST_F(WfdSourceSessionTest, OnServerReadData_003, TestSize.Level1)
269 {
270 ASSERT_TRUE(session_ != nullptr);
271 ASSERT_TRUE(networkSession_ != nullptr);
272
273 RtspRequest request;
274 std::string reqMsg(request.Stringify());
275 auto buf = std::make_shared<DataBuffer>();
276 buf->Assign(reqMsg.c_str(), reqMsg.size());
277
278 session_->OnServerReadData(1, buf, networkSession_);
279 }
280
281 HWTEST_F(WfdSourceSessionTest, HandleRequest_001, TestSize.Level1)
282 {
283 ASSERT_TRUE(session_ != nullptr);
284 ASSERT_TRUE(networkSession_ != nullptr);
285
286 EXPECT_CALL(*networkSession_, Send(_, _)).Times(2)
287 .WillOnce(Return(true))
288 .WillOnce(Return(false));
289
290 RtspRequest request;
291 request.SetMethod(RTSP_METHOD_OPTIONS);
292 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
293 bool ret = session_->HandleRequest(request, session);
294 EXPECT_EQ(ret, false);
295 }
296
297 HWTEST_F(WfdSourceSessionTest, HandleRequest_002, TestSize.Level1)
298 {
299 ASSERT_TRUE(session_ != nullptr);
300 ASSERT_TRUE(networkSession_ != nullptr);
301
302 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(false));
303
304 RtspRequest request;
305 request.SetMethod(RTSP_METHOD_SETUP);
306 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
307 bool ret = session_->HandleRequest(request, session);
308 EXPECT_EQ(ret, false);
309 }
310
311 HWTEST_F(WfdSourceSessionTest, HandleRequest_003, TestSize.Level1)
312 {
313 ASSERT_TRUE(session_ != nullptr);
314 ASSERT_TRUE(listener_ != nullptr);
315 ASSERT_TRUE(networkSession_ != nullptr);
316 ASSERT_TRUE(networkSessionCb_ != nullptr);
317
318 EXPECT_CALL(*listener_, OnSessionNotify(_));
319 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(false));
320
321 RtspRequest request;
322 request.SetMethod(RTSP_METHOD_PLAY);
323 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
324 bool ret = session_->HandleRequest(request, session);
325 EXPECT_EQ(ret, false);
326 }
327
328 HWTEST_F(WfdSourceSessionTest, HandleRequest_004, TestSize.Level1)
329 {
330 ASSERT_TRUE(session_ != nullptr);
331 ASSERT_TRUE(networkSession_ != nullptr);
332 ASSERT_TRUE(listener_ != nullptr);
333
334 EXPECT_CALL(*listener_, OnSessionNotify(_));
335 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(false));
336
337 RtspRequest request;
338 request.SetMethod(RTSP_METHOD_PAUSE);
339 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
340 bool ret = session_->HandleRequest(request, session);
341 EXPECT_EQ(ret, false);
342 }
343
344 HWTEST_F(WfdSourceSessionTest, HandleRequest_005, TestSize.Level1)
345 {
346 ASSERT_TRUE(session_ != nullptr);
347 ASSERT_TRUE(networkSession_ != nullptr);
348 ASSERT_TRUE(listener_ != nullptr);
349
350 EXPECT_CALL(*listener_, OnSessionNotify(_));
351 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(false));
352
353 RtspRequest request;
354 request.SetMethod(RTSP_METHOD_TEARDOWN);
355 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
356 bool ret = session_->HandleRequest(request, session);
357 EXPECT_EQ(ret, false);
358 }
359
360 HWTEST_F(WfdSourceSessionTest, HandleRequest_006, TestSize.Level1)
361 {
362 ASSERT_TRUE(session_ != nullptr);
363 ASSERT_TRUE(networkSession_ != nullptr);
364
365 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(false));
366
367 RtspRequestParameter request;
368 request.SetSession(session_->sessionID_);
369 request.SetMethod(RTSP_METHOD_SET_PARAMETER);
370 request.AddBodyItem(WFD_PARAM_IDR_REQUEST);
371 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
372 bool ret = session_->HandleRequest(request, session);
373 EXPECT_EQ(ret, false);
374 }
375
376 HWTEST_F(WfdSourceSessionTest, HandleResponse_001, TestSize.Level1)
377 {
378 ASSERT_TRUE(session_ != nullptr);
379 ASSERT_TRUE(networkSession_ != nullptr);
380
381 RtspResponse response(session_->cseq_, RTSP_STATUS_OK);
382 response.SetSession(session_->sessionID_);
383 std::string message = "";
384 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
385 bool ret = session_->HandleResponse(response, message, session);
386 EXPECT_EQ(ret, true);
387 }
388
389 HWTEST_F(WfdSourceSessionTest, HandleResponse_002, TestSize.Level1)
390 {
391 ASSERT_TRUE(session_ != nullptr);
392 ASSERT_TRUE(networkSession_ != nullptr);
393
394 RtspResponse response(session_->cseq_, RTSP_STATUS_OK);
395 response.SetSession(session_->sessionID_);
396 std::string message = "";
397 session_->SetWfdState(MockWfdSourceSession::WfdSessionState::M1);
398 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
399 bool ret = session_->HandleResponse(response, message, session);
400 EXPECT_EQ(ret, false);
401 }
402
403 HWTEST_F(WfdSourceSessionTest, HandleResponse_003, TestSize.Level1)
404 {
405 ASSERT_TRUE(session_ != nullptr);
406 ASSERT_TRUE(networkSession_ != nullptr);
407
408 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(false));
409
410 WfdRtspM3Response response(session_->cseq_, RTSP_STATUS_OK);
411 response.SetSession(session_->sessionID_);
412 response.SetVideoFormats(VIDEO_1920X1080_30);
413 std::string message(response.Stringify());
414 session_->SetWfdState(MockWfdSourceSession::WfdSessionState::M3);
415 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
416 bool ret = session_->HandleResponse(response, message, session);
417 EXPECT_EQ(ret, false);
418 }
419
420 HWTEST_F(WfdSourceSessionTest, HandleResponse_004, TestSize.Level1)
421 {
422 ASSERT_TRUE(session_ != nullptr);
423 ASSERT_TRUE(networkSession_ != nullptr);
424
425 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(false));
426
427 WfdRtspM4Response response(session_->cseq_, RTSP_STATUS_OK);
428 response.SetSession(session_->sessionID_);
429 std::string message(response.Stringify());
430 session_->SetWfdState(MockWfdSourceSession::WfdSessionState::M4);
431 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
432 bool ret = session_->HandleResponse(response, message, session);
433 EXPECT_EQ(ret, false);
434 }
435
436 HWTEST_F(WfdSourceSessionTest, HandleResponse_005, TestSize.Level1)
437 {
438 ASSERT_TRUE(session_ != nullptr);
439 ASSERT_TRUE(networkSession_ != nullptr);
440 ASSERT_TRUE(listener_ != nullptr);
441
442 EXPECT_CALL(*listener_, OnSessionNotify(_));
443 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(true));
444
445 WfdRtspM4Response response(session_->cseq_, RTSP_STATUS_OK);
446 response.SetSession(session_->sessionID_);
447 std::string message(response.Stringify());
448 session_->SetWfdState(MockWfdSourceSession::WfdSessionState::M4);
449 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
450 bool ret = session_->HandleResponse(response, message, session);
451 EXPECT_EQ(ret, true);
452 }
453
454 HWTEST_F(WfdSourceSessionTest, HandleResponse_006, TestSize.Level1)
455 {
456 ASSERT_TRUE(session_ != nullptr);
457 ASSERT_TRUE(networkSession_ != nullptr);
458
459 WfdRtspM5Response response(session_->cseq_, RTSP_STATUS_OK);
460 response.SetSession(session_->sessionID_);
461 std::string message(response.Stringify());
462 session_->SetWfdState(MockWfdSourceSession::WfdSessionState::M5);
463 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
464 bool ret = session_->HandleResponse(response, message, session);
465 EXPECT_EQ(ret, true);
466 }
467
468 HWTEST_F(WfdSourceSessionTest, HandleResponse_007, TestSize.Level1)
469 {
470 ASSERT_TRUE(session_ != nullptr);
471 ASSERT_TRUE(networkSession_ != nullptr);
472
473 RtspResponse response(session_->cseq_, RTSP_STATUS_OK);
474 response.SetSession(session_->sessionID_);
475 std::string message(response.Stringify());
476 session_->SetWfdState(MockWfdSourceSession::WfdSessionState::M7_WAIT);
477 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
478 bool ret = session_->HandleResponse(response, message, session);
479 EXPECT_EQ(ret, true);
480 }
481
482 HWTEST_F(WfdSourceSessionTest, HandleResponse_008, TestSize.Level1)
483 {
484 ASSERT_TRUE(session_ != nullptr);
485 ASSERT_TRUE(networkSession_ != nullptr);
486
487 RtspResponse response(session_->cseq_, RTSP_STATUS_BAD_REQUEST);
488 response.SetSession(session_->sessionID_);
489 std::string message(response.Stringify());
490 session_->SetWfdState(MockWfdSourceSession::WfdSessionState::M7_WAIT);
491 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
492 bool ret = session_->HandleResponse(response, message, session);
493 EXPECT_EQ(ret, false);
494 }
495
496 HWTEST_F(WfdSourceSessionTest, HandleResponse_009, TestSize.Level1)
497 {
498 ASSERT_TRUE(session_ != nullptr);
499 ASSERT_TRUE(networkSession_ != nullptr);
500 ASSERT_TRUE(listener_ != nullptr);
501
502 EXPECT_CALL(*listener_, OnSessionNotify(_));
503
504 RtspResponse response(session_->cseq_, RTSP_STATUS_OK);
505 response.SetSession(session_->sessionID_);
506 std::string message(response.Stringify());
507 session_->SetWfdState(MockWfdSourceSession::WfdSessionState::M8);
508 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
509 bool ret = session_->HandleResponse(response, message, session);
510 EXPECT_EQ(ret, true);
511 }
512
513 HWTEST_F(WfdSourceSessionTest, SendM2Response_001, TestSize.Level1)
514 {
515 ASSERT_TRUE(session_ != nullptr);
516 ASSERT_TRUE(networkSession_ != nullptr);
517
518 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(false));
519
520 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
521 bool ret = session_->SendM2Response(session_->cseq_, session);
522 EXPECT_EQ(ret, false);
523 }
524
525 HWTEST_F(WfdSourceSessionTest, SendM2Response_002, TestSize.Level1)
526 {
527 ASSERT_TRUE(session_ != nullptr);
528 ASSERT_TRUE(networkSession_ != nullptr);
529
530 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(true));
531
532 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
533 bool ret = session_->SendM2Response(session_->cseq_, session);
534 EXPECT_EQ(ret, true);
535 }
536
537 HWTEST_F(WfdSourceSessionTest, SendM6Response_001, TestSize.Level1)
538 {
539 ASSERT_TRUE(session_ != nullptr);
540 ASSERT_TRUE(networkSession_ != nullptr);
541
542 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(false));
543
544 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
545 bool ret = session_->SendM6Response(session, session_->cseq_);
546 EXPECT_EQ(ret, false);
547 }
548
549 HWTEST_F(WfdSourceSessionTest, SendM6Response_002, TestSize.Level1)
550 {
551 ASSERT_TRUE(session_ != nullptr);
552 ASSERT_TRUE(networkSession_ != nullptr);
553
554 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(true));
555
556 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
557 bool ret = session_->SendM6Response(session, session_->cseq_);
558 EXPECT_EQ(ret, true);
559 }
560
561 HWTEST_F(WfdSourceSessionTest, SendM1Request_001, TestSize.Level1)
562 {
563 ASSERT_TRUE(session_ != nullptr);
564 ASSERT_TRUE(networkSession_ != nullptr);
565
566 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(false));
567
568 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
569 bool ret = session_->SendM1Request(session);
570 EXPECT_EQ(ret, false);
571 }
572
573 HWTEST_F(WfdSourceSessionTest, SendM1Request_002, TestSize.Level1)
574 {
575 ASSERT_TRUE(session_ != nullptr);
576 ASSERT_TRUE(networkSession_ != nullptr);
577
578 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(true));
579
580 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
581 bool ret = session_->SendM1Request(session);
582 EXPECT_EQ(ret, true);
583 }
584
585 HWTEST_F(WfdSourceSessionTest, SendM3Request_001, TestSize.Level1)
586 {
587 ASSERT_TRUE(session_ != nullptr);
588 ASSERT_TRUE(networkSession_ != nullptr);
589
590 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(false));
591
592 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
593 bool ret = session_->SendM3Request(session);
594 EXPECT_EQ(ret, false);
595 }
596
597 HWTEST_F(WfdSourceSessionTest, SendM3Request_002, TestSize.Level1)
598 {
599 ASSERT_TRUE(session_ != nullptr);
600 ASSERT_TRUE(networkSession_ != nullptr);
601
602 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(true));
603
604 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
605 bool ret = session_->SendM3Request(session);
606 EXPECT_EQ(ret, true);
607 }
608
609 HWTEST_F(WfdSourceSessionTest, SendM4Request_001, TestSize.Level1)
610 {
611 ASSERT_TRUE(session_ != nullptr);
612 ASSERT_TRUE(networkSession_ != nullptr);
613
614 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(false));
615
616 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
617 bool ret = session_->SendM4Request(session);
618 EXPECT_EQ(ret, false);
619 }
620
621 HWTEST_F(WfdSourceSessionTest, SendM4Request_002, TestSize.Level1)
622 {
623 ASSERT_TRUE(session_ != nullptr);
624 ASSERT_TRUE(networkSession_ != nullptr);
625
626 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(true));
627
628 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
629 bool ret = session_->SendM4Request(session);
630 EXPECT_EQ(ret, true);
631 }
632
633 HWTEST_F(WfdSourceSessionTest, SendM5Request_001, TestSize.Level1)
634 {
635 ASSERT_TRUE(session_ != nullptr);
636 ASSERT_TRUE(networkSession_ != nullptr);
637
638 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(false));
639
640 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
641 bool ret = session_->SendM5Request(session);
642 EXPECT_EQ(ret, false);
643 }
644
645 HWTEST_F(WfdSourceSessionTest, SendM5Request_002, TestSize.Level1)
646 {
647 ASSERT_TRUE(session_ != nullptr);
648 ASSERT_TRUE(networkSession_ != nullptr);
649
650 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(true));
651
652 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
653 bool ret = session_->SendM5Request(session);
654 EXPECT_EQ(ret, true);
655 }
656
657 HWTEST_F(WfdSourceSessionTest, SendCommonResponse_001, TestSize.Level1)
658 {
659 ASSERT_TRUE(session_ != nullptr);
660 ASSERT_TRUE(networkSession_ != nullptr);
661
662 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(false));
663
664 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
665 bool ret = session_->SendCommonResponse(session_->cseq_, session);
666 EXPECT_EQ(ret, false);
667 }
668
669 HWTEST_F(WfdSourceSessionTest, SendM16Request_001, TestSize.Level1)
670 {
671 ASSERT_TRUE(session_ != nullptr);
672 ASSERT_TRUE(networkSession_ != nullptr);
673
674 EXPECT_CALL(*networkSession_, Send(_, _)).WillOnce(Return(false));
675
676 auto session = static_cast<INetworkSession::Ptr>(networkSession_);
677 bool ret = session_->SendM16Request(session);
678 EXPECT_EQ(ret, false);
679 }
680
681 } // namespace Sharing
682 } // namespace OHOS
683