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 UpdateOperation(SessionStatusMsg::Ptr & statusMsg)40 void UpdateOperation(SessionStatusMsg::Ptr &statusMsg) override 41 { 42 (void)statusMsg; 43 return; 44 } UpdateMediaStatus(SessionStatusMsg::Ptr & statusMsg)45 void UpdateMediaStatus(SessionStatusMsg::Ptr &statusMsg) override 46 { 47 (void)statusMsg; 48 return; 49 } HandleEvent(SharingEvent & event)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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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