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 "src_agent_unit_test.h"
17 #include "agent/srcagent/src_agent.h"
18 #include "common/sharing_log.h"
19 using namespace testing::ext;
20
21 namespace OHOS {
22 namespace Sharing {
SetUpTestCase()23 void SrcAgentUnitTest::SetUpTestCase() {}
TearDownTestCase()24 void SrcAgentUnitTest::TearDownTestCase() {}
SetUp()25 void SrcAgentUnitTest::SetUp() {}
TearDown()26 void SrcAgentUnitTest::TearDown() {}
27
28 class AgentListener : public IAgentListener {
29 public:
OnAgentNotify(AgentStatusMsg::Ptr & statusMsg)30 void OnAgentNotify(AgentStatusMsg::Ptr &statusMsg) override {}
31 };
32
33 namespace {
34 HWTEST_F(SrcAgentUnitTest, SrcAgent_001, Function | SmallTest | Level2)
35 {
36 auto srcAgent = std::make_shared<SrcAgent>();
37 ASSERT_TRUE(srcAgent != nullptr);
38 }
39
40 HWTEST_F(SrcAgentUnitTest, SrcAgent_002, Function | SmallTest | Level2)
41 {
42 auto srcAgent = std::make_shared<SrcAgent>();
43 ASSERT_TRUE(srcAgent != nullptr);
44 srcAgent->SetDestroy();
45 }
46
47 HWTEST_F(SrcAgentUnitTest, SrcAgent_003, Function | SmallTest | Level2)
48 {
49 auto srcAgent = std::make_shared<SrcAgent>();
50 ASSERT_TRUE(srcAgent != nullptr);
51 srcAgent->SetDestroy();
52 auto ret = srcAgent->GetDestroy();
53 ASSERT_TRUE(ret);
54 }
55
56 HWTEST_F(SrcAgentUnitTest, SrcAgent_004, Function | SmallTest | Level2)
57 {
58 auto srcAgent = std::make_shared<SrcAgent>();
59 ASSERT_TRUE(srcAgent != nullptr);
60 srcAgent->UpdateMediaChannelId(1);
61 }
62
63 HWTEST_F(SrcAgentUnitTest, SrcAgent_005, Function | SmallTest | Level2)
64 {
65 auto srcAgent = std::make_shared<SrcAgent>();
66 ASSERT_TRUE(srcAgent != nullptr);
67 auto listener = std::make_shared<AgentListener>();
68 ASSERT_TRUE(listener != nullptr);
69 srcAgent->SetAgentListener(listener);
70 }
71
72 HWTEST_F(SrcAgentUnitTest, SrcAgent_006, Function | SmallTest | Level2)
73 {
74 auto srcAgent = std::make_shared<SrcAgent>();
75 ASSERT_TRUE(srcAgent != nullptr);
76 uint32_t mediaChannelId = 1;
77 srcAgent->UpdateMediaChannelId(mediaChannelId);
78 auto ret = srcAgent->GetMediaChannelId();
79 ASSERT_TRUE(ret == mediaChannelId);
80 }
81
82 HWTEST_F(SrcAgentUnitTest, SrcAgent_007, Function | SmallTest | Level2)
83 {
84 auto srcAgent = std::make_shared<SrcAgent>();
85 ASSERT_TRUE(srcAgent != nullptr);
86 auto ret = srcAgent->GetAgentType();
87 ASSERT_TRUE(ret == AgentType::SRC_AGENT);
88 }
89
90 HWTEST_F(SrcAgentUnitTest, SrcAgent_008, Function | SmallTest | Level2)
91 {
92 auto srcAgent = std::make_shared<SrcAgent>();
93 ASSERT_TRUE(srcAgent != nullptr);
94 SharingEvent event;
95 auto eventMsg = std::make_shared<ContextEventMsg>();
96 ASSERT_TRUE(eventMsg != nullptr);
97 event.eventMsg = std::move(eventMsg);
98 event.eventMsg->type = EVENT_AGENT_DESTROY;
99 event.eventMsg->dstId = 0;
100 auto ret = srcAgent->HandleEvent(event);
101 ASSERT_TRUE(ret == 0);
102 }
103
104 HWTEST_F(SrcAgentUnitTest, SrcAgent_009, Function | SmallTest | Level2)
105 {
106 auto srcAgent = std::make_shared<SrcAgent>();
107 ASSERT_TRUE(srcAgent != nullptr);
108 SharingEvent event;
109 event.eventMsg = std::make_shared<ContextEventMsg>();
110 ASSERT_TRUE(event.eventMsg != nullptr);
111 event.eventMsg->type = EVENT_MEDIA_CHANNEL_DESTROY;
112 event.eventMsg->dstId = 0;
113 auto ret = srcAgent->HandleEvent(event);
114 ASSERT_TRUE(ret == 0);
115 }
116
117 HWTEST_F(SrcAgentUnitTest, SrcAgent_010, Function | SmallTest | Level2)
118 {
119 auto srcAgent = std::make_shared<SrcAgent>();
120 ASSERT_TRUE(srcAgent != nullptr);
121 SharingEvent event;
122 event.eventMsg = std::make_shared<ContextEventMsg>();
123 ASSERT_TRUE(event.eventMsg != nullptr);
124 event.eventMsg->type = EVENT_AGENT_PROSUMER_START;
125 event.eventMsg->dstId = 0;
126 auto ret = srcAgent->HandleEvent(event);
127 ASSERT_TRUE(ret == 0);
128 }
129
130 HWTEST_F(SrcAgentUnitTest, SrcAgent_011, Function | SmallTest | Level2)
131 {
132 auto srcAgent = std::make_shared<SrcAgent>();
133 ASSERT_TRUE(srcAgent != nullptr);
134 SharingEvent event;
135 event.eventMsg = std::make_shared<ContextEventMsg>();
136 ASSERT_TRUE(event.eventMsg != nullptr);
137 event.eventMsg->type = EVENT_AGENT_PROSUMER_STOP;
138 event.eventMsg->dstId = 0;
139 auto ret = srcAgent->HandleEvent(event);
140 ASSERT_TRUE(ret == 0);
141 }
142
143 HWTEST_F(SrcAgentUnitTest, SrcAgent_012, Function | SmallTest | Level2)
144 {
145 auto srcAgent = std::make_shared<SrcAgent>();
146 ASSERT_TRUE(srcAgent != nullptr);
147 SharingEvent event;
148 event.eventMsg = std::make_shared<ContextEventMsg>();
149 ASSERT_TRUE(event.eventMsg != nullptr);
150 event.eventMsg->type = EVENT_AGENT_PROSUMER_PAUSE;
151 event.eventMsg->dstId = 0;
152 auto ret = srcAgent->HandleEvent(event);
153 ASSERT_TRUE(ret == 0);
154 }
155
156 HWTEST_F(SrcAgentUnitTest, SrcAgent_013, Function | SmallTest | Level2)
157 {
158 auto srcAgent = std::make_shared<SrcAgent>();
159 ASSERT_TRUE(srcAgent != nullptr);
160 SharingEvent event;
161 event.eventMsg = std::make_shared<ContextEventMsg>();
162 ASSERT_TRUE(event.eventMsg != nullptr);
163 event.eventMsg->type = EVENT_CONFIGURE_CONTEXT;
164 event.eventMsg->dstId = 0;
165 auto ret = srcAgent->HandleEvent(event);
166 ASSERT_TRUE(ret == 0);
167 }
168
169 HWTEST_F(SrcAgentUnitTest, SrcAgent_014, Function | SmallTest | Level2)
170 {
171 auto srcAgent = std::make_shared<SrcAgent>();
172 ASSERT_TRUE(srcAgent != nullptr);
173 const std::string className = "WfdSourceSession";
174 ASSERT_TRUE(srcAgent->CreateSession(className) == ERR_OK);
175 }
176
177 HWTEST_F(SrcAgentUnitTest, SrcAgent_015, Function | SmallTest | Level2)
178 {
179 auto srcAgent = std::make_shared<SrcAgent>();
180 ASSERT_TRUE(srcAgent != nullptr);
181 const std::string className = "";
182 ASSERT_TRUE(srcAgent->CreateSession(className) != ERR_OK);
183 }
184
185 HWTEST_F(SrcAgentUnitTest, SrcAgent_016, Function | SmallTest | Level2)
186 {
187 auto srcAgent = std::make_shared<SrcAgent>();
188 ASSERT_TRUE(srcAgent != nullptr);
189 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
190 ASSERT_TRUE(sessionMsg != nullptr);
191 sessionMsg->msg = std::make_shared<AgentEventMsg>();
192 ASSERT_TRUE(sessionMsg->msg != nullptr);
193 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
194 sessionMsg->className = "";
195 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_START;
196 srcAgent->PushNextStep(sessionMsg);
197 }
198
199 HWTEST_F(SrcAgentUnitTest, SrcAgent_017, Function | SmallTest | Level2)
200 {
201 auto srcAgent = std::make_shared<SrcAgent>();
202 ASSERT_TRUE(srcAgent != nullptr);
203 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
204 ASSERT_TRUE(sessionMsg != nullptr);
205 sessionMsg->msg = std::make_shared<AgentEventMsg>();
206 ASSERT_TRUE(sessionMsg->msg != nullptr);
207 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
208 sessionMsg->className = "";
209 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_STOP;
210 srcAgent->PushNextStep(sessionMsg);
211 }
212
213 HWTEST_F(SrcAgentUnitTest, SrcAgent_018, Function | SmallTest | Level2)
214 {
215 auto srcAgent = std::make_shared<SrcAgent>();
216 ASSERT_TRUE(srcAgent != nullptr);
217 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
218 ASSERT_TRUE(sessionMsg != nullptr);
219 sessionMsg->msg = std::make_shared<AgentEventMsg>();
220 ASSERT_TRUE(sessionMsg->msg != nullptr);
221 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
222 sessionMsg->className = "";
223 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_DESTROY;
224 srcAgent->PushNextStep(sessionMsg);
225 }
226
227 HWTEST_F(SrcAgentUnitTest, SrcAgent_019, Function | SmallTest | Level2)
228 {
229 auto srcAgent = std::make_shared<SrcAgent>();
230 ASSERT_TRUE(srcAgent != nullptr);
231 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
232 ASSERT_TRUE(sessionMsg != nullptr);
233 sessionMsg->msg = std::make_shared<AgentEventMsg>();
234 ASSERT_TRUE(sessionMsg->msg != nullptr);
235 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
236 sessionMsg->className = "";
237 sessionMsg->msg->type = EVENT_AGENT_STATE_PLAY_START;
238 srcAgent->PushNextStep(sessionMsg);
239 }
240
241 HWTEST_F(SrcAgentUnitTest, SrcAgent_020, Function | SmallTest | Level2)
242 {
243 auto srcAgent = std::make_shared<SrcAgent>();
244 ASSERT_TRUE(srcAgent != nullptr);
245 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
246 ASSERT_TRUE(sessionMsg != nullptr);
247 sessionMsg->msg = std::make_shared<AgentEventMsg>();
248 ASSERT_TRUE(sessionMsg->msg != nullptr);
249 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
250 sessionMsg->className = "";
251 sessionMsg->msg->type = EVENT_AGENT_STATE_PLAY_STOP;
252 srcAgent->PushNextStep(sessionMsg);
253 }
254
255 HWTEST_F(SrcAgentUnitTest, SrcAgent_021, Function | SmallTest | Level2)
256 {
257 auto srcAgent = std::make_shared<SrcAgent>();
258 ASSERT_TRUE(srcAgent != nullptr);
259 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
260 ASSERT_TRUE(sessionMsg != nullptr);
261 sessionMsg->msg = std::make_shared<AgentEventMsg>();
262 ASSERT_TRUE(sessionMsg->msg != nullptr);
263 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
264 sessionMsg->className = "";
265 sessionMsg->msg->type = EVENT_AGENT_STATE_CHANNEL_APPENDSURFACE;
266 srcAgent->PushNextStep(sessionMsg);
267 }
268
269 HWTEST_F(SrcAgentUnitTest, SrcAgent_022, Function | SmallTest | Level2)
270 {
271 auto srcAgent = std::make_shared<SrcAgent>();
272 ASSERT_TRUE(srcAgent != nullptr);
273 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
274 ASSERT_TRUE(sessionMsg != nullptr);
275 sessionMsg->msg = std::make_shared<AgentEventMsg>();
276 ASSERT_TRUE(sessionMsg->msg != nullptr);
277 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
278 sessionMsg->className = "";
279 sessionMsg->msg->type = EVENT_AGENT_STATE_CHANNEL_REMOVESURFACE;
280 srcAgent->PushNextStep(sessionMsg);
281 }
282
283 HWTEST_F(SrcAgentUnitTest, SrcAgent_023, Function | SmallTest | Level2)
284 {
285 auto srcAgent = std::make_shared<SrcAgent>();
286 ASSERT_TRUE(srcAgent != nullptr);
287 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
288 ASSERT_TRUE(sessionMsg != nullptr);
289 sessionMsg->msg = std::make_shared<AgentEventMsg>();
290 ASSERT_TRUE(sessionMsg->msg != nullptr);
291 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
292 sessionMsg->className = "";
293 sessionMsg->msg->errorCode = ERR_SESSION_START;
294 srcAgent->HandleSessionError(sessionMsg);
295 }
296
297 HWTEST_F(SrcAgentUnitTest, SrcAgent_024, Function | SmallTest | Level2)
298 {
299 auto srcAgent = std::make_shared<SrcAgent>();
300 ASSERT_TRUE(srcAgent != nullptr);
301 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
302 ASSERT_TRUE(sessionMsg != nullptr);
303 sessionMsg->msg = std::make_shared<AgentEventMsg>();
304 ASSERT_TRUE(sessionMsg->msg != nullptr);
305 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
306 sessionMsg->className = "";
307 sessionMsg->msg->errorCode = ERR_CONNECTION_FAILURE;
308 srcAgent->HandleSessionError(sessionMsg);
309 }
310
311 HWTEST_F(SrcAgentUnitTest, SrcAgent_025, Function | SmallTest | Level2)
312 {
313 auto srcAgent = std::make_shared<SrcAgent>();
314 ASSERT_TRUE(srcAgent != nullptr);
315 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
316 ASSERT_TRUE(sessionMsg != nullptr);
317 sessionMsg->msg = std::make_shared<AgentEventMsg>();
318 ASSERT_TRUE(sessionMsg->msg != nullptr);
319 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
320 sessionMsg->className = "";
321 sessionMsg->msg->errorCode = ERR_INVALID_URL;
322 srcAgent->HandleSessionError(sessionMsg);
323 }
324
325 HWTEST_F(SrcAgentUnitTest, SrcAgent_026, Function | SmallTest | Level2)
326 {
327 auto srcAgent = std::make_shared<SrcAgent>();
328 ASSERT_TRUE(srcAgent != nullptr);
329 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
330 ASSERT_TRUE(sessionMsg != nullptr);
331 sessionMsg->msg = std::make_shared<AgentEventMsg>();
332 ASSERT_TRUE(sessionMsg->msg != nullptr);
333 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
334 sessionMsg->className = "";
335 sessionMsg->msg->errorCode = ERR_DECODE_FORMAT;
336 srcAgent->HandleSessionError(sessionMsg);
337 }
338
339 HWTEST_F(SrcAgentUnitTest, SrcAgent_027, Function | SmallTest | Level2)
340 {
341 auto srcAgent = std::make_shared<SrcAgent>();
342 ASSERT_TRUE(srcAgent != nullptr);
343 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
344 ASSERT_TRUE(sessionMsg != nullptr);
345 sessionMsg->msg = std::make_shared<AgentEventMsg>();
346 ASSERT_TRUE(sessionMsg->msg != nullptr);
347 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
348 sessionMsg->className = "";
349 sessionMsg->msg->errorCode = ERR_UNAUTHORIZED;
350 srcAgent->HandleSessionError(sessionMsg);
351 }
352
353 HWTEST_F(SrcAgentUnitTest, SrcAgent_028, Function | SmallTest | Level2)
354 {
355 auto srcAgent = std::make_shared<SrcAgent>();
356 ASSERT_TRUE(srcAgent != nullptr);
357 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
358 ASSERT_TRUE(sessionMsg != nullptr);
359 sessionMsg->msg = std::make_shared<AgentEventMsg>();
360 ASSERT_TRUE(sessionMsg->msg != nullptr);
361 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
362 sessionMsg->className = "";
363 sessionMsg->msg->errorCode = ERR_INTERACTION_FAILURE;
364 srcAgent->HandleSessionError(sessionMsg);
365 }
366
367 HWTEST_F(SrcAgentUnitTest, SrcAgent_029, Function | SmallTest | Level2)
368 {
369 auto srcAgent = std::make_shared<SrcAgent>();
370 ASSERT_TRUE(srcAgent != nullptr);
371 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
372 ASSERT_TRUE(sessionMsg != nullptr);
373 sessionMsg->msg = std::make_shared<AgentEventMsg>();
374 ASSERT_TRUE(sessionMsg->msg != nullptr);
375 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
376 sessionMsg->className = "";
377 sessionMsg->msg->errorCode = ERR_PROTOCOL_INTERACTION_TIMEOUT;
378 srcAgent->HandleSessionError(sessionMsg);
379 }
380
381 HWTEST_F(SrcAgentUnitTest, SrcAgent_030, Function | SmallTest | Level2)
382 {
383 auto srcAgent = std::make_shared<SrcAgent>();
384 ASSERT_TRUE(srcAgent != nullptr);
385 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
386 ASSERT_TRUE(sessionMsg != nullptr);
387 sessionMsg->msg = std::make_shared<AgentEventMsg>();
388 ASSERT_TRUE(sessionMsg->msg != nullptr);
389 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
390 sessionMsg->className = "";
391 sessionMsg->msg->errorCode = ERR_NETWORK_ERROR;
392 srcAgent->HandleSessionError(sessionMsg);
393 }
394
395 HWTEST_F(SrcAgentUnitTest, SrcAgent_031, Function | SmallTest | Level2)
396 {
397 auto srcAgent = std::make_shared<SrcAgent>();
398 ASSERT_TRUE(srcAgent != nullptr);
399 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
400 ASSERT_TRUE(sessionMsg != nullptr);
401 sessionMsg->msg = std::make_shared<AgentEventMsg>();
402 ASSERT_TRUE(sessionMsg->msg != nullptr);
403 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
404 sessionMsg->className = "";
405 sessionMsg->msg->errorCode = ERR_INTAKE_TIMEOUT;
406 srcAgent->HandleSessionError(sessionMsg);
407 }
408
409 HWTEST_F(SrcAgentUnitTest, SrcAgent_032, Function | SmallTest | Level2)
410 {
411 auto srcAgent = std::make_shared<SrcAgent>();
412 ASSERT_TRUE(srcAgent != nullptr);
413 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
414 ASSERT_TRUE(sessionMsg != nullptr);
415 sessionMsg->msg = std::make_shared<AgentEventMsg>();
416 ASSERT_TRUE(sessionMsg->msg != nullptr);
417 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
418 sessionMsg->className = "";
419 sessionMsg->msg->errorCode = ERR_DECODE_DISABLE_ACCELERATION;
420 srcAgent->HandleSessionError(sessionMsg);
421 }
422
423 HWTEST_F(SrcAgentUnitTest, SrcAgent_033, Function | SmallTest | Level2)
424 {
425 auto srcAgent = std::make_shared<SrcAgent>();
426 ASSERT_TRUE(srcAgent != nullptr);
427 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
428 ASSERT_TRUE(sessionMsg != nullptr);
429 sessionMsg->msg = std::make_shared<AgentEventMsg>();
430 ASSERT_TRUE(sessionMsg->msg != nullptr);
431 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
432 sessionMsg->className = "";
433 sessionMsg->msg->errorCode = ERR_DECODE_DISABLE_ACCELERATION;
434 srcAgent->UpdateSessionStatus(sessionMsg);
435 }
436
437 HWTEST_F(SrcAgentUnitTest, SrcAgent_034, Function | SmallTest | Level2)
438 {
439 auto srcAgent = std::make_shared<SrcAgent>();
440 ASSERT_TRUE(srcAgent != nullptr);
441 const std::string className = "WfdSourceSession";
442 ASSERT_TRUE(srcAgent->CreateSession(className) == ERR_OK);
443 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
444 ASSERT_TRUE(sessionMsg != nullptr);
445 sessionMsg->msg = std::make_shared<AgentEventMsg>();
446 ASSERT_TRUE(sessionMsg->msg != nullptr);
447 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
448 sessionMsg->className = "";
449 sessionMsg->msg->errorCode = ERR_DECODE_DISABLE_ACCELERATION;
450 srcAgent->UpdateSessionStatus(sessionMsg);
451 }
452
453 HWTEST_F(SrcAgentUnitTest, SrcAgent_035, Function | SmallTest | Level2)
454 {
455 auto srcAgent = std::make_shared<SrcAgent>();
456 ASSERT_TRUE(srcAgent != nullptr);
457 srcAgent->PopNextStep(AGENT_STEP_IDLE, AGENT_STATUS_IDLE);
458 }
459
460 HWTEST_F(SrcAgentUnitTest, SrcAgent_036, Function | SmallTest | Level2)
461 {
462 auto srcAgent = std::make_shared<SrcAgent>();
463 ASSERT_TRUE(srcAgent != nullptr);
464 srcAgent->PopNextStep(AGENT_STEP_RESUME, AGENT_STATUS_IDLE);
465 }
466
467 HWTEST_F(SrcAgentUnitTest, SrcAgent_037, Function | SmallTest | Level2)
468 {
469 auto srcAgent = std::make_shared<SrcAgent>();
470 ASSERT_TRUE(srcAgent != nullptr);
471 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
472 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
473 sessionMsg->className = "";
474 srcAgent->OnSessionNotify(sessionMsg);
475 }
476
477 HWTEST_F(SrcAgentUnitTest, SrcAgent_038, Function | SmallTest | Level2)
478 {
479 auto srcAgent = std::make_shared<SrcAgent>();
480 ASSERT_TRUE(srcAgent != nullptr);
481 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
482 ASSERT_TRUE(sessionMsg != nullptr);
483 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_START;
484 sessionMsg->className = "";
485 srcAgent->OnSessionNotify(sessionMsg);
486 }
487
488 HWTEST_F(SrcAgentUnitTest, SrcAgent_039, Function | SmallTest | Level2)
489 {
490 auto srcAgent = std::make_shared<SrcAgent>();
491 ASSERT_TRUE(srcAgent != nullptr);
492 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
493 ASSERT_TRUE(sessionMsg != nullptr);
494 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_STOP;
495 sessionMsg->className = "";
496 srcAgent->OnSessionNotify(sessionMsg);
497 }
498
499 HWTEST_F(SrcAgentUnitTest, SrcAgent_040, Function | SmallTest | Level2)
500 {
501 auto srcAgent = std::make_shared<SrcAgent>();
502 ASSERT_TRUE(srcAgent != nullptr);
503 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
504 ASSERT_TRUE(sessionMsg != nullptr);
505 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_PAUSE;
506 sessionMsg->className = "";
507 srcAgent->OnSessionNotify(sessionMsg);
508 }
509
510 HWTEST_F(SrcAgentUnitTest, SrcAgent_041, Function | SmallTest | Level2)
511 {
512 auto srcAgent = std::make_shared<SrcAgent>();
513 ASSERT_TRUE(srcAgent != nullptr);
514 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
515 ASSERT_TRUE(sessionMsg != nullptr);
516 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_DESTROY;
517 sessionMsg->className = "";
518 srcAgent->OnSessionNotify(sessionMsg);
519 }
520
521 HWTEST_F(SrcAgentUnitTest, SrcAgent_042, Function | SmallTest | Level2)
522 {
523 auto srcAgent = std::make_shared<SrcAgent>();
524 ASSERT_TRUE(srcAgent != nullptr);
525 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
526 ASSERT_TRUE(sessionMsg != nullptr);
527 sessionMsg->status = SessionNotifyStatus::STATE_SESSION_IDLE;
528 sessionMsg->className = "";
529 srcAgent->OnSessionNotify(sessionMsg);
530 }
531
532 HWTEST_F(SrcAgentUnitTest, SrcAgent_043, Function | SmallTest | Level2)
533 {
534 auto srcAgent = std::make_shared<SrcAgent>();
535 ASSERT_TRUE(srcAgent != nullptr);
536 srcAgent->SetRunningStatus(AGENT_STEP_RESUME, AGENT_STATUS_IDLE);
537 }
538
539 HWTEST_F(SrcAgentUnitTest, SrcAgent_044, Function | SmallTest | Level2)
540 {
541 auto srcAgent = std::make_shared<SrcAgent>();
542 ASSERT_TRUE(srcAgent != nullptr);
543 auto ret = srcAgent->GetRunStep(EVENT_AGENT_START);
544 ASSERT_TRUE(ret == AGENT_STEP_START);
545 }
546
547 HWTEST_F(SrcAgentUnitTest, SrcAgent_045, Function | SmallTest | Level2)
548 {
549 auto srcAgent = std::make_shared<SrcAgent>();
550 ASSERT_TRUE(srcAgent != nullptr);
551 auto ret = srcAgent->GetRunStep(EVENT_AGENT_CHANNEL_APPENDSURFACE);
552 ASSERT_TRUE(ret == AGENT_STEP_APPENDSURFACE);
553 }
554
555 HWTEST_F(SrcAgentUnitTest, SrcAgent_046, Function | SmallTest | Level2)
556 {
557 auto srcAgent = std::make_shared<SrcAgent>();
558 ASSERT_TRUE(srcAgent != nullptr);
559 auto ret = srcAgent->GetRunStep(EVENT_AGENT_CHANNEL_REMOVESURFACE);
560 ASSERT_TRUE(ret == AGENT_STEP_REMOVESURFACE);
561 }
562
563 HWTEST_F(SrcAgentUnitTest, SrcAgent_047, Function | SmallTest | Level2)
564 {
565 auto srcAgent = std::make_shared<SrcAgent>();
566 ASSERT_TRUE(srcAgent != nullptr);
567 auto ret = srcAgent->GetRunStep(EVENT_AGENT_PLAY_START);
568 ASSERT_TRUE(ret == AGENT_STEP_PLAY);
569 }
570
571 HWTEST_F(SrcAgentUnitTest, SrcAgent_048, Function | SmallTest | Level2)
572 {
573 auto srcAgent = std::make_shared<SrcAgent>();
574 ASSERT_TRUE(srcAgent != nullptr);
575 auto ret = srcAgent->GetRunStep(EVENT_AGENT_PLAY_STOP);
576 ASSERT_TRUE(ret == AGENT_STEP_PLAYSTOP);
577 }
578
579 HWTEST_F(SrcAgentUnitTest, SrcAgent_049, Function | SmallTest | Level2)
580 {
581 auto srcAgent = std::make_shared<SrcAgent>();
582 ASSERT_TRUE(srcAgent != nullptr);
583 auto ret = srcAgent->GetRunStep(EVENT_AGENT_PROSUMER_ERROR);
584 ASSERT_TRUE(ret == AGENT_STEP_DESTROY);
585 }
586
587 HWTEST_F(SrcAgentUnitTest, SrcAgent_050, Function | SmallTest | Level2)
588 {
589 auto srcAgent = std::make_shared<SrcAgent>();
590 ASSERT_TRUE(srcAgent != nullptr);
591 auto ret = srcAgent->GetRunStep(EVENT_AGENT_DESTROY);
592 ASSERT_TRUE(ret == AGENT_STEP_DESTROY);
593 }
594
595 HWTEST_F(SrcAgentUnitTest, SrcAgent_051, Function | SmallTest | Level2)
596 {
597 auto srcAgent = std::make_shared<SrcAgent>();
598 ASSERT_TRUE(srcAgent != nullptr);
599 auto ret = srcAgent->GetRunStep(EVENT_AGEINT_ACCELERATION_DONE);
600 ASSERT_TRUE(ret == AGENT_STEP_IDLE);
601 }
602
603 HWTEST_F(SrcAgentUnitTest, SrcAgent_052, Function | SmallTest | Level2)
604 {
605 auto srcAgent = std::make_shared<SrcAgent>();
606 ASSERT_TRUE(srcAgent != nullptr);
607 auto ret = srcAgent->GetRunStepWeight(AGENT_STEP_START);
608 ASSERT_TRUE(ret == AGENT_STEP_WEIGHT_START);
609 }
610
611 HWTEST_F(SrcAgentUnitTest, SrcAgent_053, Function | SmallTest | Level2)
612 {
613 auto srcAgent = std::make_shared<SrcAgent>();
614 ASSERT_TRUE(srcAgent != nullptr);
615 auto ret = srcAgent->GetRunStepWeight(AGENT_STEP_APPENDSURFACE);
616 ASSERT_TRUE(ret == AGENT_STEP_WEIGHT_REUSABLE);
617 }
618
619 HWTEST_F(SrcAgentUnitTest, SrcAgent_054, Function | SmallTest | Level2)
620 {
621 auto srcAgent = std::make_shared<SrcAgent>();
622 ASSERT_TRUE(srcAgent != nullptr);
623 auto ret = srcAgent->GetRunStepWeight(AGENT_STEP_REMOVESURFACE);
624 ASSERT_TRUE(ret == AGENT_STEP_WEIGHT_REUSABLE);
625 }
626
627 HWTEST_F(SrcAgentUnitTest, SrcAgent_055, Function | SmallTest | Level2)
628 {
629 auto srcAgent = std::make_shared<SrcAgent>();
630 ASSERT_TRUE(srcAgent != nullptr);
631 auto ret = srcAgent->GetRunStepWeight(AGENT_STEP_PLAY);
632 ASSERT_TRUE(ret == AGENT_STEP_WEIGHT_REUSABLE);
633 }
634
635 HWTEST_F(SrcAgentUnitTest, SrcAgent_056, Function | SmallTest | Level2)
636 {
637 auto srcAgent = std::make_shared<SrcAgent>();
638 ASSERT_TRUE(srcAgent != nullptr);
639 auto ret = srcAgent->GetRunStepWeight(AGENT_STEP_PLAYSTOP);
640 ASSERT_TRUE(ret == AGENT_STEP_WEIGHT_REUSABLE);
641 }
642
643 HWTEST_F(SrcAgentUnitTest, SrcAgent_057, Function | SmallTest | Level2)
644 {
645 auto srcAgent = std::make_shared<SrcAgent>();
646 ASSERT_TRUE(srcAgent != nullptr);
647 auto ret = srcAgent->GetRunStepWeight(AGENT_STEP_DESTROY);
648 ASSERT_TRUE(ret == AGENT_STEP_WEIGHT_DESTROY);
649 }
650
651 HWTEST_F(SrcAgentUnitTest, SrcAgent_058, Function | SmallTest | Level2)
652 {
653 auto srcAgent = std::make_shared<SrcAgent>();
654 ASSERT_TRUE(srcAgent != nullptr);
655 auto ret = srcAgent->GetRunStepWeight(AGENT_STEP_IDLE);
656 ASSERT_TRUE(ret == AGENT_STEP_WEIGHT_IDLE);
657 }
658
659 HWTEST_F(SrcAgentUnitTest, SrcAgent_059, Function | SmallTest | Level2)
660 {
661 auto srcAgent = std::make_shared<SrcAgent>();
662 ASSERT_TRUE(srcAgent != nullptr);
663 SharingEvent event;
664 event.eventMsg = std::make_shared<ContextEventMsg>();
665 ASSERT_TRUE(event.eventMsg != nullptr);
666 event.eventMsg->type = EVENT_AGEINT_ACCELERATION_DONE;
667 event.eventMsg->dstId = 0;
668 bool isCached = false;
669 auto ret = srcAgent->CheckRunStep(event, isCached);
670 ASSERT_TRUE(ret == ERR_OK);
671 }
672
673 HWTEST_F(SrcAgentUnitTest, SrcAgent_060, Function | SmallTest | Level2)
674 {
675 auto srcAgent = std::make_shared<SrcAgent>();
676 ASSERT_TRUE(srcAgent != nullptr);
677 SharingEvent event;
678 event.eventMsg = std::make_shared<ContextEventMsg>();
679 ASSERT_TRUE(event.eventMsg != nullptr);
680 event.eventMsg->type = EVENT_AGENT_CHANNEL_REMOVESURFACE;
681 event.eventMsg->dstId = 0;
682 bool isCached = false;
683 srcAgent->runningStatus_ = AGENT_STATUS_DONE;
684 srcAgent->runStep_ = AGENT_STEP_DESTROY;
685 auto ret = srcAgent->CheckRunStep(event, isCached);
686 ASSERT_TRUE(ret == ERR_GENERAL_ERROR);
687 }
688
689 HWTEST_F(SrcAgentUnitTest, SrcAgent_061, Function | SmallTest | Level2)
690 {
691 auto srcAgent = std::make_shared<SrcAgent>();
692 ASSERT_TRUE(srcAgent != nullptr);
693 SharingEvent event;
694 event.eventMsg = std::make_shared<ContextEventMsg>();
695 ASSERT_TRUE(event.eventMsg != nullptr);
696 event.eventMsg->type = EVENT_AGENT_CHANNEL_REMOVESURFACE;
697 event.eventMsg->dstId = 0;
698 bool isCached = false;
699 srcAgent->runningStatus_ = AGENT_STATUS_DONE;
700 srcAgent->runStep_ = AGENT_STEP_IDLE;
701 auto ret = srcAgent->CheckRunStep(event, isCached);
702 ASSERT_TRUE(ret == ERR_OK);
703 }
704
705 HWTEST_F(SrcAgentUnitTest, SrcAgent_062, Function | SmallTest | Level2)
706 {
707 auto srcAgent = std::make_shared<SrcAgent>();
708 ASSERT_TRUE(srcAgent != nullptr);
709 SharingEvent event;
710 event.eventMsg = std::make_shared<ContextEventMsg>();
711 ASSERT_TRUE(event.eventMsg != nullptr);
712 event.eventMsg->type = EVENT_AGENT_CHANNEL_REMOVESURFACE;
713 event.eventMsg->dstId = 0;
714 bool isCached = false;
715 srcAgent->runningStatus_ = AGENT_STATUS_DONE;
716 srcAgent->runStep_ = AGENT_STEP_PLAY;
717 auto ret = srcAgent->CheckRunStep(event, isCached);
718 ASSERT_TRUE(ret == ERR_OK);
719 }
720
721 HWTEST_F(SrcAgentUnitTest, SrcAgent_063, Function | SmallTest | Level2)
722 {
723 auto srcAgent = std::make_shared<SrcAgent>();
724 ASSERT_TRUE(srcAgent != nullptr);
725 SharingEvent event;
726 event.eventMsg = std::make_shared<ContextEventMsg>();
727 ASSERT_TRUE(event.eventMsg != nullptr);
728 event.eventMsg->type = EVENT_AGENT_CHANNEL_REMOVESURFACE;
729 event.eventMsg->dstId = 0;
730 bool isCached = false;
731 srcAgent->runningStatus_ = AGENT_STATUS_RUNNING;
732 srcAgent->runStep_ = AGENT_STEP_REMOVESURFACE;
733 auto ret = srcAgent->CheckRunStep(event, isCached);
734 ASSERT_TRUE(ret == ERR_GENERAL_ERROR);
735 }
736
737 HWTEST_F(SrcAgentUnitTest, SrcAgent_064, Function | SmallTest | Level2)
738 {
739 auto srcAgent = std::make_shared<SrcAgent>();
740 ASSERT_TRUE(srcAgent != nullptr);
741 SharingEvent event;
742 event.eventMsg = std::make_shared<ContextEventMsg>();
743 ASSERT_TRUE(event.eventMsg != nullptr);
744 event.eventMsg->type = EVENT_AGENT_DESTROY;
745 event.eventMsg->dstId = 0;
746 bool isCached = false;
747 srcAgent->runningStatus_ = AGENT_STATUS_RUNNING;
748 srcAgent->runStep_ = AGENT_STEP_REMOVESURFACE;
749 auto ret = srcAgent->CheckRunStep(event, isCached);
750 ASSERT_TRUE(ret == ERR_OK);
751 }
752
753 HWTEST_F(SrcAgentUnitTest, SrcAgent_065, Function | SmallTest | Level2)
754 {
755 auto srcAgent = std::make_shared<SrcAgent>();
756 ASSERT_TRUE(srcAgent != nullptr);
757 SharingEvent event;
758 event.eventMsg = std::make_shared<ContextEventMsg>();
759 ASSERT_TRUE(event.eventMsg != nullptr);
760 event.eventMsg->type = EVENT_AGENT_DESTROY;
761 event.eventMsg->dstId = 0;
762 bool isCached = false;
763 srcAgent->runningStatus_ = AGENT_STATUS_ERROR;
764 srcAgent->runStep_ = AGENT_STEP_REMOVESURFACE;
765 auto ret = srcAgent->CheckRunStep(event, isCached);
766 ASSERT_TRUE(ret == ERR_OK);
767 }
768
769 HWTEST_F(SrcAgentUnitTest, SrcAgent_066, Function | SmallTest | Level2)
770 {
771 auto srcAgent = std::make_shared<SrcAgent>();
772 ASSERT_TRUE(srcAgent != nullptr);
773 SharingEvent event;
774 event.eventMsg = std::make_shared<ContextEventMsg>();
775 ASSERT_TRUE(event.eventMsg != nullptr);
776 event.eventMsg->type = EVENT_AGENT_CHANNEL_REMOVESURFACE;
777 event.eventMsg->dstId = 0;
778 bool isCached = false;
779 srcAgent->runningStatus_ = AGENT_STATUS_ERROR;
780 srcAgent->runStep_ = AGENT_STEP_REMOVESURFACE;
781 auto ret = srcAgent->CheckRunStep(event, isCached);
782 ASSERT_TRUE(ret == ERR_GENERAL_ERROR);
783 }
784
785 HWTEST_F(SrcAgentUnitTest, SrcAgent_067, Function | SmallTest | Level2)
786 {
787 auto srcAgent = std::make_shared<SrcAgent>();
788 ASSERT_TRUE(srcAgent != nullptr);
789 SharingEvent event;
790 event.eventMsg = std::make_shared<ContextEventMsg>();
791 ASSERT_TRUE(event.eventMsg != nullptr);
792 event.eventMsg->type = EVENT_AGENT_CHANNEL_REMOVESURFACE;
793 event.eventMsg->dstId = 0;
794 bool isCached = false;
795 srcAgent->runningStatus_ = AGENT_STATUS_INTERRUPT;
796 srcAgent->runStep_ = AGENT_STEP_REMOVESURFACE;
797 auto ret = srcAgent->CheckRunStep(event, isCached);
798 ASSERT_TRUE(ret == ERR_OK);
799 }
800
801 HWTEST_F(SrcAgentUnitTest, SrcAgent_068, Function | SmallTest | Level2)
802 {
803 auto srcAgent = std::make_shared<SrcAgent>();
804 ASSERT_TRUE(srcAgent != nullptr);
805 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
806 ASSERT_TRUE(sessionMsg != nullptr);
807 sessionMsg->msg = std::make_shared<AgentEventMsg>();
808 ASSERT_TRUE(sessionMsg->msg != nullptr);
809 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
810 sessionMsg->className = "";
811 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_START;
812 sessionMsg->msg->toMgr = ModuleType::MODULE_MEDIACHANNEL;
813 auto ret = srcAgent->NotifyPrivateEvent(sessionMsg);
814 ASSERT_TRUE(ret == ERR_OK);
815 }
816
817 HWTEST_F(SrcAgentUnitTest, SrcAgent_069, Function | SmallTest | Level2)
818 {
819 auto srcAgent = std::make_shared<SrcAgent>();
820 ASSERT_TRUE(srcAgent != nullptr);
821 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
822 ASSERT_TRUE(sessionMsg != nullptr);
823 sessionMsg->msg = std::make_shared<AgentEventMsg>();
824 ASSERT_TRUE(sessionMsg->msg != nullptr);
825 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
826 sessionMsg->className = "";
827 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_START;
828 sessionMsg->msg->toMgr = ModuleType::MODULE_INTERACTION;
829 auto ret = srcAgent->NotifyPrivateEvent(sessionMsg);
830 ASSERT_TRUE(ret == ERR_OK);
831 }
832
833 HWTEST_F(SrcAgentUnitTest, SrcAgent_070, Function | SmallTest | Level2)
834 {
835 auto srcAgent = std::make_shared<SrcAgent>();
836 ASSERT_TRUE(srcAgent != nullptr);
837 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
838 ASSERT_TRUE(sessionMsg != nullptr);
839 sessionMsg->msg = std::make_shared<AgentEventMsg>();
840 ASSERT_TRUE(sessionMsg->msg != nullptr);
841 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
842 sessionMsg->className = "";
843 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_START;
844 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
845 auto ret = srcAgent->NotifyPrivateEvent(sessionMsg);
846 ASSERT_TRUE(ret == ERR_GENERAL_ERROR);
847 }
848
849 HWTEST_F(SrcAgentUnitTest, SrcAgent_071, Function | SmallTest | Level2)
850 {
851 auto srcAgent = std::make_shared<SrcAgent>();
852 ASSERT_TRUE(srcAgent != nullptr);
853 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
854 ASSERT_TRUE(sessionMsg != nullptr);
855 sessionMsg->msg = std::make_shared<AgentEventMsg>();
856 ASSERT_TRUE(sessionMsg->msg != nullptr);
857 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
858 sessionMsg->className = "";
859 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_START;
860 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
861 srcAgent->HandleProsumerState(sessionMsg);
862 }
863
864 HWTEST_F(SrcAgentUnitTest, SrcAgent_072, Function | SmallTest | Level2)
865 {
866 auto srcAgent = std::make_shared<SrcAgent>();
867 ASSERT_TRUE(srcAgent != nullptr);
868 const std::string className = "WfdSourceSession";
869 ASSERT_TRUE(srcAgent->CreateSession(className) == ERR_OK);
870 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
871 ASSERT_TRUE(sessionMsg != nullptr);
872 sessionMsg->msg = std::make_shared<AgentEventMsg>();
873 ASSERT_TRUE(sessionMsg->msg != nullptr);
874 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
875 sessionMsg->className = "";
876 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_CREATE;
877 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
878 srcAgent->HandleProsumerState(sessionMsg);
879 }
880
881 HWTEST_F(SrcAgentUnitTest, SrcAgent_073, Function | SmallTest | Level2)
882 {
883 auto srcAgent = std::make_shared<SrcAgent>();
884 ASSERT_TRUE(srcAgent != nullptr);
885 const std::string className = "WfdSourceSession";
886 ASSERT_TRUE(srcAgent->CreateSession(className) == ERR_OK);
887 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
888 ASSERT_TRUE(sessionMsg != nullptr);
889 sessionMsg->msg = std::make_shared<AgentEventMsg>();
890 ASSERT_TRUE(sessionMsg->msg != nullptr);
891 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
892 sessionMsg->className = "";
893 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_START;
894 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
895 srcAgent->HandleProsumerState(sessionMsg);
896 }
897
898 HWTEST_F(SrcAgentUnitTest, SrcAgent_074, Function | SmallTest | Level2)
899 {
900 auto srcAgent = std::make_shared<SrcAgent>();
901 ASSERT_TRUE(srcAgent != nullptr);
902 const std::string className = "WfdSourceSession";
903 ASSERT_TRUE(srcAgent->CreateSession(className) == ERR_OK);
904 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
905 ASSERT_TRUE(sessionMsg != nullptr);
906 sessionMsg->msg = std::make_shared<AgentEventMsg>();
907 ASSERT_TRUE(sessionMsg->msg != nullptr);
908 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
909 sessionMsg->className = "";
910 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_STOP;
911 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
912 srcAgent->HandleProsumerState(sessionMsg);
913 }
914
915 HWTEST_F(SrcAgentUnitTest, SrcAgent_075, Function | SmallTest | Level2)
916 {
917 auto srcAgent = std::make_shared<SrcAgent>();
918 ASSERT_TRUE(srcAgent != nullptr);
919 const std::string className = "WfdSourceSession";
920 ASSERT_TRUE(srcAgent->CreateSession(className) == ERR_OK);
921 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
922 ASSERT_TRUE(sessionMsg != nullptr);
923 sessionMsg->msg = std::make_shared<AgentEventMsg>();
924 ASSERT_TRUE(sessionMsg->msg != nullptr);
925 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
926 sessionMsg->className = "";
927 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_PAUSE;
928 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
929 srcAgent->HandleProsumerState(sessionMsg);
930 }
931
932 HWTEST_F(SrcAgentUnitTest, SrcAgent_076, Function | SmallTest | Level2)
933 {
934 auto srcAgent = std::make_shared<SrcAgent>();
935 ASSERT_TRUE(srcAgent != nullptr);
936 const std::string className = "WfdSourceSession";
937 ASSERT_TRUE(srcAgent->CreateSession(className) == ERR_OK);
938 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
939 ASSERT_TRUE(sessionMsg != nullptr);
940 sessionMsg->msg = std::make_shared<AgentEventMsg>();
941 ASSERT_TRUE(sessionMsg->msg != nullptr);
942 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
943 sessionMsg->className = "";
944 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_RESUME;
945 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
946 srcAgent->HandleProsumerState(sessionMsg);
947 }
948
949 HWTEST_F(SrcAgentUnitTest, SrcAgent_077, Function | SmallTest | Level2)
950 {
951 auto srcAgent = std::make_shared<SrcAgent>();
952 ASSERT_TRUE(srcAgent != nullptr);
953 const std::string className = "WfdSourceSession";
954 ASSERT_TRUE(srcAgent->CreateSession(className) == ERR_OK);
955 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
956 ASSERT_TRUE(sessionMsg != nullptr);
957 sessionMsg->msg = std::make_shared<AgentEventMsg>();
958 ASSERT_TRUE(sessionMsg->msg != nullptr);
959 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
960 sessionMsg->className = "";
961 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_DESTROY;
962 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
963 srcAgent->HandleProsumerState(sessionMsg);
964 }
965
966 HWTEST_F(SrcAgentUnitTest, SrcAgent_078, Function | SmallTest | Level2)
967 {
968 auto srcAgent = std::make_shared<SrcAgent>();
969 ASSERT_TRUE(srcAgent != nullptr);
970 const std::string className = "WfdSourceSession";
971 ASSERT_TRUE(srcAgent->CreateSession(className) == ERR_OK);
972 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
973 ASSERT_TRUE(sessionMsg != nullptr);
974 sessionMsg->msg = std::make_shared<AgentEventMsg>();
975 ASSERT_TRUE(sessionMsg->msg != nullptr);
976 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
977 sessionMsg->className = "";
978 sessionMsg->msg->type = EVENT_AGENT_DECODER_DIED;
979 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
980 srcAgent->HandleProsumerState(sessionMsg);
981 }
982
983 HWTEST_F(SrcAgentUnitTest, SrcAgent_079, Function | SmallTest | Level2)
984 {
985 auto srcAgent = std::make_shared<SrcAgent>();
986 ASSERT_TRUE(srcAgent != nullptr);
987 const std::string className = "WfdSourceSession";
988 ASSERT_TRUE(srcAgent->CreateSession(className) == ERR_OK);
989 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
990 ASSERT_TRUE(sessionMsg != nullptr);
991 sessionMsg->msg = std::make_shared<AgentEventMsg>();
992 ASSERT_TRUE(sessionMsg->msg != nullptr);
993 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
994 sessionMsg->className = "";
995 sessionMsg->msg->errorCode = ERR_PROSUMER_INIT;
996 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
997 srcAgent->HandleProsumerError(sessionMsg);
998 }
999
1000 HWTEST_F(SrcAgentUnitTest, SrcAgent_080, Function | SmallTest | Level2)
1001 {
1002 auto srcAgent = std::make_shared<SrcAgent>();
1003 ASSERT_TRUE(srcAgent != nullptr);
1004 const std::string className = "WfdSourceSession";
1005 ASSERT_TRUE(srcAgent->CreateSession(className) == ERR_OK);
1006 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
1007 ASSERT_TRUE(sessionMsg != nullptr);
1008 sessionMsg->msg = std::make_shared<AgentEventMsg>();
1009 ASSERT_TRUE(sessionMsg->msg != nullptr);
1010 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
1011 sessionMsg->className = "";
1012 sessionMsg->msg->errorCode = ERR_PROSUMER_CREATE;
1013 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
1014 srcAgent->HandleProsumerError(sessionMsg);
1015 }
1016
1017 HWTEST_F(SrcAgentUnitTest, SrcAgent_081, Function | SmallTest | Level2)
1018 {
1019 auto srcAgent = std::make_shared<SrcAgent>();
1020 ASSERT_TRUE(srcAgent != nullptr);
1021 const std::string className = "WfdSourceSession";
1022 ASSERT_TRUE(srcAgent->CreateSession(className) == ERR_OK);
1023 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
1024 ASSERT_TRUE(sessionMsg != nullptr);
1025 sessionMsg->msg = std::make_shared<AgentEventMsg>();
1026 ASSERT_TRUE(sessionMsg->msg != nullptr);
1027 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
1028 sessionMsg->className = "";
1029 sessionMsg->msg->errorCode = ERR_PROSUMER_START;
1030 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
1031 srcAgent->HandleProsumerError(sessionMsg);
1032 }
1033
1034 HWTEST_F(SrcAgentUnitTest, SrcAgent_082, Function | SmallTest | Level2)
1035 {
1036 auto srcAgent = std::make_shared<SrcAgent>();
1037 ASSERT_TRUE(srcAgent != nullptr);
1038 const std::string className = "WfdSourceSession";
1039 ASSERT_TRUE(srcAgent->CreateSession(className) == ERR_OK);
1040 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
1041 ASSERT_TRUE(sessionMsg != nullptr);
1042 sessionMsg->msg = std::make_shared<AgentEventMsg>();
1043 ASSERT_TRUE(sessionMsg->msg != nullptr);
1044 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
1045 sessionMsg->className = "";
1046 sessionMsg->msg->errorCode = ERR_PROSUMER_VIDEO_CAPTURE;
1047 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
1048 srcAgent->HandleProsumerError(sessionMsg);
1049 }
1050
1051 HWTEST_F(SrcAgentUnitTest, SrcAgent_083, Function | SmallTest | Level2)
1052 {
1053 auto srcAgent = std::make_shared<SrcAgent>();
1054 ASSERT_TRUE(srcAgent != nullptr);
1055 const std::string className = "WfdSourceSession";
1056 ASSERT_TRUE(srcAgent->CreateSession(className) == ERR_OK);
1057 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
1058 ASSERT_TRUE(sessionMsg != nullptr);
1059 sessionMsg->msg = std::make_shared<AgentEventMsg>();
1060 ASSERT_TRUE(sessionMsg->msg != nullptr);
1061 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
1062 sessionMsg->className = "";
1063 sessionMsg->msg->errorCode = ERR_PROSUMER_TIMEOUT;
1064 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
1065 srcAgent->HandleProsumerError(sessionMsg);
1066 }
1067
1068 HWTEST_F(SrcAgentUnitTest, SrcAgent_084, Function | SmallTest | Level2)
1069 {
1070 auto srcAgent = std::make_shared<SrcAgent>();
1071 ASSERT_TRUE(srcAgent != nullptr);
1072 const std::string className = "WfdSourceSession";
1073 ASSERT_TRUE(srcAgent->CreateSession(className) == ERR_OK);
1074 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
1075 ASSERT_TRUE(sessionMsg != nullptr);
1076 sessionMsg->msg = std::make_shared<AgentEventMsg>();
1077 ASSERT_TRUE(sessionMsg->msg != nullptr);
1078 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
1079 sessionMsg->className = "";
1080 sessionMsg->msg->errorCode = ERR_PROSUMER_STOP;
1081 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
1082 srcAgent->HandleProsumerError(sessionMsg);
1083 }
1084
1085 HWTEST_F(SrcAgentUnitTest, SrcAgent_085, Function | SmallTest | Level2)
1086 {
1087 auto srcAgent = std::make_shared<SrcAgent>();
1088 ASSERT_TRUE(srcAgent != nullptr);
1089 const std::string className = "WfdSourceSession";
1090 ASSERT_TRUE(srcAgent->CreateSession(className) == ERR_OK);
1091 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
1092 ASSERT_TRUE(sessionMsg != nullptr);
1093 sessionMsg->msg = std::make_shared<AgentEventMsg>();
1094 ASSERT_TRUE(sessionMsg->msg != nullptr);
1095 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
1096 sessionMsg->className = "";
1097 sessionMsg->msg->errorCode = ERR_PROSUMER_DESTROY;
1098 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
1099 srcAgent->HandleProsumerError(sessionMsg);
1100 }
1101
1102 HWTEST_F(SrcAgentUnitTest, SrcAgent_086, Function | SmallTest | Level2)
1103 {
1104 auto srcAgent = std::make_shared<SrcAgent>();
1105 ASSERT_TRUE(srcAgent != nullptr);
1106 const std::string className = "WfdSourceSession";
1107 ASSERT_TRUE(srcAgent->CreateSession(className) == ERR_OK);
1108 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
1109 ASSERT_TRUE(sessionMsg != nullptr);
1110 sessionMsg->msg = std::make_shared<AgentEventMsg>();
1111 ASSERT_TRUE(sessionMsg->msg != nullptr);
1112 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
1113 sessionMsg->className = "";
1114 sessionMsg->msg->errorCode = ERR_PLAY_STOP;
1115 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
1116 srcAgent->HandleProsumerError(sessionMsg);
1117 }
1118
1119 HWTEST_F(SrcAgentUnitTest, SrcAgent_087, Function | SmallTest | Level2)
1120 {
1121 auto srcAgent = std::make_shared<SrcAgent>();
1122 ASSERT_TRUE(srcAgent != nullptr);
1123 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
1124 ASSERT_TRUE(sessionMsg != nullptr);
1125 sessionMsg->msg = std::make_shared<AgentEventMsg>();
1126 ASSERT_TRUE(sessionMsg->msg != nullptr);
1127 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
1128 sessionMsg->className = "";
1129 sessionMsg->msg->errorCode = ERR_PLAY_STOP;
1130 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_DESTROY;
1131 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
1132 srcAgent->SendContextEvent(sessionMsg, EVENT_AGENT_PROSUMER_RESUME);
1133 }
1134
1135 HWTEST_F(SrcAgentUnitTest, SrcAgent_088, Function | SmallTest | Level2)
1136 {
1137 auto srcAgent = std::make_shared<SrcAgent>();
1138 ASSERT_TRUE(srcAgent != nullptr);
1139 auto listener = std::make_shared<AgentListener>();
1140 srcAgent->SetAgentListener(listener);
1141 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
1142 ASSERT_TRUE(sessionMsg != nullptr);
1143 sessionMsg->msg = std::make_shared<AgentEventMsg>();
1144 ASSERT_TRUE(sessionMsg->msg != nullptr);
1145 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
1146 sessionMsg->className = "";
1147 sessionMsg->msg->errorCode = ERR_PLAY_STOP;
1148 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_DESTROY;
1149 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
1150 srcAgent->SendContextEvent(sessionMsg, EVENT_AGENT_PROSUMER_RESUME);
1151 }
1152
1153 HWTEST_F(SrcAgentUnitTest, SrcAgent_089, Function | SmallTest | Level2)
1154 {
1155 auto srcAgent = std::make_shared<SrcAgent>();
1156 ASSERT_TRUE(srcAgent != nullptr);
1157 auto listener = std::make_shared<AgentListener>();
1158 srcAgent->SetAgentListener(listener);
1159 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
1160 ASSERT_TRUE(sessionMsg != nullptr);
1161 sessionMsg->msg = std::make_shared<AgentEventMsg>();
1162 ASSERT_TRUE(sessionMsg->msg != nullptr);
1163 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
1164 sessionMsg->className = "";
1165 sessionMsg->msg->errorCode = ERR_PLAY_STOP;
1166 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_DESTROY;
1167 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
1168 srcAgent->SendChannelEvent(sessionMsg, EVENT_AGENT_PROSUMER_RESUME);
1169 }
1170
1171 HWTEST_F(SrcAgentUnitTest, SrcAgent_090, Function | SmallTest | Level2)
1172 {
1173 auto srcAgent = std::make_shared<SrcAgent>();
1174 ASSERT_TRUE(srcAgent != nullptr);
1175 auto listener = std::make_shared<AgentListener>();
1176 srcAgent->SetAgentListener(listener);
1177 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
1178 ASSERT_TRUE(sessionMsg != nullptr);
1179 sessionMsg->msg = std::make_shared<AgentEventMsg>();
1180 ASSERT_TRUE(sessionMsg->msg != nullptr);
1181 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
1182 sessionMsg->className = "";
1183 sessionMsg->msg->errorCode = ERR_PLAY_STOP;
1184 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_DESTROY;
1185 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
1186 srcAgent->SendInteractionEvent(sessionMsg, EVENT_AGENT_PROSUMER_RESUME);
1187 }
1188
1189 HWTEST_F(SrcAgentUnitTest, SrcAgent_091, Function | SmallTest | Level2)
1190 {
1191 auto srcAgent = std::make_shared<SrcAgent>();
1192 ASSERT_TRUE(srcAgent != nullptr);
1193 auto listener = std::make_shared<AgentListener>();
1194 srcAgent->SetAgentListener(listener);
1195 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
1196 ASSERT_TRUE(sessionMsg != nullptr);
1197 sessionMsg->msg = std::make_shared<AgentEventMsg>();
1198 ASSERT_TRUE(sessionMsg->msg != nullptr);
1199 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
1200 sessionMsg->className = "";
1201 sessionMsg->msg->errorCode = ERR_PLAY_STOP;
1202 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_DESTROY;
1203 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
1204 srcAgent->SendChannelSetVolumeEvent(sessionMsg, EVENT_AGENT_PROSUMER_RESUME);
1205 }
1206
1207 HWTEST_F(SrcAgentUnitTest, SrcAgent_092, Function | SmallTest | Level2)
1208 {
1209 auto srcAgent = std::make_shared<SrcAgent>();
1210 ASSERT_TRUE(srcAgent != nullptr);
1211 auto listener = std::make_shared<AgentListener>();
1212 srcAgent->SetAgentListener(listener);
1213 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
1214 ASSERT_TRUE(sessionMsg != nullptr);
1215 sessionMsg->msg = std::make_shared<AgentEventMsg>();
1216 ASSERT_TRUE(sessionMsg->msg != nullptr);
1217 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
1218 sessionMsg->className = "";
1219 sessionMsg->msg->errorCode = ERR_PLAY_STOP;
1220 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_DESTROY;
1221 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
1222 srcAgent->SendChannelSceneTypeEvent(sessionMsg, EVENT_AGENT_PROSUMER_RESUME);
1223 }
1224
1225 HWTEST_F(SrcAgentUnitTest, SrcAgent_093, Function | SmallTest | Level2)
1226 {
1227 auto srcAgent = std::make_shared<SrcAgent>();
1228 ASSERT_TRUE(srcAgent != nullptr);
1229 auto listener = std::make_shared<AgentListener>();
1230 srcAgent->SetAgentListener(listener);
1231 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
1232 ASSERT_TRUE(sessionMsg != nullptr);
1233 sessionMsg->msg = std::make_shared<AgentEventMsg>();
1234 ASSERT_TRUE(sessionMsg->msg != nullptr);
1235 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
1236 sessionMsg->className = "";
1237 sessionMsg->msg->errorCode = ERR_PLAY_STOP;
1238 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_DESTROY;
1239 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
1240 srcAgent->SendChannelKeyRedirectEvent(sessionMsg, EVENT_AGENT_PROSUMER_RESUME);
1241 }
1242
1243 HWTEST_F(SrcAgentUnitTest, SrcAgent_094, Function | SmallTest | Level2)
1244 {
1245 auto srcAgent = std::make_shared<SrcAgent>();
1246 ASSERT_TRUE(srcAgent != nullptr);
1247 auto listener = std::make_shared<AgentListener>();
1248 srcAgent->SetAgentListener(listener);
1249 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
1250 ASSERT_TRUE(sessionMsg != nullptr);
1251 sessionMsg->msg = std::make_shared<AgentEventMsg>();
1252 ASSERT_TRUE(sessionMsg->msg != nullptr);
1253 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
1254 sessionMsg->className = "";
1255 sessionMsg->msg->errorCode = ERR_PLAY_STOP;
1256 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_DESTROY;
1257 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
1258 srcAgent->SendChannelAppendSurfaceEvent(sessionMsg, EVENT_AGENT_PROSUMER_RESUME);
1259 }
1260
1261 HWTEST_F(SrcAgentUnitTest, SrcAgent_095, Function | SmallTest | Level2)
1262 {
1263 auto srcAgent = std::make_shared<SrcAgent>();
1264 ASSERT_TRUE(srcAgent != nullptr);
1265 auto listener = std::make_shared<AgentListener>();
1266 srcAgent->SetAgentListener(listener);
1267 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
1268 ASSERT_TRUE(sessionMsg != nullptr);
1269 sessionMsg->msg = std::make_shared<AgentEventMsg>();
1270 ASSERT_TRUE(sessionMsg->msg != nullptr);
1271 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
1272 sessionMsg->className = "";
1273 sessionMsg->msg->errorCode = ERR_PLAY_STOP;
1274 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_DESTROY;
1275 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
1276 srcAgent->SendChannelRemoveSurfaceEvent(sessionMsg, EVENT_AGENT_PROSUMER_RESUME);
1277 }
1278
1279 HWTEST_F(SrcAgentUnitTest, SrcAgent_096, Function | SmallTest | Level2)
1280 {
1281 auto srcAgent = std::make_shared<SrcAgent>();
1282 ASSERT_TRUE(srcAgent != nullptr);
1283 auto listener = std::make_shared<AgentListener>();
1284 srcAgent->SetAgentListener(listener);
1285 SessionStatusMsg::Ptr sessionMsg = std::make_shared<SessionStatusMsg>();
1286 ASSERT_TRUE(sessionMsg != nullptr);
1287 sessionMsg->msg = std::make_shared<AgentEventMsg>();
1288 ASSERT_TRUE(sessionMsg->msg != nullptr);
1289 sessionMsg->status = SessionNotifyStatus::NOTIFY_PROSUMER_CREATE;
1290 sessionMsg->className = "";
1291 sessionMsg->msg->errorCode = ERR_PLAY_STOP;
1292 sessionMsg->msg->type = EVENT_AGENT_STATE_PROSUMER_DESTROY;
1293 sessionMsg->msg->toMgr = ModuleType::MODULE_WINDOW;
1294 srcAgent->NotifyProducer(sessionMsg, EVENT_AGENT_PROSUMER_RESUME);
1295 }
1296
1297 HWTEST_F(SrcAgentUnitTest, SrcAgent_097, Function | SmallTest | Level2)
1298 {
1299 auto srcAgent = std::make_shared<SrcAgent>();
1300 ASSERT_TRUE(srcAgent != nullptr);
1301 uint32_t sinkAgentId = 1;
1302 srcAgent->SetSinkAgentId(sinkAgentId);
1303 auto ret = srcAgent->GetSinkAgentId();
1304 ASSERT_TRUE(ret == sinkAgentId);
1305 }
1306 } // namespace
1307 } // namespace Sharing
1308 } // namespace OHOS