1 /*
2 * Copyright (c) 2023 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 <gtest/gtest.h>
17 #include <iostream>
18 #include "common/reflect_registration.h"
19 #include "common/sharing_log.h"
20 #include "context/context.h"
21 #include "context/context_manager.h"
22 #include "agent/srcagent/src_agent.h"
23 #include "configuration/include/sharing_data.h"
24 #include "configuration/include/config.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::Sharing;
28
29 namespace OHOS {
30 namespace Sharing {
31
32 class ContextTestScene : public BaseSession,
33 public std::enable_shared_from_this<ContextTestScene> {
34 public:
ContextTestScene()35 ContextTestScene()
36 {
37 std::cout << "ContextTestScene constructor called." << std::endl;
38 }
39
40 void UpdateOperation(SessionStatusMsg::Ptr &statusMsg) override
41 {
42 (void)statusMsg;
43 return;
44 }
45 void UpdateMediaStatus(SessionStatusMsg::Ptr &statusMsg) override
46 {
47 (void)statusMsg;
48 return;
49 }
50 int32_t HandleEvent(SharingEvent &event) override
51 {
52 (void)event;
53 return 0;
54 }
55 };
56
57 class ContextImpl : public Context {
58 public:
59 ContextImpl() = default;
60 };
61 REGISTER_CLASS_REFLECTOR(ContextTestScene);
62 class SharingContextUnitTest : public testing::Test {};
63
64 namespace {
65
HWTEST_F(SharingContextUnitTest, Context_Base_01, Function | SmallTest | Level2)66 HWTEST_F(SharingContextUnitTest, Context_Base_01, Function | SmallTest | Level2)
67 {
68 SHARING_LOGD("trace");
69 int32_t ret = -1;
70 std::shared_ptr<Context> context = std::make_shared<Context>();
71 EXPECT_NE(context, nullptr);
72 SharingEvent event;
73 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
74
75 contextEventMsgSptr->className = "ContextTestScene";
76 contextEventMsgSptr->agentType = SINK_AGENT;
77 contextEventMsgSptr->agentId = 100;
78
79 event.description = "test";
80 event.emitterType = CLASS_TYPE_PRODUCER;
81 event.eventMsg = contextEventMsgSptr;
82 event.listenerType = CLASS_TYPE_SCHEDULER;
83 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
84
85 ret = context->HandleEvent(event);
86 EXPECT_EQ(ret, 0);
87 }
88
89
HWTEST_F(SharingContextUnitTest, Context_Base_02, Function | SmallTest | Level2)90 HWTEST_F(SharingContextUnitTest, Context_Base_02, Function | SmallTest | Level2)
91 {
92 SHARING_LOGD("trace");
93 int32_t ret = -1;
94 std::shared_ptr<Context> context = std::make_shared<Context>();
95 EXPECT_NE(context, nullptr);
96 SharingEvent event;
97 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
98
99 contextEventMsgSptr->className = "ContextTestScene";
100 contextEventMsgSptr->agentType = SINK_AGENT;
101 contextEventMsgSptr->agentId = 100;
102
103 event.description = "test";
104 event.emitterType = CLASS_TYPE_PRODUCER;
105 event.eventMsg = contextEventMsgSptr;
106 event.listenerType = CLASS_TYPE_SCHEDULER;
107 event.eventMsg->type = EVENT_CONTEXT_STATE_AGENT_DESTROY;
108
109 ret = context->HandleEvent(event);
110 EXPECT_EQ(ret, 0);
111 }
112
113
HWTEST_F(SharingContextUnitTest, Context_Base_03, Function | SmallTest | Level2)114 HWTEST_F(SharingContextUnitTest, Context_Base_03, Function | SmallTest | Level2)
115 {
116 SHARING_LOGD("trace");
117 int32_t ret = -1;
118 std::shared_ptr<Context> context = std::make_shared<Context>();
119 EXPECT_NE(context, nullptr);
120 SharingEvent event;
121 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
122
123 contextEventMsgSptr->className = "ContextTestScene";
124 contextEventMsgSptr->agentType = SINK_AGENT;
125 contextEventMsgSptr->agentId = 100;
126
127 event.description = "test";
128 event.emitterType = CLASS_TYPE_PRODUCER;
129 event.eventMsg = contextEventMsgSptr;
130 event.listenerType = CLASS_TYPE_SCHEDULER;
131 event.eventMsg->type = EVENT_CONTEXT_STATE_AGENT_DESTROY;
132 context->Release();
133
134 ret = context->HandleEvent(event);
135 EXPECT_EQ(ret, -1);
136 }
137
HWTEST_F(SharingContextUnitTest, Context_Base_04, Function | SmallTest | Level2)138 HWTEST_F(SharingContextUnitTest, Context_Base_04, Function | SmallTest | Level2)
139 {
140 SHARING_LOGD("trace");
141 int32_t ret = 0;
142 bool tag = false;
143 std::shared_ptr<Context> context = std::make_shared<Context>();
144 EXPECT_NE(context, nullptr);
145 SharingEvent event;
146 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
147
148 contextEventMsgSptr->className = "ContextTestScene";
149 contextEventMsgSptr->agentType = SINK_AGENT;
150 contextEventMsgSptr->agentId = 100;
151
152 tag = context->IsEmptyAgent();
153 EXPECT_EQ(tag, true);
154
155 event.description = "test";
156 event.emitterType = CLASS_TYPE_PRODUCER;
157 event.eventMsg = contextEventMsgSptr;
158 event.listenerType = CLASS_TYPE_SCHEDULER;
159 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
160
161 ret = context->HandleEvent(event);
162 EXPECT_EQ(ret, 0);
163
164 tag = context->IsEmptyAgent();
165 EXPECT_EQ(tag, false);
166 }
167
HWTEST_F(SharingContextUnitTest, Context_Base_05, Function | SmallTest | Level2)168 HWTEST_F(SharingContextUnitTest, Context_Base_05, Function | SmallTest | Level2)
169 {
170 SHARING_LOGD("trace");
171 int32_t ret = 0;
172 bool tag = false;
173 std::shared_ptr<Context> context = std::make_shared<Context>();
174 EXPECT_NE(context, nullptr);
175 SharingEvent event;
176 uint32_t agentId;
177 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
178
179 contextEventMsgSptr->className = "ContextTestScene";
180 contextEventMsgSptr->agentType = SINK_AGENT;
181 contextEventMsgSptr->type = EVENT_CONTEXT_AGENT_CREATE;
182
183 tag = context->IsEmptySrcAgent(contextEventMsgSptr->agentId);
184 EXPECT_EQ(tag, true);
185
186 event.description = "test";
187 event.emitterType = CLASS_TYPE_PRODUCER;
188 event.eventMsg = contextEventMsgSptr;
189 event.listenerType = CLASS_TYPE_SCHEDULER;
190
191 ret = context->HandleEvent(event);
192 EXPECT_EQ(ret, 0);
193 agentId = contextEventMsgSptr->agentId;
194 contextEventMsgSptr->agentType = SRC_AGENT;
195 event.eventMsg = contextEventMsgSptr;
196
197 ret = context->HandleEvent(event);
198 EXPECT_EQ(ret, 0);
199
200 tag = context->IsEmptySrcAgent(agentId);
201 EXPECT_EQ(tag, false);
202 }
203
HWTEST_F(SharingContextUnitTest, Context_Base_06, Function | SmallTest | Level2)204 HWTEST_F(SharingContextUnitTest, Context_Base_06, Function | SmallTest | Level2)
205 {
206 SHARING_LOGD("trace");
207 int32_t ret = -1;
208 std::shared_ptr<Context> context = std::make_shared<Context>();
209 EXPECT_NE(context, nullptr);
210 SharingEvent event;
211 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
212
213 contextEventMsgSptr->className = "ContextTestScene";
214 contextEventMsgSptr->agentType = SINK_AGENT;
215 contextEventMsgSptr->type = EVENT_CONTEXT_AGENT_CREATE;
216
217 ret = context->GetSrcAgentSize();
218 EXPECT_EQ(ret, 0);
219
220 event.description = "test";
221 event.emitterType = CLASS_TYPE_PRODUCER;
222 event.eventMsg = contextEventMsgSptr;
223 event.listenerType = CLASS_TYPE_SCHEDULER;
224
225 ret = context->HandleEvent(event);
226 EXPECT_EQ(ret, 0);
227
228 contextEventMsgSptr->agentType = SRC_AGENT;
229 event.eventMsg = contextEventMsgSptr;
230
231 ret = context->HandleEvent(event);
232 EXPECT_EQ(ret, 0);
233
234 ret = context->GetSrcAgentSize();
235 EXPECT_EQ(ret, 1);
236 }
237
HWTEST_F(SharingContextUnitTest, Context_Base_07, Function | SmallTest | Level2)238 HWTEST_F(SharingContextUnitTest, Context_Base_07, Function | SmallTest | Level2)
239 {
240 SHARING_LOGD("trace");
241 int32_t ret = -1;
242 std::shared_ptr<Context> context = std::make_shared<Context>();
243 EXPECT_NE(context, nullptr);
244 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
245
246 SharingEvent event;
247 contextEventMsgSptr->className = "ContextTestScene";
248 contextEventMsgSptr->agentType = SINK_AGENT;
249
250 ret = context->GetSinkAgentSize();
251 EXPECT_EQ(ret, 0);
252
253 event.description = "test";
254 event.emitterType = CLASS_TYPE_PRODUCER;
255 event.eventMsg = contextEventMsgSptr;
256 event.listenerType = CLASS_TYPE_SCHEDULER;
257 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
258
259 ret = context->HandleEvent(event);
260 EXPECT_EQ(ret, 0);
261
262 ret = context->GetSinkAgentSize();
263 EXPECT_EQ(ret, 1);
264 }
265
HWTEST_F(SharingContextUnitTest, Context_Base_008, Function | SmallTest | Level2)266 HWTEST_F(SharingContextUnitTest, Context_Base_008, Function | SmallTest | Level2)
267 {
268 SHARING_LOGD("trace");
269
270 std::shared_ptr<Context> context = std::make_shared<Context>();
271 EXPECT_NE(context, nullptr);
272
273 context->Release();
274 }
275
HWTEST_F(SharingContextUnitTest, Context_Base_009, Function | SmallTest | Level2)276 HWTEST_F(SharingContextUnitTest, Context_Base_009, Function | SmallTest | Level2)
277 {
278 SHARING_LOGD("trace");
279 std::shared_ptr<AgentStatusMsg> StatusMsg = std::make_shared<AgentStatusMsg>();
280
281 std::shared_ptr<Context> context = std::make_shared<Context>();
282 EXPECT_NE(context, nullptr);
283
284 StatusMsg->msg = std::make_shared<EventMsg>();
285 context->OnAgentNotify(StatusMsg);
286 }
287
HWTEST_F(SharingContextUnitTest, Context_Base_010, Function | SmallTest | Level2)288 HWTEST_F(SharingContextUnitTest, Context_Base_010, Function | SmallTest | Level2)
289 {
290 SHARING_LOGD("trace");
291 SharingEvent event;
292 event.description = "test";
293 event.emitterType = CLASS_TYPE_PRODUCER;
294 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
295
296 contextEventMsgSptr->agentType = SRC_AGENT;
297 event.eventMsg = std::make_shared<ContextEventMsg>();
298 event.listenerType = CLASS_TYPE_SCHEDULER;
299 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
300
301 auto eventMsg = ConvertEventMsg<ContextEventMsg>(event);
302 std::shared_ptr<Context> context = std::make_shared<Context>();
303 context->SendInteractionEvent(EVENT_COMMON_BASE, eventMsg);
304 }
305
HWTEST_F(SharingContextUnitTest, Context_Base_011, Function | SmallTest | Level2)306 HWTEST_F(SharingContextUnitTest, Context_Base_011, Function | SmallTest | Level2)
307 {
308 SHARING_LOGD("trace");
309 SharingEvent event;
310 event.description = "test";
311 event.emitterType = CLASS_TYPE_PRODUCER;
312 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
313
314 contextEventMsgSptr->agentType = SRC_AGENT;
315 event.eventMsg = std::make_shared<ContextEventMsg>();
316 event.listenerType = CLASS_TYPE_SCHEDULER;
317 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
318
319 auto eventMsg = ConvertEventMsg<ContextEventMsg>(event);
320 std::shared_ptr<Context> context = std::make_shared<Context>();
321 context->SendInteractionEvent(EVENT_CONTEXTMGR_AGENT_CREATE, eventMsg);
322 }
323
HWTEST_F(SharingContextUnitTest, Context_Base_012, Function | SmallTest | Level2)324 HWTEST_F(SharingContextUnitTest, Context_Base_012, Function | SmallTest | Level2)
325 {
326 SHARING_LOGD("trace");
327 SharingEvent event;
328 event.description = "test";
329 event.emitterType = CLASS_TYPE_PRODUCER;
330 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
331
332 contextEventMsgSptr->agentType = SRC_AGENT;
333 event.eventMsg = std::make_shared<ContextEventMsg>();
334 event.listenerType = CLASS_TYPE_SCHEDULER;
335 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
336
337 auto eventMsg = ConvertEventMsg<ContextEventMsg>(event);
338 std::shared_ptr<Context> context = std::make_shared<Context>();
339 context->SendInteractionEvent(EVENT_AGENT_DESTROY, eventMsg);
340 }
341
HWTEST_F(SharingContextUnitTest, Context_Base_013, Function | SmallTest | Level2)342 HWTEST_F(SharingContextUnitTest, Context_Base_013, Function | SmallTest | Level2)
343 {
344 SHARING_LOGD("trace");
345 SharingEvent event;
346 event.description = "test";
347 event.emitterType = CLASS_TYPE_PRODUCER;
348 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
349
350 contextEventMsgSptr->agentType = SRC_AGENT;
351 event.eventMsg = std::make_shared<ContextEventMsg>();
352 event.listenerType = CLASS_TYPE_SCHEDULER;
353 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
354
355 auto eventMsg = ConvertEventMsg<ContextEventMsg>(event);
356 std::shared_ptr<Context> context = std::make_shared<Context>();
357 context->SendInteractionEvent(EVENT_SESSION_BASE, eventMsg);
358 }
359
HWTEST_F(SharingContextUnitTest, Context_Base_014, Function | SmallTest | Level2)360 HWTEST_F(SharingContextUnitTest, Context_Base_014, Function | SmallTest | Level2)
361 {
362 SHARING_LOGD("trace");
363 SharingEvent event;
364 event.description = "test";
365 event.emitterType = CLASS_TYPE_PRODUCER;
366 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
367
368 contextEventMsgSptr->agentType = SRC_AGENT;
369 event.eventMsg = std::make_shared<ContextEventMsg>();
370 event.listenerType = CLASS_TYPE_SCHEDULER;
371 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
372
373 auto eventMsg = ConvertEventMsg<ContextEventMsg>(event);
374 std::shared_ptr<Context> context = std::make_shared<Context>();
375 context->SendInteractionEvent(EVENT_MEDIA_CONSUMER_PAUSE, eventMsg);
376 }
377
HWTEST_F(SharingContextUnitTest, Context_Base_015, Function | SmallTest | Level2)378 HWTEST_F(SharingContextUnitTest, Context_Base_015, Function | SmallTest | Level2)
379 {
380 SHARING_LOGD("trace");
381 SharingEvent event;
382 event.description = "test";
383 event.emitterType = CLASS_TYPE_PRODUCER;
384 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
385
386 contextEventMsgSptr->agentType = SRC_AGENT;
387 event.eventMsg = std::make_shared<ContextEventMsg>();
388 event.listenerType = CLASS_TYPE_SCHEDULER;
389 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
390
391 auto eventMsg = ConvertEventMsg<ContextEventMsg>(event);
392 std::shared_ptr<Context> context = std::make_shared<Context>();
393 context->SendInteractionEvent(EVENT_SCHEDULER_BASE, eventMsg);
394 }
395
HWTEST_F(SharingContextUnitTest, Context_Base_016, Function | SmallTest | Level2)396 HWTEST_F(SharingContextUnitTest, Context_Base_016, Function | SmallTest | Level2)
397 {
398 SHARING_LOGD("trace");
399 SharingEvent event;
400 event.description = "test";
401 event.emitterType = CLASS_TYPE_PRODUCER;
402 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
403
404 contextEventMsgSptr->agentType = SRC_AGENT;
405 event.eventMsg = std::make_shared<ContextEventMsg>();
406 event.listenerType = CLASS_TYPE_SCHEDULER;
407 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
408
409 auto eventMsg = ConvertEventMsg<ContextEventMsg>(event);
410 std::shared_ptr<Context> context = std::make_shared<Context>();
411 context->SendInteractionEvent(EVENT_INTERACTION_MSG_ERROR, eventMsg);
412 }
413
HWTEST_F(SharingContextUnitTest, Context_Base_017, Function | SmallTest | Level2)414 HWTEST_F(SharingContextUnitTest, Context_Base_017, Function | SmallTest | Level2)
415 {
416 SHARING_LOGD("trace");
417 SharingEvent event;
418 event.description = "test";
419 event.emitterType = CLASS_TYPE_PRODUCER;
420 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
421
422 contextEventMsgSptr->agentType = SRC_AGENT;
423 event.eventMsg = std::make_shared<ContextEventMsg>();
424 event.listenerType = CLASS_TYPE_SCHEDULER;
425 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
426
427 auto eventMsg = ConvertEventMsg<ContextEventMsg>(event);
428 std::shared_ptr<Context> context = std::make_shared<Context>();
429 context->SendInteractionEvent(EVENT_CONFIGURE_BASE, eventMsg);
430 }
431
HWTEST_F(SharingContextUnitTest, Context_Base_018, Function | SmallTest | Level2)432 HWTEST_F(SharingContextUnitTest, Context_Base_018, Function | SmallTest | Level2)
433 {
434 SHARING_LOGD("trace");
435 SharingEvent event;
436 event.description = "test";
437 event.emitterType = CLASS_TYPE_PRODUCER;
438 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
439
440 contextEventMsgSptr->agentType = SRC_AGENT;
441 event.eventMsg = std::make_shared<ContextEventMsg>();
442 event.listenerType = CLASS_TYPE_SCHEDULER;
443 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
444
445 auto eventMsg = ConvertEventMsg<ContextEventMsg>(event);
446 std::shared_ptr<Context> context = std::make_shared<Context>();
447 context->SendInteractionEvent(EVENT_VIDEOCHAT, eventMsg);
448 }
449
HWTEST_F(SharingContextUnitTest, Context_Base_019, Function | SmallTest | Level2)450 HWTEST_F(SharingContextUnitTest, Context_Base_019, Function | SmallTest | Level2)
451 {
452 SHARING_LOGD("trace");
453 SharingEvent event;
454 event.description = "test";
455 event.emitterType = CLASS_TYPE_PRODUCER;
456 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
457
458 contextEventMsgSptr->agentType = SRC_AGENT;
459 event.eventMsg = std::make_shared<ContextEventMsg>();
460 event.listenerType = CLASS_TYPE_SCHEDULER;
461 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
462
463 auto eventMsg = ConvertEventMsg<ContextEventMsg>(event);
464 std::shared_ptr<Context> context = std::make_shared<Context>();
465 context->SendInteractionEvent(EVENT_WFD_NOTIFY_RTSP_PLAYED, eventMsg);
466 }
467
HWTEST_F(SharingContextUnitTest, Context_Base_020, Function | SmallTest | Level2)468 HWTEST_F(SharingContextUnitTest, Context_Base_020, Function | SmallTest | Level2)
469 {
470 SHARING_LOGD("trace");
471 SharingEvent event;
472 event.description = "test";
473 event.emitterType = CLASS_TYPE_PRODUCER;
474 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
475
476 contextEventMsgSptr->agentType = SRC_AGENT;
477 event.eventMsg = std::make_shared<ContextEventMsg>();
478 event.listenerType = CLASS_TYPE_SCHEDULER;
479 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
480
481 auto eventMsg = ConvertEventMsg<ContextEventMsg>(event);
482 std::shared_ptr<Context> context = std::make_shared<Context>();
483 context->SendInteractionEvent(EVENT_PLAYER, eventMsg);
484 }
485
HWTEST_F(SharingContextUnitTest, Context_Base_021, Function | SmallTest | Level2)486 HWTEST_F(SharingContextUnitTest, Context_Base_021, Function | SmallTest | Level2)
487 {
488 SHARING_LOGD("trace");
489 SharingEvent event;
490 event.description = "test";
491 event.emitterType = CLASS_TYPE_PRODUCER;
492 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
493
494 contextEventMsgSptr->agentType = SRC_AGENT;
495 event.eventMsg = std::make_shared<ContextEventMsg>();
496 event.listenerType = CLASS_TYPE_SCHEDULER;
497 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
498
499 auto eventMsg = ConvertEventMsg<ContextEventMsg>(event);
500 std::shared_ptr<Context> context = std::make_shared<Context>();
501 context->SendInteractionEvent(EVENT_SCREEN_CAPTURE_BASE, eventMsg);
502 }
503
HWTEST_F(SharingContextUnitTest, Context_Base_022, Function | SmallTest | Level2)504 HWTEST_F(SharingContextUnitTest, Context_Base_022, Function | SmallTest | Level2)
505 {
506 SHARING_LOGD("trace");
507 SharingEvent event;
508 int32_t ret = -1;
509 event.description = "test";
510 event.emitterType = CLASS_TYPE_PRODUCER;
511 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
512
513 contextEventMsgSptr->agentType = SRC_AGENT;
514 event.eventMsg = std::make_shared<ContextEventMsg>();
515 event.listenerType = CLASS_TYPE_SCHEDULER;
516 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
517
518 auto eventMsg = ConvertEventMsg<ContextEventMsg>(event);
519 std::shared_ptr<Context> context = std::make_shared<Context>();
520 ret = context->HandleEvent(event);
521 EXPECT_EQ(ret, 0);
522 context->RemoveAgent(eventMsg->agentId);
523 }
524
HWTEST_F(SharingContextUnitTest, Context_Base_023, Function | SmallTest | Level2)525 HWTEST_F(SharingContextUnitTest, Context_Base_023, Function | SmallTest | Level2)
526 {
527 SHARING_LOGD("trace");
528 int32_t ret = -1;
529 std::shared_ptr<Context> context = std::make_shared<Context>();
530 EXPECT_NE(context, nullptr);
531 SharingEvent event;
532 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
533
534 contextEventMsgSptr->className = "ContextTestScene";
535 contextEventMsgSptr->agentType = SINK_AGENT;
536 contextEventMsgSptr->agentId = 100;
537
538 event.description = "test";
539 event.emitterType = CLASS_TYPE_PRODUCER;
540 event.eventMsg = contextEventMsgSptr;
541 event.listenerType = CLASS_TYPE_SCHEDULER;
542 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
543
544 ret = context->HandleEvent(event);
545 EXPECT_EQ(ret, 0);
546 context->DistributeEvent(event);
547 }
548
HWTEST_F(SharingContextUnitTest, Context_Base_024, Function | SmallTest | Level2)549 HWTEST_F(SharingContextUnitTest, Context_Base_024, Function | SmallTest | Level2)
550 {
551 SHARING_LOGD("trace");
552 int32_t ret = -1;
553 std::shared_ptr<Context> context = std::make_shared<Context>();
554 EXPECT_NE(context, nullptr);
555 SharingEvent event;
556 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
557
558 contextEventMsgSptr->className = "ContextTestScene";
559 contextEventMsgSptr->agentType = SINK_AGENT;
560 contextEventMsgSptr->agentId = 100;
561
562 event.description = "test";
563 event.emitterType = CLASS_TYPE_PRODUCER;
564 event.eventMsg = contextEventMsgSptr;
565 event.listenerType = CLASS_TYPE_SCHEDULER;
566 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
567
568 ret = context->HandleEvent(event);
569 EXPECT_EQ(ret, 0);
570 auto agent = context->GetAgentById(contextEventMsgSptr->agentId);
571 EXPECT_NE(agent, nullptr);
572 }
573
HWTEST_F(SharingContextUnitTest, Context_Base_025, Function | SmallTest | Level2)574 HWTEST_F(SharingContextUnitTest, Context_Base_025, Function | SmallTest | Level2)
575 {
576 SHARING_LOGD("trace");
577 int32_t ret = -1;
578 std::shared_ptr<Context> context = std::make_shared<Context>();
579 EXPECT_NE(context, nullptr);
580 SharingEvent event;
581 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
582
583 contextEventMsgSptr->className = "ContextTestScene";
584 contextEventMsgSptr->agentType = SINK_AGENT;
585 contextEventMsgSptr->agentId = 100;
586
587 event.description = "test";
588 event.emitterType = CLASS_TYPE_PRODUCER;
589 event.eventMsg = contextEventMsgSptr;
590 event.listenerType = CLASS_TYPE_SCHEDULER;
591 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
592
593 ret = context->HandleEvent(event);
594 EXPECT_EQ(ret, 0);
595 auto agent = context->GetAgentById(contextEventMsgSptr->agentId);
596 EXPECT_NE(agent, nullptr);
597 auto srcAgent = std::static_pointer_cast<SrcAgent>(agent);
598 uint32_t sinkAgentId = srcAgent->GetSinkAgentId();
599 context->CheckNeedDestroySink(sinkAgentId);
600 }
601
HWTEST_F(SharingContextUnitTest, Context_Base_026, Function | SmallTest | Level2)602 HWTEST_F(SharingContextUnitTest, Context_Base_026, Function | SmallTest | Level2)
603 {
604 SHARING_LOGD("trace");
605 SharingEvent event;
606 event.description = "test";
607 event.emitterType = CLASS_TYPE_PRODUCER;
608 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
609
610 contextEventMsgSptr->agentType = SRC_AGENT;
611 event.eventMsg = std::make_shared<ContextEventMsg>();
612 event.listenerType = CLASS_TYPE_SCHEDULER;
613 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
614
615 auto eventMsg = ConvertEventMsg<ContextEventMsg>(event);
616 std::shared_ptr<Context> context = std::make_shared<Context>();
617 context->HandleAgentDestroy(event);
618 }
619
HWTEST_F(SharingContextUnitTest, Context_Base_027, Function | SmallTest | Level2)620 HWTEST_F(SharingContextUnitTest, Context_Base_027, Function | SmallTest | Level2)
621 {
622 SHARING_LOGD("trace");
623 SharingEvent event;
624 event.description = "test";
625 event.emitterType = CLASS_TYPE_PRODUCER;
626 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
627
628 contextEventMsgSptr->agentType = SRC_AGENT;
629 event.eventMsg = std::make_shared<ContextEventMsg>();
630 event.listenerType = CLASS_TYPE_SCHEDULER;
631 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
632
633 auto eventMsg = ConvertEventMsg<ContextEventMsg>(event);
634 std::shared_ptr<Context> context = std::make_shared<Context>();
635 context->HandleStateDestroyAgent(event);
636 }
637
HWTEST_F(SharingContextUnitTest, Context_Base_028, Function | SmallTest | Level2)638 HWTEST_F(SharingContextUnitTest, Context_Base_028, Function | SmallTest | Level2)
639 {
640 SHARING_LOGD("trace");
641 SharingEvent event;
642 uint32_t CreatRet = 0;
643 event.description = "test";
644 event.emitterType = CLASS_TYPE_PRODUCER;
645 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
646
647 contextEventMsgSptr->agentType = SRC_AGENT;
648 event.eventMsg = std::make_shared<ContextEventMsg>();
649 event.listenerType = CLASS_TYPE_SCHEDULER;
650 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
651
652 auto eventMsg = ConvertEventMsg<ContextEventMsg>(event);
653 std::shared_ptr<Context> context = std::make_shared<Context>();
654 CreatRet = context->HandleCreateAgent(eventMsg->className, eventMsg->agentType, eventMsg->agentId);
655 EXPECT_EQ(CreatRet, 0);
656 }
657
HWTEST_F(SharingContextUnitTest, Context_Base_029, Function | SmallTest | Level2)658 HWTEST_F(SharingContextUnitTest, Context_Base_029, Function | SmallTest | Level2)
659 {
660 SHARING_LOGD("trace");
661 SharingEvent event;
662 uint32_t CreatRet = 0;
663 event.description = "test";
664 event.emitterType = CLASS_TYPE_PRODUCER;
665 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
666
667 contextEventMsgSptr->agentType = SINK_AGENT;
668 event.eventMsg = std::make_shared<ContextEventMsg>();
669 event.listenerType = CLASS_TYPE_SCHEDULER;
670 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
671
672 auto eventMsg = ConvertEventMsg<ContextEventMsg>(event);
673 std::shared_ptr<Context> context = std::make_shared<Context>();
674 CreatRet = context->HandleCreateAgent(eventMsg->className, eventMsg->agentType, eventMsg->agentId);
675 EXPECT_EQ(CreatRet, 0);
676 }
677
HWTEST_F(SharingContextUnitTest, Context_Base_030, Function | SmallTest | Level2)678 HWTEST_F(SharingContextUnitTest, Context_Base_030, Function | SmallTest | Level2)
679 {
680 SHARING_LOGD("trace");
681 int32_t ret = -1;
682 std::shared_ptr<Context> context = std::make_shared<Context>();
683 EXPECT_NE(context, nullptr);
684 SharingEvent event;
685 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
686
687 contextEventMsgSptr->className = "ContextTestScene";
688 contextEventMsgSptr->agentType = SINK_AGENT;
689 contextEventMsgSptr->agentId = 100;
690
691 event.description = "test";
692 event.emitterType = CLASS_TYPE_PRODUCER;
693 event.eventMsg = contextEventMsgSptr;
694 event.listenerType = CLASS_TYPE_SCHEDULER;
695 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
696
697 ret = context->HandleCreateAgent(contextEventMsgSptr->className,
698 contextEventMsgSptr->agentType, contextEventMsgSptr->agentId);
699 EXPECT_NE(ret, 0);
700 }
701
HWTEST_F(SharingContextUnitTest, Context_Manager_01, Function | SmallTest | Level2)702 HWTEST_F(SharingContextUnitTest, Context_Manager_01, Function | SmallTest | Level2)
703 {
704 SHARING_LOGD("trace");
705 ContextManager::GetInstance().Init();
706 SharingEvent event;
707
708 event.description = "test";
709 event.emitterType = CLASS_TYPE_PRODUCER;
710 event.eventMsg = std::make_shared<ContextEventMsg>();
711 event.listenerType = CLASS_TYPE_SCHEDULER;
712 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
713 auto ret = ContextManager::GetInstance().HandleEvent(event);
714 EXPECT_EQ(ret, 0);
715 }
716
HWTEST_F(SharingContextUnitTest, Context_Manager_02, Function | SmallTest | Level2)717 HWTEST_F(SharingContextUnitTest, Context_Manager_02, Function | SmallTest | Level2)
718 {
719 SHARING_LOGD("trace");
720 ContextManager::GetInstance().Init();
721 SharingEvent event;
722
723 event.description = "test";
724 event.emitterType = CLASS_TYPE_PRODUCER;
725 event.eventMsg = std::make_shared<ContextEventMsg>();
726 event.listenerType = CLASS_TYPE_SCHEDULER;
727 event.eventMsg->type = EVENT_CONTEXTMGR_CREATE;
728
729 auto ret = ContextManager::GetInstance().HandleEvent(event);
730 EXPECT_EQ(ret, 0);
731 }
732
HWTEST_F(SharingContextUnitTest, Context_Manager_03, Function | SmallTest | Level2)733 HWTEST_F(SharingContextUnitTest, Context_Manager_03, Function | SmallTest | Level2)
734 {
735 SHARING_LOGD("trace");
736 ContextManager::GetInstance().Init();
737 SharingEvent event;
738
739 event.description = "test";
740 event.emitterType = CLASS_TYPE_PRODUCER;
741 event.eventMsg = std::make_shared<ContextEventMsg>();
742 event.listenerType = CLASS_TYPE_SCHEDULER;
743 event.eventMsg->type = EVENT_CONTEXTMGR_AGENT_CREATE;
744
745 auto ret = ContextManager::GetInstance().HandleEvent(event);
746 EXPECT_EQ(ret, 0);
747 }
748
HWTEST_F(SharingContextUnitTest, Context_Manager_04, Function | SmallTest | Level2)749 HWTEST_F(SharingContextUnitTest, Context_Manager_04, Function | SmallTest | Level2)
750 {
751 SHARING_LOGD("trace");
752 ContextManager::GetInstance().Init();
753 SharingEvent event;
754
755 event.description = "test";
756 event.emitterType = CLASS_TYPE_PRODUCER;
757 event.eventMsg = std::make_shared<ContextEventMsg>();
758 event.listenerType = CLASS_TYPE_SCHEDULER;
759 event.eventMsg->type = EVENT_CONTEXTMGR_STATE_CHANNEL_DESTROY;
760
761 auto ret = ContextManager::GetInstance().HandleEvent(event);
762 EXPECT_EQ(ret, 0);
763 }
764
HWTEST_F(SharingContextUnitTest, Context_Manager_05, Function | SmallTest | Level2)765 HWTEST_F(SharingContextUnitTest, Context_Manager_05, Function | SmallTest | Level2)
766 {
767 SHARING_LOGD("trace");
768 ContextManager::GetInstance().Init();
769 SharingEvent event;
770
771 event.description = "test";
772 event.emitterType = CLASS_TYPE_PRODUCER;
773 event.eventMsg = std::make_shared<ContextEventMsg>();
774 event.listenerType = CLASS_TYPE_SCHEDULER;
775 event.eventMsg->type = EVENT_CONTEXT_STATE_AGENT_DESTROY;
776
777 auto ret = ContextManager::GetInstance().HandleEvent(event);
778 EXPECT_EQ(ret, 0);
779 }
780
HWTEST_F(SharingContextUnitTest, Context_Manager_06, Function | SmallTest | Level2)781 HWTEST_F(SharingContextUnitTest, Context_Manager_06, Function | SmallTest | Level2)
782 {
783 SHARING_LOGD("trace");
784 ContextManager::GetInstance().Init();
785 SharingEvent event;
786 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
787
788 contextEventMsgSptr->className = "ContextTestScene";
789 contextEventMsgSptr->agentType = SINK_AGENT;
790 contextEventMsgSptr->agentId = 100;
791
792 event.description = "test";
793 event.emitterType = CLASS_TYPE_PRODUCER;
794 event.eventMsg = std::make_shared<ContextEventMsg>();
795 event.listenerType = CLASS_TYPE_SCHEDULER;
796 event.eventMsg->type = EVENT_CONTEXT_STATE_AGENT_DESTROY;
797
798 bool ret = ContextManager::GetInstance().CheckAgentSize(contextEventMsgSptr->agentType);
799 EXPECT_EQ(ret, true);
800 }
801
HWTEST_F(SharingContextUnitTest, Context_Manager_07, Function | SmallTest | Level2)802 HWTEST_F(SharingContextUnitTest, Context_Manager_07, Function | SmallTest | Level2)
803 {
804 SHARING_LOGD("trace");
805 ContextManager::GetInstance().Init();
806 SharingEvent event;
807 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
808
809 contextEventMsgSptr->className = "ContextTestScene";
810 contextEventMsgSptr->agentType = SRC_AGENT;
811 contextEventMsgSptr->agentId = 100;
812
813 event.description = "test";
814 event.emitterType = CLASS_TYPE_PRODUCER;
815 event.eventMsg = std::make_shared<ContextEventMsg>();
816 event.listenerType = CLASS_TYPE_SCHEDULER;
817 event.eventMsg->type = EVENT_CONTEXT_STATE_AGENT_DESTROY;
818
819 bool ret = ContextManager::GetInstance().CheckAgentSize(contextEventMsgSptr->agentType);
820 EXPECT_EQ(ret, true);
821 }
822
HWTEST_F(SharingContextUnitTest, Context_Manager_08, Function | SmallTest | Level2)823 HWTEST_F(SharingContextUnitTest, Context_Manager_08, Function | SmallTest | Level2)
824 {
825 SHARING_LOGD("trace");
826 ContextManager::GetInstance().Init();
827 SharingEvent event;
828 bool tag = false;
829 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
830
831 contextEventMsgSptr->className = "ContextTestScene";
832 contextEventMsgSptr->agentType = SINK_AGENT;
833 contextEventMsgSptr->agentId = 100;
834
835 event.description = "test";
836 event.emitterType = CLASS_TYPE_PRODUCER;
837 event.eventMsg = contextEventMsgSptr;
838 event.listenerType = CLASS_TYPE_SCHEDULER;
839 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
840 ContextManager::GetInstance().maxSinkAgent_ = 0;
841 tag = ContextManager::GetInstance().CheckAgentSize(contextEventMsgSptr->agentType);
842 EXPECT_EQ(tag, false);
843 }
844
HWTEST_F(SharingContextUnitTest, Context_Manager_09, Function | SmallTest | Level2)845 HWTEST_F(SharingContextUnitTest, Context_Manager_09, Function | SmallTest | Level2)
846 {
847 SHARING_LOGD("trace");
848 ContextManager::GetInstance().Init();
849 SharingEvent event;
850 bool tag = false;
851 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
852
853 contextEventMsgSptr->className = "ContextTestScene";
854 contextEventMsgSptr->agentType = SRC_AGENT;
855 contextEventMsgSptr->agentId = 100;
856
857 event.description = "test";
858 event.emitterType = CLASS_TYPE_PRODUCER;
859 event.eventMsg = contextEventMsgSptr;
860 event.listenerType = CLASS_TYPE_SCHEDULER;
861 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
862 ContextManager::GetInstance().maxSrcAgent_ = 0;
863 tag = ContextManager::GetInstance().CheckAgentSize(contextEventMsgSptr->agentType);
864 EXPECT_EQ(tag, false)
865 }
866
HWTEST_F(SharingContextUnitTest, Context_Manager_10, Function | SmallTest | Level2)867 HWTEST_F(SharingContextUnitTest, Context_Manager_10, Function | SmallTest | Level2)
868 {
869 SHARING_LOGD("trace");
870 ContextManager::GetInstance().Init();
871 SharingEvent event;
872 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
873
874 contextEventMsgSptr->className = "ContextTestScene";
875 contextEventMsgSptr->agentType = SINK_AGENT;
876 contextEventMsgSptr->agentId = 100;
877
878 event.description = "test";
879 event.emitterType = CLASS_TYPE_PRODUCER;
880 event.eventMsg = contextEventMsgSptr;
881 event.listenerType = CLASS_TYPE_SCHEDULER;
882 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
883 ContextManager::GetInstance().HandleAgentCreate(event);
884 }
885
HWTEST_F(SharingContextUnitTest, Context_Manager_11, Function | SmallTest | Level2)886 HWTEST_F(SharingContextUnitTest, Context_Manager_11, Function | SmallTest | Level2)
887 {
888 SHARING_LOGD("trace");
889 ContextManager::GetInstance().Init();
890 SharingEvent event;
891 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
892
893 contextEventMsgSptr->className = "ContextTestScene";
894 contextEventMsgSptr->agentType = SINK_AGENT;
895 contextEventMsgSptr->agentId = 100;
896
897 event.description = "test";
898 event.emitterType = CLASS_TYPE_PRODUCER;
899 event.eventMsg = contextEventMsgSptr;
900 event.listenerType = CLASS_TYPE_SCHEDULER;
901 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
902 ContextManager::GetInstance().maxSinkAgent_ = 0;
903 ContextManager::GetInstance().HandleAgentCreate(event);
904 }
905
HWTEST_F(SharingContextUnitTest, Context_Manager_12, Function | SmallTest | Level2)906 HWTEST_F(SharingContextUnitTest, Context_Manager_12, Function | SmallTest | Level2)
907 {
908 SHARING_LOGD("trace");
909 ContextManager::GetInstance().Init();
910 uint32_t ret = 0;
911 ret = ContextManager::GetInstance().HandleContextCreate();
912 EXPECT_NE(ret, 0);
913 }
914
HWTEST_F(SharingContextUnitTest, Context_Manager_13, Function | SmallTest | Level2)915 HWTEST_F(SharingContextUnitTest, Context_Manager_13, Function | SmallTest | Level2)
916 {
917 SHARING_LOGD("trace");
918 ContextManager::GetInstance().Init();
919 uint32_t ret = 0;
920 ContextManager::GetInstance().maxContext_ = 0;
921 ret = ContextManager::GetInstance().HandleContextCreate();
922 EXPECT_EQ(ret, 0);
923 }
924
HWTEST_F(SharingContextUnitTest, Context_Manager_14, Function | SmallTest | Level2)925 HWTEST_F(SharingContextUnitTest, Context_Manager_14, Function | SmallTest | Level2)
926 {
927 SHARING_LOGD("trace");
928 uint32_t ret = 0;
929 ret = ContextManager::GetInstance().HandleContextCreate();
930 EXPECT_EQ(ret, 0);
931 ContextManager::GetInstance().DestroyContext(58);
932 }
933
HWTEST_F(SharingContextUnitTest, Context_Manager_15, Function | SmallTest | Level2)934 HWTEST_F(SharingContextUnitTest, Context_Manager_15, Function | SmallTest | Level2)
935 {
936 SHARING_LOGD("trace");
937 ContextManager::GetInstance().contexts_ = {};
938 ContextManager::GetInstance().DestroyContext(58)
939 }
940
HWTEST_F(SharingContextUnitTest, Context_Manager_16, Function | SmallTest | Level2)941 HWTEST_F(SharingContextUnitTest, Context_Manager_16, Function | SmallTest | Level2)
942 {
943 SHARING_LOGD("trace");
944 uint32_t ret = 0;
945 Context::Ptr context = nullptr;
946 ContextManager::GetInstance().maxContext_ = 20;
947 ret = ContextManager::GetInstance().HandleContextCreate();
948 EXPECT_NE(ret, 0);
949 context = ContextManager::GetInstance().GetContextById(59);
950 EXPECT_NE(context, nullptr);
951 }
952
HWTEST_F(SharingContextUnitTest, Context_Manager_17, Function | SmallTest | Level2)953 HWTEST_F(SharingContextUnitTest, Context_Manager_17, Function | SmallTest | Level2)
954 {
955 SHARING_LOGD("trace");
956 Context::Ptr context = nullptr;
957 ContextManager::GetInstance().Init();
958 context = ContextManager::GetInstance().GetContextById(60);
959 EXPECT_EQ(context, nullptr)
960 }
961
HWTEST_F(SharingContextUnitTest, Context_Manager_18, Function | SmallTest | Level2)962 HWTEST_F(SharingContextUnitTest, Context_Manager_18, Function | SmallTest | Level2)
963 {
964 SHARING_LOGD("trace");
965 ContextManager::GetInstance().Init();
966 SharingEvent event;
967 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
968
969 contextEventMsgSptr->className = "ContextTestScene";
970 contextEventMsgSptr->agentType = SINK_AGENT;
971 contextEventMsgSptr->agentId = 100;
972
973 event.description = "test";
974 event.emitterType = CLASS_TYPE_PRODUCER;
975 event.eventMsg = contextEventMsgSptr;
976 event.listenerType = CLASS_TYPE_SCHEDULER;
977 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
978
979 ContextManager::GetInstance().HandleAgentCreate(event);
980 ContextManager::GetInstance().HandleContextEvent(event);
981 }
982
HWTEST_F(SharingContextUnitTest, Context_Manager_19, Function | SmallTest | Level2)983 HWTEST_F(SharingContextUnitTest, Context_Manager_19, Function | SmallTest | Level2)
984 {
985 SHARING_LOGD("trace");
986 ContextManager::GetInstance().Init();
987 SharingEvent event;
988 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
989
990 contextEventMsgSptr->className = "ContextTestScene";
991 contextEventMsgSptr->agentType = SINK_AGENT;
992 contextEventMsgSptr->agentId = 100;
993
994 event.description = "test";
995 event.emitterType = CLASS_TYPE_PRODUCER;
996 event.eventMsg = contextEventMsgSptr;
997 event.listenerType = CLASS_TYPE_SCHEDULER;
998 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
999 ContextManager::GetInstance().HandleContextEvent(event);
1000 }
1001
HWTEST_F(SharingContextUnitTest, Context_Manager_20, Function | SmallTest | Level2)1002 HWTEST_F(SharingContextUnitTest, Context_Manager_20, Function | SmallTest | Level2)
1003 {
1004 SHARING_LOGD("trace");
1005 std::string value("5687868");
1006 SharingEvent event;
1007 std::shared_ptr<ConfigEventMsg> ConfigEventMsgSptr;
1008 ConfigEventMsgSptr = std::make_shared<ConfigEventMsg>(ConfigStatus::CONFIG_STATUS_INVALID, MODULE_CONTEXT);
1009 ConfigEventMsgSptr->data = std::make_shared<SharingDataGroupByModule>("ContextTestScene");
1010 ConfigEventMsgSptr->data->PutSharingValue("agentLimit", "testdescription", std::make_shared<SharingValue>(value));
1011
1012 event.description = "test";
1013 event.emitterType = CLASS_TYPE_PRODUCER;
1014 event.eventMsg = ConfigEventMsgSptr;
1015
1016 event.listenerType = CLASS_TYPE_SCHEDULER;
1017 event.eventMsg->type = EVENT_CONFIGURE_CONTEXT;
1018
1019 ContextManager::GetInstance().HandleConfiguration(event);
1020 }
1021
HWTEST_F(SharingContextUnitTest, Context_Manager_21, Function | SmallTest | Level2)1022 HWTEST_F(SharingContextUnitTest, Context_Manager_21, Function | SmallTest | Level2)
1023 {
1024 SHARING_LOGD("trace");
1025 SharingEvent event;
1026 std::shared_ptr<ConfigEventMsg> ConfigEventMsgSptr;
1027 ConfigEventMsgSptr= std::make_shared<ConfigEventMsg>(ConfigStatus::CONFIG_STATUS_INVALID, MODULE_CONTEXT);
1028 ConfigEventMsgSptr->data = std::make_shared<SharingDataGroupByModule>("ContextTestScene");
1029 ConfigEventMsgSptr->data->PutSharingValue("networkLimit", "logOn", std::make_shared<SharingValue>(123));
1030
1031 event.description = "test";
1032 event.emitterType = CLASS_TYPE_PRODUCER;
1033 event.eventMsg = ConfigEventMsgSptr;
1034
1035 event.listenerType = CLASS_TYPE_SCHEDULER;
1036 event.eventMsg->type = EVENT_CONFIGURE_CONTEXT;
1037
1038 ContextManager::GetInstance().HandleConfiguration(event);
1039 }
1040
HWTEST_F(SharingContextUnitTest, Context_Manager_22, Function | SmallTest | Level2)1041 HWTEST_F(SharingContextUnitTest, Context_Manager_22, Function | SmallTest | Level2)
1042 {
1043 SHARING_LOGD("trace");
1044 SharingEvent event;
1045 std::shared_ptr<ConfigEventMsg> ConfigEventMsgSptr;
1046 ConfigEventMsgSptr = std::make_shared<ConfigEventMsg>(ConfigStatus::CONFIG_STATUS_INVALID, MODULE_CONTEXT);
1047
1048 event.description = "test";
1049 event.emitterType = CLASS_TYPE_PRODUCER;
1050 event.eventMsg = ConfigEventMsgSptr;
1051
1052 event.listenerType = CLASS_TYPE_SCHEDULER;
1053 event.eventMsg->type = EVENT_CONFIGURE_CONTEXT;
1054
1055 ContextManager::GetInstance().HandleConfiguration(event);
1056 }
1057
HWTEST_F(SharingContextUnitTest, Context_Manager_23, Function | SmallTest | Level2)1058 HWTEST_F(SharingContextUnitTest, Context_Manager_23, Function | SmallTest | Level2)
1059 {
1060 SHARING_LOGD("trace");
1061 ContextManager::GetInstance().Init();
1062 SharingEvent event;
1063 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
1064
1065 contextEventMsgSptr->className = "ContextTestScene";
1066 contextEventMsgSptr->agentType = SINK_AGENT;
1067 contextEventMsgSptr->agentId = 100;
1068
1069 event.description = "test";
1070 event.emitterType = CLASS_TYPE_PRODUCER;
1071 event.eventMsg = contextEventMsgSptr;
1072 event.listenerType = CLASS_TYPE_SCHEDULER;
1073 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
1074
1075 ContextManager::GetInstance().HandleAgentCreate(event);
1076 ContextManager::GetInstance().HandleMediachannelDestroy(event);
1077 }
1078
HWTEST_F(SharingContextUnitTest, Context_Manager_24, Function | SmallTest | Level2)1079 HWTEST_F(SharingContextUnitTest, Context_Manager_24, Function | SmallTest | Level2)
1080 {
1081 SHARING_LOGD("trace");
1082 ContextManager::GetInstance().Init();
1083 SharingEvent event;
1084 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
1085
1086 contextEventMsgSptr->className = "ContextTestScene";
1087 contextEventMsgSptr->agentType = SINK_AGENT;
1088 contextEventMsgSptr->agentId = 100;
1089
1090 event.description = "test";
1091 event.emitterType = CLASS_TYPE_PRODUCER;
1092 event.eventMsg = contextEventMsgSptr;
1093 event.listenerType = CLASS_TYPE_SCHEDULER;
1094 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
1095
1096 ContextManager::GetInstance().HandleMediachannelDestroy(event);
1097 }
1098
HWTEST_F(SharingContextUnitTest, Context_Manager_25, Function | SmallTest | Level2)1099 HWTEST_F(SharingContextUnitTest, Context_Manager_25, Function | SmallTest | Level2)
1100 {
1101 SHARING_LOGD("trace");
1102 ContextManager::GetInstance().Init();
1103 SharingEvent event;
1104 std::shared_ptr<ContextEventMsg> contextEventMsgSptr = std::make_shared<ContextEventMsg>();
1105
1106 contextEventMsgSptr->className = "ContextTestScene";
1107 contextEventMsgSptr->agentType = SINK_AGENT;
1108 contextEventMsgSptr->agentId = 100;
1109
1110 event.description = "test";
1111 event.emitterType = CLASS_TYPE_PRODUCER;
1112 event.eventMsg = contextEventMsgSptr;
1113 event.listenerType = CLASS_TYPE_SCHEDULER;
1114 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE;
1115
1116 std::shared_ptr<Context> context ;
1117 ContextManager::GetInstance().HandleAgentCreate(event);
1118 context = ContextManager::GetInstance().GetContextById(event.eventMsg->dstId);
1119 context->HandleCreateAgent(contextEventMsgSptr->className,
1120 contextEventMsgSptr->agentType, contextEventMsgSptr->agentId);
1121 ContextManager::GetInstance().HandleMediachannelDestroy(event);
1122 }
1123 } // namespace
1124 } // namespace Sharing
1125 } // namespace OHOS