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_sink_session_test.h"
17
18 using namespace testing;
19 using namespace testing::ext;
20 using namespace OHOS::Sharing;
21
22 namespace OHOS {
23 namespace Sharing {
24
SetUpTestCase(void)25 void WfdSinkSessionTest::SetUpTestCase(void)
26 {
27 client_ = std::make_shared<MockClient>();
28 session_ = std::make_shared<MockWfdSinkSession>();
29 listener_ = std::make_shared<MockSessionListener>();
30 session_->InitSession();
31 session_->SetSessionListener(listener_);
32 }
33
TearDownTestCase(void)34 void WfdSinkSessionTest::TearDownTestCase(void)
35 {
36 EXPECT_CALL(*client_, Disconnect());
37 client_ = nullptr;
38 session_ = nullptr;
39 listener_ = nullptr;
40 }
41
SetUp(void)42 void WfdSinkSessionTest::SetUp(void)
43 {
44 session_->SetClient(client_);
45 }
46
TearDown(void)47 void WfdSinkSessionTest::TearDown(void)
48 {
49 }
50
51 HWTEST_F(WfdSinkSessionTest, HandleEvent_001, TestSize.Level1)
52 {
53 ASSERT_TRUE(session_ != nullptr);
54 ASSERT_TRUE(listener_ != nullptr);
55
56 EXPECT_CALL(*listener_, OnSessionNotify(_));
57
58 SharingEvent event;
59 auto msg = std::make_shared<WfdSinkSessionEventMsg>();
60 msg->type = EventType::EVENT_SESSION_INIT;
61 event.eventMsg = msg;
62 session_->SetInterruptState(true);
63 session_->SetRunningState(SESSION_INTERRUPT);
64 int32_t ret = session_->HandleEvent(event);
65 EXPECT_EQ(ret, 0);
66 }
67
68 HWTEST_F(WfdSinkSessionTest, HandleEvent_002, TestSize.Level1)
69 {
70 ASSERT_TRUE(session_ != nullptr);
71
72 SharingEvent event;
73 auto msg = std::make_shared<WfdSinkSessionEventMsg>();
74 msg->type = EventType::EVENT_SESSION_INIT;
75 event.eventMsg = msg;
76 session_->SetInterruptState(false);
77 session_->SetRunningState(SESSION_START);
78 int32_t ret = session_->HandleEvent(event);
79 EXPECT_EQ(ret, 0);
80 }
81
82 HWTEST_F(WfdSinkSessionTest, HandleEvent_003, TestSize.Level1)
83 {
84 ASSERT_TRUE(session_ != nullptr);
85 ASSERT_TRUE(listener_ != nullptr);
86
87 EXPECT_CALL(*listener_, OnSessionNotify(_));
88
89 SharingEvent event;
90 auto msg = std::make_shared<WfdSinkSessionEventMsg>();
91 msg->type = EventType::EVENT_AGENT_STATE_PROSUMER_INIT;
92 event.eventMsg = msg;
93 session_->SetInterruptState(false);
94 session_->SetRunningState(SESSION_START);
95 int32_t ret = session_->HandleEvent(event);
96 EXPECT_EQ(ret, 0);
97 }
98
99 HWTEST_F(WfdSinkSessionTest, HandleEvent_004, TestSize.Level1)
100 {
101 ASSERT_TRUE(session_ != nullptr);
102 ASSERT_TRUE(client_ != nullptr);
103
104 EXPECT_CALL(*client_, Send(_, _)).WillOnce(Return(false));
105
106 SharingEvent event;
107 auto msg = std::make_shared<WfdSinkSessionEventMsg>();
108 msg->type = EventType::EVENT_AGENT_KEYMODE_STOP;
109 event.eventMsg = msg;
110 session_->rtspSession_ = "session_str";
111 session_->SetInterruptState(false);
112 session_->SetRunningState(SESSION_START);
113 session_->SetWfdState(WfdSinkSession::WfdSessionState::PLAYING);
114 int32_t ret = session_->HandleEvent(event);
115 EXPECT_EQ(ret, 0);
116 }
117
118 HWTEST_F(WfdSinkSessionTest, HandleEvent_005, TestSize.Level1)
119 {
120 ASSERT_TRUE(session_ != nullptr);
121 ASSERT_TRUE(client_ != nullptr);
122
123 EXPECT_CALL(*client_, Send(_, _)).WillOnce(Return(false));
124
125 SharingEvent event;
126 auto msg = std::make_shared<WfdSinkSessionEventMsg>();
127 msg->type = EventType::EVENT_WFD_REQUEST_IDR;
128 event.eventMsg = msg;
129 session_->rtspSession_ = "session_str";
130 session_->SetInterruptState(false);
131 session_->SetRunningState(SESSION_START);
132 session_->SetWfdState(WfdSinkSession::WfdSessionState::PLAYING);
133 int32_t ret = session_->HandleEvent(event);
134 EXPECT_EQ(ret, 0);
135 }
136
137 HWTEST_F(WfdSinkSessionTest, HandleEvent_006, TestSize.Level1)
138 {
139 ASSERT_TRUE(session_ != nullptr);
140
141 SharingEvent event;
142 auto msg = std::make_shared<WfdSinkSessionEventMsg>();
143 msg->type = EventType::EVENT_SESSION_TEARDOWN;
144 event.eventMsg = msg;
145 session_->SetInterruptState(false);
146 session_->SetRunningState(SESSION_START);
147 session_->SetWfdState(MockWfdSinkSession::WfdSessionState::STOPPING);
148 int32_t ret = session_->HandleEvent(event);
149 EXPECT_EQ(ret, 0);
150 }
151
152 HWTEST_F(WfdSinkSessionTest, HandleEvent_007, TestSize.Level1)
153 {
154 ASSERT_TRUE(session_ != nullptr);
155
156 SharingEvent event;
157 auto msg = std::make_shared<WfdSinkSessionEventMsg>();
158 msg->type = EventType::EVENT_SESSION_TEARDOWN;
159 event.eventMsg = msg;
160 session_->SetInterruptState(false);
161 session_->SetRunningState(SESSION_START);
162 session_->SetWfdState(MockWfdSinkSession::WfdSessionState::PLAYING);
163 session_->SetConnectState(false);
164 int32_t ret = session_->HandleEvent(event);
165 EXPECT_EQ(ret, 0);
166 }
167
168 HWTEST_F(WfdSinkSessionTest, HandleEvent_008, TestSize.Level1)
169 {
170 ASSERT_TRUE(session_ != nullptr);
171 ASSERT_TRUE(client_ != nullptr);
172
173 EXPECT_CALL(*client_, Send(_, _)).WillOnce(Return(false));
174
175 SharingEvent event;
176 auto msg = std::make_shared<WfdSinkSessionEventMsg>();
177 msg->type = EventType::EVENT_SESSION_TEARDOWN;
178 event.eventMsg = msg;
179 session_->SetInterruptState(false);
180 session_->SetRunningState(SESSION_START);
181 session_->rtspSession_ = "session_str";
182 session_->SetWfdState(MockWfdSinkSession::WfdSessionState::PLAYING);
183 session_->SetConnectState(true);
184 int32_t ret = session_->HandleEvent(event);
185 EXPECT_EQ(ret, 0);
186 }
187
188 HWTEST_F(WfdSinkSessionTest, HandleEvent_009, TestSize.Level1)
189 {
190 ASSERT_TRUE(session_ != nullptr);
191 ASSERT_TRUE(listener_ != nullptr);
192
193 EXPECT_CALL(*listener_, OnSessionNotify(_));
194
195 SharingEvent event;
196 auto msg = std::make_shared<WfdSinkSessionEventMsg>();
197 msg->type = EventType::EVENT_AGENT_STATE_WRITE_WARNING;
198 event.eventMsg = msg;
199 session_->SetInterruptState(false);
200 session_->SetRunningState(SESSION_START);
201 int32_t ret = session_->HandleEvent(event);
202 EXPECT_EQ(ret, 0);
203 }
204
205 HWTEST_F(WfdSinkSessionTest, UpdateOperation_001, TestSize.Level1)
206 {
207 ASSERT_TRUE(session_ != nullptr);
208 ASSERT_TRUE(listener_ != nullptr);
209
210 EXPECT_CALL(*listener_, OnSessionNotify(_));
211
212 auto statusMsg = std::make_shared<SessionStatusMsg>();
213 auto msg = std::make_shared<EventMsg>();
214 statusMsg->msg = msg;
215 statusMsg->status = SESSION_INTERRUPT;
216 session_->SetInterruptState(true);
217 session_->UpdateOperation(statusMsg);
218 }
219
220 HWTEST_F(WfdSinkSessionTest, UpdateOperation_002, TestSize.Level1)
221 {
222 ASSERT_TRUE(session_ != nullptr);
223 ASSERT_TRUE(listener_ != nullptr);
224
225 EXPECT_CALL(*listener_, OnSessionNotify(_));
226
227 auto statusMsg = std::make_shared<SessionStatusMsg>();
228 auto msg = std::make_shared<EventMsg>();
229 statusMsg->msg = msg;
230 statusMsg->status = SESSION_PAUSE;
231 session_->SetInterruptState(false);
232
233 session_->UpdateOperation(statusMsg);
234 }
235
236 HWTEST_F(WfdSinkSessionTest, UpdateOperation_003, TestSize.Level1)
237 {
238 ASSERT_TRUE(session_ != nullptr);
239 ASSERT_TRUE(listener_ != nullptr);
240
241 EXPECT_CALL(*listener_, OnSessionNotify(_));
242
243 auto statusMsg = std::make_shared<SessionStatusMsg>();
244 auto msg = std::make_shared<EventMsg>();
245 statusMsg->msg = msg;
246 statusMsg->status = SESSION_RESUME;
247 session_->SetInterruptState(false);
248
249 session_->UpdateOperation(statusMsg);
250 }
251
252 HWTEST_F(WfdSinkSessionTest, UpdateOperation_004, TestSize.Level1)
253 {
254 ASSERT_TRUE(session_ != nullptr);
255
256 auto statusMsg = std::make_shared<SessionStatusMsg>();
257 auto msg = std::make_shared<EventMsg>();
258 statusMsg->msg = msg;
259 statusMsg->status = SESSION_INTERRUPT;
260 session_->SetInterruptState(false);
261
262 session_->UpdateOperation(statusMsg);
263 }
264
265 HWTEST_F(WfdSinkSessionTest, UpdateOperation_005, TestSize.Level1)
266 {
267 ASSERT_TRUE(session_ != nullptr);
268 ASSERT_TRUE(listener_ != nullptr);
269 ASSERT_TRUE(client_ != nullptr);
270
271 EXPECT_CALL(*client_, Send(_, _)).WillOnce(Return(false));
272 EXPECT_CALL(*listener_, OnSessionNotify(_));
273
274 auto statusMsg = std::make_shared<SessionStatusMsg>();
275 auto msg = std::make_shared<EventMsg>();
276 statusMsg->msg = msg;
277 statusMsg->status = SESSION_STOP;
278 session_->SetInterruptState(false);
279
280 session_->rtspSession_ = "session_str";
281 session_->SetWfdState(MockWfdSinkSession::WfdSessionState::PLAYING);
282 session_->SetConnectState(true);
283 session_->UpdateOperation(statusMsg);
284 }
285
286 HWTEST_F(WfdSinkSessionTest, UpdateOperation_006, TestSize.Level1)
287 {
288 ASSERT_TRUE(session_ != nullptr);
289 ASSERT_TRUE(listener_ != nullptr);
290
291 EXPECT_CALL(*listener_, OnSessionNotify(_));
292
293 auto statusMsg = std::make_shared<SessionStatusMsg>();
294 auto msg = std::make_shared<EventMsg>();
295 statusMsg->msg = msg;
296 statusMsg->status = SESSION_DESTROY;
297 session_->SetInterruptState(false);
298
299 session_->UpdateOperation(statusMsg);
300 }
301
302 HWTEST_F(WfdSinkSessionTest, UpdateMediaStatus_001, TestSize.Level1)
303 {
304 ASSERT_TRUE(session_ != nullptr);
305 ASSERT_TRUE(listener_ != nullptr);
306
307 EXPECT_CALL(*listener_, OnSessionNotify(_));
308
309 auto statusMsg = std::make_shared<SessionStatusMsg>();
310 auto msg = std::make_shared<EventMsg>();
311 statusMsg->msg = msg;
312 session_->SetRunningState(SESSION_INTERRUPT);
313 session_->SetInterruptState(true);
314 session_->UpdateMediaStatus(statusMsg);
315 }
316
317 HWTEST_F(WfdSinkSessionTest, UpdateMediaStatus_002, TestSize.Level1)
318 {
319 ASSERT_TRUE(session_ != nullptr);
320 ASSERT_TRUE(listener_ != nullptr);
321
322 EXPECT_CALL(*listener_, OnSessionNotify(_));
323
324 auto statusMsg = std::make_shared<SessionStatusMsg>();
325 auto msg = std::make_shared<EventMsg>();
326 statusMsg->msg = msg;
327 statusMsg->status = STATE_PROSUMER_CREATE_SUCCESS;
328 session_->SetRunningState(SESSION_INTERRUPT);
329 session_->SetInterruptState(false);
330
331 session_->UpdateMediaStatus(statusMsg);
332 }
333
334 HWTEST_F(WfdSinkSessionTest, UpdateMediaStatus_003, TestSize.Level1)
335 {
336 ASSERT_TRUE(session_ != nullptr);
337
338 auto statusMsg = std::make_shared<SessionStatusMsg>();
339 auto msg = std::make_shared<EventMsg>();
340 statusMsg->msg = msg;
341 statusMsg->status = STATE_PROSUMER_START_SUCCESS;
342 session_->SetRunningState(SESSION_START);
343 session_->SetInterruptState(false);
344
345 session_->UpdateMediaStatus(statusMsg);
346 }
347
348 HWTEST_F(WfdSinkSessionTest, UpdateMediaStatus_004, TestSize.Level1)
349 {
350 ASSERT_TRUE(session_ != nullptr);
351
352 auto statusMsg = std::make_shared<SessionStatusMsg>();
353 auto msg = std::make_shared<EventMsg>();
354 statusMsg->msg = msg;
355 statusMsg->status = STATE_PROSUMER_STOP_SUCCESS;
356 session_->SetRunningState(SESSION_START);
357 session_->SetInterruptState(false);
358
359 session_->UpdateMediaStatus(statusMsg);
360 }
361
362 HWTEST_F(WfdSinkSessionTest, UpdateMediaStatus_005, TestSize.Level1)
363 {
364 ASSERT_TRUE(session_ != nullptr);
365
366 auto statusMsg = std::make_shared<SessionStatusMsg>();
367 auto msg = std::make_shared<EventMsg>();
368 statusMsg->msg = msg;
369 statusMsg->status = STATE_PROSUMER_DESTROY_SUCCESS;
370 session_->SetRunningState(SESSION_START);
371 session_->SetInterruptState(false);
372
373 session_->UpdateMediaStatus(statusMsg);
374 }
375
376 HWTEST_F(WfdSinkSessionTest, UpdateMediaStatus_00, TestSize.Level1)
377 {
378 ASSERT_TRUE(session_ != nullptr);
379 ASSERT_TRUE(client_ != nullptr);
380
381 EXPECT_CALL(*client_, Send(_, _)).WillOnce(Return(false));
382
383 auto statusMsg = std::make_shared<SessionStatusMsg>();
384 auto msg = std::make_shared<EventMsg>();
385 statusMsg->msg = msg;
386 statusMsg->status = STATE_PROSUMER_RESUME_SUCCESS;
387 session_->SetRunningState(SESSION_START);
388 session_->SetInterruptState(false);
389 session_->SetWfdState(WfdSinkSession::WfdSessionState::PLAYING);
390 session_->rtspSession_ = "session_str";
391
392 session_->UpdateMediaStatus(statusMsg);
393 }
394
395 HWTEST_F(WfdSinkSessionTest, OnClientReadData_001, TestSize.Level1)
396 {
397 ASSERT_TRUE(session_ != nullptr);
398 ASSERT_TRUE(listener_ != nullptr);
399
400 EXPECT_CALL(*listener_, OnSessionNotify(_));
401
402 auto buf = std::make_shared<DataBuffer>();
403 char data[100];
404 buf->Assign(data, 100);
405
406 session_->SetRunningState(SESSION_INTERRUPT);
407 session_->SetInterruptState(true);
408
409 session_->OnClientReadData(0, buf);
410 }
411
412 HWTEST_F(WfdSinkSessionTest, OnClientReadData_002, TestSize.Level1)
413 {
414 ASSERT_TRUE(session_ != nullptr);
415
416 auto buf = std::make_shared<DataBuffer>();
417 char data[100] = {0};
418 buf->Assign(data, 100);
419
420 session_->SetRunningState(SESSION_START);
421 session_->SetInterruptState(false);
422
423 session_->OnClientReadData(0, buf);
424 }
425
426 HWTEST_F(WfdSinkSessionTest, OnClientClose_001, TestSize.Level1)
427 {
428 ASSERT_TRUE(session_ != nullptr);
429 ASSERT_TRUE(listener_ != nullptr);
430
431 EXPECT_CALL(*listener_, OnSessionNotify(_));
432
433 session_->SetRunningState(SESSION_INTERRUPT);
434 session_->SetInterruptState(true);
435
436 session_->OnClientClose(0);
437 }
438
439 HWTEST_F(WfdSinkSessionTest, OnClientClose_002, TestSize.Level1)
440 {
441 ASSERT_TRUE(session_ != nullptr);
442 ASSERT_TRUE(listener_ != nullptr);
443
444 EXPECT_CALL(*listener_, OnSessionNotify(_));
445
446 session_->SetRunningState(SESSION_START);
447 session_->SetInterruptState(false);
448 session_->SetWfdState(WfdSinkSession::WfdSessionState::PLAYING);
449
450 session_->OnClientClose(0);
451 }
452
453 HWTEST_F(WfdSinkSessionTest, HandleRequest_001, TestSize.Level1)
454 {
455 ASSERT_TRUE(session_ != nullptr);
456 ASSERT_TRUE(listener_ != nullptr);
457 ASSERT_TRUE(client_ != nullptr);
458
459 EXPECT_CALL(*client_, Send(_, _)).Times(2)
460 .WillOnce(Return(false))
461 .WillOnce(Return(false));
462 EXPECT_CALL(*listener_, OnSessionNotify(_));
463
464 RtspRequest request;
465 std::string message("req msg");
466 request.SetCSeq(1);
467 request.SetMethod(RTSP_METHOD_OPTIONS);
468
469 session_->HandleRequest(request, message);
470 }
471
472 HWTEST_F(WfdSinkSessionTest, HandleRequest_002, TestSize.Level1)
473 {
474 ASSERT_TRUE(session_ != nullptr);
475 ASSERT_TRUE(client_ != nullptr);
476
477 EXPECT_CALL(*client_, Send(_, _)).Times(1)
478 .WillOnce(Return(false));
479
480 RtspRequest request;
481 std::string message("req msg");
482 request.SetCSeq(1);
483 request.SetMethod(RTSP_METHOD_GET_PARAMETER);
484
485 session_->HandleRequest(request, message);
486 }
487
488 HWTEST_F(WfdSinkSessionTest, HandleRequest_003, TestSize.Level1)
489 {
490 ASSERT_TRUE(session_ != nullptr);
491 ASSERT_TRUE(listener_ != nullptr);
492 ASSERT_TRUE(client_ != nullptr);
493
494 EXPECT_CALL(*client_, Send(_, _)).Times(1)
495 .WillOnce(Return(false));
496 EXPECT_CALL(*listener_, OnSessionNotify(_));
497
498 RtspRequestParameter request;
499 request.AddBodyItem(WFD_PARAM_VIDEO_FORMATS);
500 request.AddBodyItem(WFD_PARAM_AUDIO_CODECS);
501 request.AddBodyItem(WFD_PARAM_RTP_PORTS);
502 request.AddBodyItem(WFD_PARAM_CONTENT_PROTECTION);
503 request.AddBodyItem(WFD_PARAM_COUPLED_SINK);
504 request.AddBodyItem(WFD_PARAM_UIBC_CAPABILITY);
505 request.AddBodyItem(WFD_PARAM_STANDBY_RESUME);
506 std::string message("req msg");
507 request.SetCSeq(1);
508 request.SetMethod(RTSP_METHOD_GET_PARAMETER);
509
510 session_->HandleRequest(request, message);
511 }
512
513 HWTEST_F(WfdSinkSessionTest, HandleRequest_004, TestSize.Level1)
514 {
515 ASSERT_TRUE(session_ != nullptr);
516
517 RtspRequestParameter request;
518 request.AddBodyItem(WFD_PARAM_TRIGGER);
519 std::string message("req msg");
520 request.SetCSeq(1);
521 request.SetMethod(RTSP_METHOD_SET_PARAMETER);
522
523 session_->HandleRequest(request, message);
524 }
525
526 HWTEST_F(WfdSinkSessionTest, HandleRequest_005, TestSize.Level1)
527 {
528 ASSERT_TRUE(session_ != nullptr);
529 ASSERT_TRUE(listener_ != nullptr);
530 ASSERT_TRUE(client_ != nullptr);
531
532 EXPECT_CALL(*client_, Send(_, _)).Times(1)
533 .WillOnce(Return(false));
534 EXPECT_CALL(*listener_, OnSessionNotify(_));
535
536 RtspRequestParameter request;
537 request.AddBodyItem(WFD_PARAM_VIDEO_FORMATS);
538 std::string message("req msg");
539 request.SetCSeq(1);
540 request.SetMethod(RTSP_METHOD_SET_PARAMETER);
541
542 session_->HandleRequest(request, message);
543 }
544
545 HWTEST_F(WfdSinkSessionTest, HandleRequest_006, TestSize.Level1)
546 {
547 ASSERT_TRUE(session_ != nullptr);
548 ASSERT_TRUE(listener_ != nullptr);
549 ASSERT_TRUE(client_ != nullptr);
550
551 EXPECT_CALL(*client_, Send(_, _)).Times(1)
552 .WillOnce(Return(true));
553 EXPECT_CALL(*listener_, OnSessionNotify(_));
554
555 RtspRequestParameter request;
556 request.AddBodyItem(WFD_PARAM_VIDEO_FORMATS);
557 std::string message("req msg");
558 request.SetCSeq(1);
559 request.SetMethod(RTSP_METHOD_SET_PARAMETER);
560
561 session_->HandleRequest(request, message);
562 }
563
564 HWTEST_F(WfdSinkSessionTest, HandleM2Response_001, TestSize.Level1)
565 {
566 ASSERT_TRUE(session_ != nullptr);
567 ASSERT_TRUE(listener_ != nullptr);
568
569 EXPECT_CALL(*listener_, OnSessionNotify(_));
570
571 RtspResponse response(1, RTSP_STATUS_BAD_REQUEST);
572 std::string message("req msg");
573 session_->HandleM2Response(response, message);
574 }
575
576 HWTEST_F(WfdSinkSessionTest, HandleM2Response_002, TestSize.Level1)
577 {
578 ASSERT_TRUE(session_ != nullptr);
579 ASSERT_TRUE(listener_ != nullptr);
580
581 EXPECT_CALL(*listener_, OnSessionNotify(_));
582
583 RtspResponse response(1, RTSP_STATUS_OK);
584 std::string message("req msg");
585 session_->HandleM2Response(response, message);
586 }
587
588 HWTEST_F(WfdSinkSessionTest, HandleM6Response_001, TestSize.Level1)
589 {
590 ASSERT_TRUE(session_ != nullptr);
591 ASSERT_TRUE(listener_ != nullptr);
592
593 EXPECT_CALL(*listener_, OnSessionNotify(_));
594
595 RtspResponse response(1, RTSP_STATUS_BAD_REQUEST);
596 std::string message("req msg");
597 session_->HandleM6Response(response, message);
598 }
599
600 HWTEST_F(WfdSinkSessionTest, HandleM6Response_002, TestSize.Level1)
601 {
602 ASSERT_TRUE(session_ != nullptr);
603 ASSERT_TRUE(listener_ != nullptr);
604 ASSERT_TRUE(client_ != nullptr);
605
606 EXPECT_CALL(*client_, Send(_, _)).Times(1)
607 .WillOnce(Return(false));
608 EXPECT_CALL(*listener_, OnSessionNotify(_));
609
610 RtspResponse response(1, RTSP_STATUS_OK);
611 std::string message("req msg");
612 session_->rtspSession_ = "session_str";
613 session_->HandleM6Response(response, message);
614 }
615
616 HWTEST_F(WfdSinkSessionTest, HandleM7Response_001, TestSize.Level1)
617 {
618 ASSERT_TRUE(session_ != nullptr);
619 ASSERT_TRUE(listener_ != nullptr);
620
621 EXPECT_CALL(*listener_, OnSessionNotify(_));
622
623 RtspResponse response(1, RTSP_STATUS_BAD_REQUEST);
624 std::string message("req msg");
625 session_->HandleM7Response(response, message);
626 }
627
628 HWTEST_F(WfdSinkSessionTest, HandleM7Response_002, TestSize.Level1)
629 {
630 ASSERT_TRUE(session_ != nullptr);
631
632 RtspResponse response(1, RTSP_STATUS_OK);
633 std::string message("req msg");
634 session_->HandleM7Response(response, message);
635 }
636
637 HWTEST_F(WfdSinkSessionTest, HandleM8Response_001, TestSize.Level1)
638 {
639 ASSERT_TRUE(session_ != nullptr);
640 ASSERT_TRUE(listener_ != nullptr);
641
642 EXPECT_CALL(*listener_, OnSessionNotify(_));
643
644 RtspResponse response(1, RTSP_STATUS_BAD_REQUEST);
645 std::string message("req msg");
646 session_->HandleM8Response(response, message);
647 }
648
649 HWTEST_F(WfdSinkSessionTest, HandleM8Response_002, TestSize.Level1)
650 {
651 ASSERT_TRUE(session_ != nullptr);
652 ASSERT_TRUE(listener_ != nullptr);
653
654 EXPECT_CALL(*listener_, OnSessionNotify(_));
655 RtspResponse response(1, RTSP_STATUS_OK);
656 std::string message("req msg");
657 session_->HandleM8Response(response, message);
658 }
659
660 HWTEST_F(WfdSinkSessionTest, SendM1Response_001, TestSize.Level1)
661 {
662 ASSERT_TRUE(session_ != nullptr);
663 ASSERT_TRUE(client_ != nullptr);
664
665 EXPECT_CALL(*client_, Send(_, _)).Times(1)
666 .WillOnce(Return(false));
667
668 bool ret = session_->SendM1Response(1);
669 EXPECT_EQ(ret, false);
670 }
671
672 HWTEST_F(WfdSinkSessionTest, HandleCommonResponse_001, TestSize.Level1)
673 {
674 ASSERT_TRUE(session_ != nullptr);
675 ASSERT_TRUE(listener_ != nullptr);
676
677 EXPECT_CALL(*listener_, OnSessionNotify(_));
678
679 RtspResponse response(1, RTSP_STATUS_BAD_REQUEST);
680 std::string message("req msg");
681 session_->HandleCommonResponse(response, message);
682 }
683
684 HWTEST_F(WfdSinkSessionTest, HandleTriggerMethod_001, TestSize.Level1)
685 {
686 ASSERT_TRUE(session_ != nullptr);
687 ASSERT_TRUE(listener_ != nullptr);
688 ASSERT_TRUE(client_ != nullptr);
689
690 EXPECT_CALL(*client_, Send(_, _)).Times(2)
691 .WillOnce(Return(false))
692 .WillOnce(Return(false));
693 EXPECT_CALL(*listener_, OnSessionNotify(_));
694
695 bool ret = session_->HandleTriggerMethod(1, RTSP_METHOD_SETUP);
696 EXPECT_EQ(ret, true);
697 }
698
699 HWTEST_F(WfdSinkSessionTest, HandleTriggerMethod_002, TestSize.Level1)
700 {
701 ASSERT_TRUE(session_ != nullptr);
702 ASSERT_TRUE(client_ != nullptr);
703
704 EXPECT_CALL(*client_, Send(_, _)).Times(2)
705 .WillOnce(Return(false))
706 .WillOnce(Return(false));
707
708 session_->SetConnectState(true);
709 session_->rtspSession_ = "session_str";
710 bool ret = session_->HandleTriggerMethod(1, RTSP_METHOD_TEARDOWN);
711 EXPECT_EQ(ret, true);
712 }
713
714 HWTEST_F(WfdSinkSessionTest, SendM7Request_001, TestSize.Level1)
715 {
716 ASSERT_TRUE(session_ != nullptr);
717 ASSERT_TRUE(listener_ != nullptr);
718 ASSERT_TRUE(client_ != nullptr);
719
720 EXPECT_CALL(*client_, Send(_, _)).Times(1)
721 .WillOnce(Return(false));
722 EXPECT_CALL(*listener_, OnSessionNotify(_));
723
724 session_->rtspSession_ = "session_str";
725 bool ret = session_->SendM7Request();
726 EXPECT_EQ(ret, false);
727 }
728
729 } // namespace Sharing
730 } // namespace OHOS
731