1 /*
2 * Copyright (c) 2025 Huawei Device 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 <chrono>
17 #include <gtest/gtest.h>
18 #include <gmock/gmock.h>
19 #include <thread>
20
21 #include "event_handler_wrap.h"
22 #include "hilog_tag_wrapper.h"
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace AAFwk {
28 namespace {
29 constexpr int32_t TIME_DELAY = 100;
30 constexpr int32_t TIME_SLEEP = 4000;
GetCurrentTimeMillis()31 inline int64_t GetCurrentTimeMillis()
32 {
33 return std::chrono::duration_cast<std::chrono::milliseconds>(
34 std::chrono::steady_clock::now().time_since_epoch()).count();
35 }
36 }
37 MockLogger MockLogger::instance;
38 bool EventTask::cancelStatus = false;
39 static std::shared_ptr<TaskHandlerWrap> instance = std::make_shared<TaskHandlerWrap>();
GetFfrtHandler()40 std::shared_ptr<TaskHandlerWrap> TaskHandlerWrap::GetFfrtHandler()
41 {
42 return instance;
43 }
44
45 static bool g_isEqual = false;
operator ==(const EventWrap & lhs,const EventWrap & rhs)46 bool operator==(const EventWrap &lhs, const EventWrap &rhs)
47 {
48 return g_isEqual;
49 }
50
51 class MockEventHandlerWrap : public EventHandlerWrap {
52 public:
53 MOCK_METHOD(void, ProcessEvent, (const EventWrap& event), ());
54 };
55
56 class EventHandlerWrapTest : public testing::Test {
57 public:
58 static void SetUpTestCase(void);
59 static void TearDownTestCase(void);
60 void SetUp() override;
61 void TearDown() override;
62 };
63
SetUpTestCase(void)64 void EventHandlerWrapTest::SetUpTestCase(void)
65 {}
TearDownTestCase(void)66 void EventHandlerWrapTest::TearDownTestCase(void)
67 {}
SetUp()68 void EventHandlerWrapTest::SetUp()
69 {}
TearDown()70 void EventHandlerWrapTest::TearDown()
71 {}
72
73 /**
74 * @tc.name: SendEvent_0010
75 * @tc.desc: Task handler is null.
76 * @tc.type: FUNC
77 */
78 HWTEST_F(EventHandlerWrapTest, SendEvent_0010, TestSize.Level2)
79 {
80 auto handler = std::make_shared<MockEventHandlerWrap>();
81 handler->taskHandler_ = nullptr;
82
83 EventWrap event;
84 bool result = handler->SendEvent(event, TIME_DELAY, false);
85 EXPECT_FALSE(result);
86 }
87
88 /**
89 * @tc.name: SendEvent_0020
90 * @tc.desc: Send same event fail.
91 * @tc.type: FUNC
92 */
93 HWTEST_F(EventHandlerWrapTest, SendEvent_0020, TestSize.Level2)
94 {
95 auto handler = std::make_shared<MockEventHandlerWrap>();
96 auto taskHandler = std::make_shared<TaskHandlerWrap>();
97 handler->taskHandler_ = taskHandler;
98
99 EventWrap event;
100 handler->eventMap_["test_event"] = event;
101 event.eventString = "test_event";
102 bool result = handler->SendEvent(event, TIME_DELAY, false);
103 EXPECT_FALSE(result);
104 }
105
106 /**
107 * @tc.name: SendEvent_0030
108 * @tc.desc: Send event success.
109 * @tc.type: FUNC
110 */
111 HWTEST_F(EventHandlerWrapTest, SendEvent_0030, TestSize.Level2)
112 {
113 auto handler = std::make_shared<MockEventHandlerWrap>();
114 auto taskHandler = std::make_shared<TaskHandlerWrap>();
115 handler->taskHandler_ = taskHandler;
116
117 EventWrap event;
118 event.eventString = "test_event";
119
120 EXPECT_CALL(*taskHandler, SubmitTaskJust(::testing::_, "test_event", TIME_DELAY))
121 .WillOnce(::testing::Return(std::make_shared<int32_t>(0)));
122
123 bool result = handler->SendEvent(event, TIME_DELAY, false);
124 EXPECT_TRUE(result);
125 }
126
127 /**
128 * @tc.name: SendEvent_0040
129 * @tc.desc: force insert event success.
130 * @tc.type: FUNC
131 */
132 HWTEST_F(EventHandlerWrapTest, SendEvent_0040, TestSize.Level2) {
133 auto handler = std::make_shared<MockEventHandlerWrap>();
134 auto taskHandler = std::make_shared<TaskHandlerWrap>();
135 handler->taskHandler_ = taskHandler;
136
137 EventWrap event1, event2;
138 event2.eventString = "test_event";
139 handler->eventMap_["test_event"] = event1;
140
141 EXPECT_CALL(*taskHandler, SubmitTaskJust(::testing::_, "test_event", TIME_DELAY))
142 .WillOnce(::testing::Return(std::make_shared<int32_t>(0)));
143
144 bool result = handler->SendEvent(event2, TIME_DELAY, true);
145 EXPECT_TRUE(result);
146 EXPECT_EQ(handler->eventMap_["test_event"].GetEventString(), "test_event");
147 }
148
149 /**
150 * @tc.name: SendEvent_0050
151 * @tc.desc: SendEvent event success and execute timeout.
152 * @tc.type: FUNC
153 */
154 HWTEST_F(EventHandlerWrapTest, SendEvent_0050, TestSize.Level2) {
155 auto handler = std::make_shared<MockEventHandlerWrap>();
156 auto taskHandler = std::make_shared<TaskHandlerWrap>();
157 handler->taskHandler_ = taskHandler;
158
159 EventWrap event2;
160 event2.eventString = "test_event";
161 event2.sameStatus = true;
162
163 EXPECT_CALL(*taskHandler, SubmitTaskJust(::testing::_, "test_event", TIME_DELAY))
__anonbb05157a0202(std::function<void()> task, const std::string& name, int64_t delay) 164 .WillOnce([](std::function<void()> task, const std::string& name, int64_t delay) {
165 if (task) {
166 std::thread(task).detach();
167 }
168 return std::make_shared<int32_t>(0);
169 });
170 EXPECT_CALL(MockLogger::instance, PrintLog).Times(2)
__anonbb05157a0302(const std::string &fmt) 171 .WillRepeatedly([](const std::string &fmt) {
172 GTEST_LOG_(INFO) << fmt;
173 });
174 EXPECT_CALL(*handler, ProcessEvent).Times(1);
175 bool result = handler->SendEvent(event2, TIME_DELAY, true);
176 usleep(TIME_SLEEP);
177 EXPECT_TRUE(result);
178 }
179
180 /**
181 * @tc.name: SendEvent_0060
182 * @tc.desc: SendEvent event success and execute timeout.
183 * @tc.type: FUNC
184 */
185 HWTEST_F(EventHandlerWrapTest, SendEvent_0060, TestSize.Level2) {
186 auto handler = std::make_shared<MockEventHandlerWrap>();
187 auto taskHandler = std::make_shared<TaskHandlerWrap>();
188 handler->taskHandler_ = taskHandler;
189
190 EventWrap event2;
191 event2.eventString = "test_event";
192 event2.sameStatus = true;
193 event2.createTime = GetCurrentTimeMillis();
194
195 EXPECT_CALL(*taskHandler, SubmitTaskJust(::testing::_, "test_event", TIME_DELAY))
__anonbb05157a0402(std::function<void()> task, const std::string& name, int64_t delay) 196 .WillOnce([](std::function<void()> task, const std::string& name, int64_t delay) {
197 if (task) {
198 std::thread(task).detach();
199 }
200 return std::make_shared<int32_t>(0);
201 });
202 EXPECT_CALL(MockLogger::instance, PrintLog).Times(1);
203 EXPECT_CALL(*handler, ProcessEvent).Times(1);
204 bool result = handler->SendEvent(event2, TIME_DELAY, true);
205 usleep(TIME_SLEEP);
206 EXPECT_TRUE(result);
207 Mock::VerifyAndClear(&MockLogger::instance);
208 }
209
210 /**
211 * @tc.name: RemoveEvent_0010
212 * @tc.desc: RemoveEvent not found.
213 * @tc.type: FUNC
214 */
215 HWTEST_F(EventHandlerWrapTest, RemoveEvent_0010, TestSize.Level2) {
216 auto handler = std::make_shared<MockEventHandlerWrap>();
217
218 EventWrap event2;
219 event2.eventString = "test_event";
220
221 bool result = handler->RemoveEvent(event2);
222 EXPECT_FALSE(result);
223 }
224
225 /**
226 * @tc.name: RemoveEvent_0020
227 * @tc.desc: RemoveEvent force success.
228 * @tc.type: FUNC
229 */
230 HWTEST_F(EventHandlerWrapTest, RemoveEvent_0020, TestSize.Level2) {
231 auto handler = std::make_shared<MockEventHandlerWrap>();
232
233 EventWrap event2;
234 event2.eventString = "test_event";
235 handler->eventMap_["test_event"] = event2;
236
237 bool result = handler->RemoveEvent(event2);
238 EXPECT_TRUE(result);
239 }
240
241 /**
242 * @tc.name: RemoveEvent_0030
243 * @tc.desc: RemoveEvent same success.
244 * @tc.type: FUNC
245 */
246 HWTEST_F(EventHandlerWrapTest, RemoveEvent_0030, TestSize.Level2) {
247 auto handler = std::make_shared<MockEventHandlerWrap>();
248
249 EventWrap event2;
250 event2.eventString = "test_event";
251 event2.sameStatus = true;
252 handler->eventMap_["test_event"] = event2;
253
254 bool result = handler->RemoveEvent(event2, false);
255 EXPECT_TRUE(result);
256 }
257
258 /**
259 * @tc.name: RemoveEvent_0040
260 * @tc.desc: RemoveEvent fail (not same, not force).
261 * @tc.type: FUNC
262 */
263 HWTEST_F(EventHandlerWrapTest, RemoveEvent_0040, TestSize.Level2) {
264 auto handler = std::make_shared<MockEventHandlerWrap>();
265
266 EventWrap event2;
267 event2.eventString = "test_event";
268 event2.sameStatus = false;
269 handler->eventMap_["test_event"] = event2;
270
271 bool result = handler->RemoveEvent(event2, false);
272 EXPECT_FALSE(result);
273 }
274
275 /**
276 * @tc.name: RemoveEvent_0050
277 * @tc.desc: RemoveEvent success and cancel success.
278 * @tc.type: FUNC
279 */
280 HWTEST_F(EventHandlerWrapTest, RemoveEvent_0050, TestSize.Level2) {
281 auto handler = std::make_shared<MockEventHandlerWrap>();
282
283 EventWrap event2;
284 event2.eventString = "test_event";
285 event2.sameStatus = true;
286 handler->eventMap_["test_event"] = event2;
287 EventTask::cancelStatus = true;
288 EXPECT_CALL(MockLogger::instance, PrintLog)
__anonbb05157a0502(const std::string &fmt) 289 .WillRepeatedly([](const std::string &fmt) {
290 GTEST_LOG_(INFO) << fmt;
291 });
292 bool result = handler->RemoveEvent(event2);
293 EXPECT_TRUE(result);
294 EventTask::cancelStatus = false;
295 }
296
297 /**
298 * @tc.name: RemoveEvent_0060
299 * @tc.desc: RemoveEvent success and cancel success.
300 * @tc.type: FUNC
301 */
302 HWTEST_F(EventHandlerWrapTest, RemoveEvent_0060, TestSize.Level2) {
303 auto handler = std::make_shared<MockEventHandlerWrap>();
304
305 EventWrap event2;
306 event2.eventString = "test_event";
307 event2.sameStatus = true;
308 event2.createTime = GetCurrentTimeMillis();
309 handler->eventMap_["test_event"] = event2;
310 EventTask::cancelStatus = true;
311 EXPECT_CALL(MockLogger::instance, PrintLog).Times(0);
312 bool result = handler->RemoveEvent(event2);
313 EXPECT_TRUE(result);
314 EventTask::cancelStatus = false;
315 Mock::VerifyAndClear(&MockLogger::instance);
316 }
317 } // namespace AAFwk
318 } // namespace OHOS