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/sharing_log.h"
19 #include "event/event_manager.h"
20 #include "event/taskpool.h"
21
22 using namespace testing::ext;
23 using namespace OHOS::Sharing;
24
25 namespace OHOS {
26 namespace Sharing {
27 class EventListenerImpl : public EventListener {
28 public:
29 EventListenerImpl() = default;
OnEvent(SharingEvent & event)30 int32_t OnEvent(SharingEvent &event) final
31 {
32 SHARING_LOGD("onEvent");
33 return 0;
34 }
35 };
36
37 class SharingEventUnitTest : public testing::Test {};
38
39 namespace {
40 HWTEST_F(SharingEventUnitTest, Event_Base_01, Function | SmallTest | Level2)
41 {
42 SHARING_LOGD("trace");
43 std::shared_ptr<EventEmitter> emitter = std::make_shared<EventEmitter>();
44 EXPECT_NE(emitter, nullptr);
45 SharingEvent event;
46 event.description = "test";
47 event.emitterType = CLASS_TYPE_PRODUCER;
48 event.eventMsg = std::make_shared<EventMsg>();
49 event.listenerType = CLASS_TYPE_SCHEDULER;
50 int32_t ret = emitter->SendEvent(event);
51 EXPECT_EQ(ret, 0);
52 ret = emitter->SendSyncEvent(event);
53 EXPECT_EQ(ret, 0);
54 }
55
56 HWTEST_F(SharingEventUnitTest, Event_Base_03, Function | SmallTest | Level2)
57 {
58 SHARING_LOGD("trace");
59 EventMsg::Ptr eventMsg = std::make_shared<EventMsg>();
60 eventMsg->type = EVENT_AGENT_BASE;
61 eventMsg->toMgr = MODULE_CONTEXT;
62 EventChecker::CheckEvent(eventMsg);
63
64 eventMsg->type = EVENT_SESSION_BASE;
65 eventMsg->toMgr = MODULE_MEDIACHANNEL;
66 EventChecker::CheckEvent(eventMsg);
67
68 eventMsg->type = EVENT_SCHEDULER_BASE;
69 eventMsg->toMgr = MODULE_MEDIACHANNEL;
70 EventChecker::CheckEvent(eventMsg);
71
72 eventMsg->type = EVENT_SCHEDULER_BASE;
73 eventMsg->toMgr = MODULE_CONFIGURE;
74 EventChecker::CheckEvent(eventMsg);
75
76 eventMsg->type = (EventType)7000;
77 eventMsg->toMgr = MODULE_CONFIGURE;
78 EventChecker::CheckEvent(eventMsg);
79
80 eventMsg->type = (EventType)7000;
81 eventMsg->toMgr = MODULE_INTERACTION;
82 EventChecker::CheckEvent(eventMsg);
83
84 EventChecker::CheckEvent(nullptr);
85 }
86
87 HWTEST_F(SharingEventUnitTest, Event_Manager_01, Function | SmallTest | Level2)
88 {
89 SHARING_LOGD("trace");
90 auto ret = EventManager::GetInstance().Init();
91 EXPECT_EQ(ret, 0);
92
93 ret = EventManager::GetInstance().StartEventLoop();
94 EXPECT_EQ(ret, 0);
95
96 EventManager::GetInstance().StopEventLoop();
97
98 std::shared_ptr<EventListenerImpl> listener = std::make_shared<EventListenerImpl>();
99 std::shared_ptr<EventListenerImpl> listener1 = std::make_shared<EventListenerImpl>();
100 std::shared_ptr<EventListenerImpl> listener2 = std::make_shared<EventListenerImpl>();
101
102 ret = EventManager::GetInstance().AddListener(listener);
103 EXPECT_EQ(ret, 0);
104 ret = EventManager::GetInstance().AddListener(listener1);
105 EXPECT_EQ(ret, 0);
106 ret = EventManager::GetInstance().AddListener(listener2);
107 EXPECT_EQ(ret, 0);
108
109 ret = EventManager::GetInstance().DelListener(listener);
110 EXPECT_EQ(ret, 0);
111
112 ret = EventManager::GetInstance().DrainAllListeners();
113 EXPECT_EQ(ret, 0);
114
115 SharingEvent event;
116 event.description = "test";
117 event.emitterType = CLASS_TYPE_PRODUCER;
118 event.eventMsg = std::make_shared<EventMsg>();
119 event.listenerType = CLASS_TYPE_SCHEDULER;
120 ret = EventManager::GetInstance().PushEvent(event);
121 EXPECT_EQ(ret, 0);
122
123 ret = EventManager::GetInstance().PushSyncEvent(event);
124 EXPECT_EQ(ret, 0);
125 }
126
testTask()127 int32_t testTask()
128 {
129 SHARING_LOGD("testTask");
130 sleep(2);
131 return 0;
132 }
133 HWTEST_F(SharingEventUnitTest, Task_Pool_01, Function | SmallTest | Level2)
134 {
135 SHARING_LOGD("task_Pool_01");
136 std::shared_ptr<TaskPool> taskPool = std::make_shared<TaskPool>();
137 EXPECT_NE(taskPool, nullptr);
138
139 taskPool->SetMaxTaskNum(1000);
140 auto ret = taskPool->GetMaxTaskNum();
141 EXPECT_EQ(ret, (uint32_t)1000);
142
143 ret = taskPool->Start(100);
144 EXPECT_EQ(ret, (int32_t)0);
145
146 taskPool->SetTimeoutInterval(1000);
147
148 std::packaged_task<TaskPool::BindedTask> bindedTask(testTask);
149 taskPool->PushTask(bindedTask);
150
151 ret = taskPool->GetTaskNum();
152 EXPECT_EQ(ret, 1);
153
154 taskPool->Stop();
155 }
156 } // namespace
157 } // namespace Sharing
158 } // namespace OHOS