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 "scheduler/scheduler.h" 21 22 using namespace testing::ext; 23 using namespace OHOS::Sharing; 24 25 namespace OHOS { 26 namespace Sharing { 27 28 class SharingSchedulerUnitTest : public testing::Test {}; 29 30 namespace { 31 HWTEST_F(SharingSchedulerUnitTest, Scheduler_Manager_01, Function | SmallTest | Level2) 32 { 33 SHARING_LOGD("trace"); 34 SharingEvent event; 35 int32_t ret = -1; 36 37 event.description = "test"; 38 event.emitterType = CLASS_TYPE_PRODUCER; 39 event.eventMsg = std::make_shared<ContextEventMsg>(); 40 event.listenerType = CLASS_TYPE_SCHEDULER; 41 event.eventMsg->toMgr = MODULE_CONTEXT; 42 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE; 43 44 ret = Scheduler::GetInstance().HandleEvent(event); 45 EXPECT_EQ(ret, 0); 46 } 47 48 HWTEST_F(SharingSchedulerUnitTest, Scheduler_Manager_02, Function | SmallTest | Level2) 49 { 50 SHARING_LOGD("trace"); 51 SharingEvent event; 52 int32_t ret = -1; 53 54 event.description = "test"; 55 event.emitterType = CLASS_TYPE_PRODUCER; 56 event.eventMsg = std::make_shared<ContextEventMsg>(); 57 event.listenerType = CLASS_TYPE_SCHEDULER; 58 event.eventMsg->toMgr = MODULE_CONTEXT; 59 60 event.eventMsg->type = EVENT_CONTEXTMGR_CREATE; 61 ret = Scheduler::GetInstance().HandleEvent(event); 62 EXPECT_EQ(ret, 0); 63 } 64 65 HWTEST_F(SharingSchedulerUnitTest, Scheduler_Manager_03, Function | SmallTest | Level2) 66 { 67 SHARING_LOGD("trace"); 68 SharingEvent event; 69 int32_t ret = -1; 70 71 event.description = "test"; 72 event.emitterType = CLASS_TYPE_PRODUCER; 73 event.eventMsg = std::make_shared<ContextEventMsg>(); 74 event.listenerType = CLASS_TYPE_SCHEDULER; 75 event.eventMsg->toMgr = MODULE_CONTEXT; 76 event.eventMsg->type = EVENT_CONTEXTMGR_AGENT_CREATE; 77 78 ret = Scheduler::GetInstance().HandleEvent(event); 79 EXPECT_EQ(ret, 0); 80 } 81 82 HWTEST_F(SharingSchedulerUnitTest, Scheduler_Manager_04, Function | SmallTest | Level2) 83 { 84 SHARING_LOGD("trace"); 85 SharingEvent event; 86 int32_t ret = -1; 87 88 event.description = "test"; 89 event.emitterType = CLASS_TYPE_PRODUCER; 90 event.eventMsg = std::make_shared<ContextEventMsg>(); 91 event.listenerType = CLASS_TYPE_SCHEDULER; 92 event.eventMsg->toMgr = MODULE_CONTEXT; 93 event.eventMsg->type = EVENT_CONTEXT_AGENT_CREATE; 94 event.eventMsg->type = EVENT_CONTEXTMGR_STATE_CHANNEL_DESTROY; 95 96 ret = Scheduler::GetInstance().HandleEvent(event); 97 EXPECT_EQ(ret, 0); 98 } 99 100 HWTEST_F(SharingSchedulerUnitTest, Scheduler_Manager_05, Function | SmallTest | Level2) 101 { 102 SHARING_LOGD("trace"); 103 SharingEvent event; 104 int32_t ret = -1; 105 106 event.description = "test"; 107 event.emitterType = CLASS_TYPE_PRODUCER; 108 event.eventMsg = std::make_shared<ContextEventMsg>(); 109 event.listenerType = CLASS_TYPE_SCHEDULER; 110 event.eventMsg->toMgr = MODULE_CONTEXT; 111 event.eventMsg->type = EVENT_CONTEXT_STATE_AGENT_DESTROY; 112 113 ret = Scheduler::GetInstance().HandleEvent(event); 114 EXPECT_EQ(ret, 0); 115 } 116 117 HWTEST_F(SharingSchedulerUnitTest, Scheduler_Manager_06, Function | SmallTest | Level2) 118 { 119 SHARING_LOGD("trace"); 120 SharingEvent event; 121 int32_t ret = -1; 122 123 event.description = "test"; 124 event.emitterType = CLASS_TYPE_PRODUCER; 125 event.eventMsg = std::make_shared<ContextEventMsg>(); 126 event.listenerType = CLASS_TYPE_SCHEDULER; 127 event.eventMsg->toMgr = MODULE_MEDIACHANNEL; 128 event.eventMsg->type = EVENT_CONFIGURE_MEDIACHANNEL; 129 130 ret = Scheduler::GetInstance().HandleEvent(event); 131 EXPECT_EQ(ret, 0); 132 } 133 134 HWTEST_F(SharingSchedulerUnitTest, Scheduler_Manager_07, Function | SmallTest | Level2) 135 { 136 SHARING_LOGD("trace"); 137 SharingEvent event; 138 int32_t ret = -1; 139 140 event.description = "test"; 141 event.emitterType = CLASS_TYPE_PRODUCER; 142 event.eventMsg = std::make_shared<ContextEventMsg>(); 143 event.listenerType = CLASS_TYPE_SCHEDULER; 144 event.eventMsg->toMgr = MODULE_MEDIACHANNEL; 145 146 ret = Scheduler::GetInstance().HandleEvent(event); 147 EXPECT_EQ(ret, 0); 148 } 149 150 HWTEST_F(SharingSchedulerUnitTest, Scheduler_Manager_08, Function | SmallTest | Level2) 151 { 152 SHARING_LOGD("trace"); 153 SharingEvent event; 154 int32_t ret = -1; 155 156 event.description = "test"; 157 event.emitterType = CLASS_TYPE_PRODUCER; 158 event.eventMsg = std::make_shared<ContextEventMsg>(); 159 event.listenerType = CLASS_TYPE_SCHEDULER; 160 event.eventMsg->toMgr = MODULE_INTERACTION; 161 event.eventMsg->type = EVENT_CONFIGURE_INTERACT; 162 163 ret = Scheduler::GetInstance().HandleEvent(event); 164 EXPECT_EQ(ret, 0); 165 } 166 167 HWTEST_F(SharingSchedulerUnitTest, Scheduler_Manager_9, Function | SmallTest | Level2) 168 { 169 SHARING_LOGD("trace"); 170 SharingEvent event; 171 int32_t ret = -1; 172 173 event.description = "test"; 174 event.emitterType = CLASS_TYPE_PRODUCER; 175 event.eventMsg = std::make_shared<ContextEventMsg>(); 176 event.listenerType = CLASS_TYPE_SCHEDULER; 177 event.eventMsg->toMgr = MODULE_DATACENTER; 178 event.eventMsg->type = EVENT_INTERACTIONMGR_REMOVE_INTERACTION; 179 180 ret = Scheduler::GetInstance().HandleEvent(event); 181 EXPECT_EQ(ret, -1); 182 } 183 184 } // namespace 185 } // namespace Sharing 186 } // namespace OHOS