1 /*
2 * Copyright (c) 2022-2023 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 <gtest/gtest.h>
17 #include <numeric>
18 #define private public
19 #include "common_event_control_manager.h"
20 #undef private
21
22 using namespace testing::ext;
23 using namespace OHOS::AppExecFwk;
24 namespace OHOS {
25 namespace EventFwk {
26
27 class CommonEventControlManagerTest : public testing::Test {
28 public:
CommonEventControlManagerTest()29 CommonEventControlManagerTest()
30 {}
~CommonEventControlManagerTest()31 ~CommonEventControlManagerTest()
32 {}
33
34 static void SetUpTestCase(void);
35 static void TearDownTestCase(void);
36 void SetUp();
37 void TearDown();
38 };
39
SetUpTestCase(void)40 void CommonEventControlManagerTest::SetUpTestCase(void)
41 {}
42
TearDownTestCase(void)43 void CommonEventControlManagerTest::TearDownTestCase(void)
44 {}
45
SetUp(void)46 void CommonEventControlManagerTest::SetUp(void)
47 {}
48
TearDown(void)49 void CommonEventControlManagerTest::TearDown(void)
50 {}
51
52 /**
53 * @tc.name: CommonEventControlManager_0100
54 * @tc.desc: test PublishStickyCommonEvent function and subscriberRecord is nullptr.
55 * @tc.type: FUNC
56 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0100,Level1)57 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0100, Level1)
58 {
59 GTEST_LOG_(INFO) << "CommonEventControlManager_0100 start";
60 CommonEventControlManager commonEventControlManager;
61 CommonEventRecord eventRecord;
62 std::shared_ptr<EventSubscriberRecord> subscriberRecord = nullptr;
63 bool sticky = commonEventControlManager.PublishStickyCommonEvent(eventRecord, subscriberRecord);
64 EXPECT_EQ(false, sticky);
65 GTEST_LOG_(INFO) << "CommonEventControlManager_0100 end";
66 }
67
68 /**
69 * @tc.name: CommonEventControlManager_0200
70 * @tc.desc: test NotifyUnorderedEvent function and eventRecord is nullptr.
71 * @tc.type: FUNC
72 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0200,Level1)73 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0200, Level1)
74 {
75 GTEST_LOG_(INFO) << "CommonEventControlManager_0200 start";
76 CommonEventControlManager commonEventControlManager;
77 std::shared_ptr<OrderedEventRecord> eventRecord = nullptr;
78 bool sticky = commonEventControlManager.NotifyUnorderedEvent(eventRecord);
79 EXPECT_EQ(false, sticky);
80 GTEST_LOG_(INFO) << "CommonEventControlManager_0200 end";
81 }
82
83 /**
84 * @tc.name: CommonEventControlManager_0300
85 * @tc.desc: test EnqueueUnorderedRecord function and eventRecordPtr is nullptr.
86 * @tc.type: FUNC
87 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0300,Level1)88 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0300, Level1)
89 {
90 GTEST_LOG_(INFO) << "CommonEventControlManager_0300 start";
91 CommonEventControlManager commonEventControlManager;
92 std::shared_ptr<OrderedEventRecord> eventRecordPtr = nullptr;
93 bool sticky = commonEventControlManager.EnqueueUnorderedRecord(eventRecordPtr);
94 EXPECT_EQ(false, sticky);
95 GTEST_LOG_(INFO) << "CommonEventControlManager_0300 end";
96 }
97
98 /**
99 * @tc.name: CommonEventControlManager_0500
100 * @tc.desc: test NotifyOrderedEvent function and eventRecordPtr is nullptr.
101 * @tc.type: FUNC
102 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0500,Level1)103 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0500, Level1)
104 {
105 GTEST_LOG_(INFO) << "CommonEventControlManager_0500 start";
106 CommonEventControlManager commonEventControlManager;
107 std::shared_ptr<OrderedEventRecord> eventRecordPtr = nullptr;
108 size_t index = 1;
109 EXPECT_EQ(false, commonEventControlManager.NotifyOrderedEvent(eventRecordPtr, index));
110 GTEST_LOG_(INFO) << "CommonEventControlManager_0500 end";
111 }
112
113 /**
114 * @tc.name: CommonEventControlManager_0600
115 * @tc.desc: test NotifyOrderedEvent function.
116 * @tc.type: FUNC
117 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0600,Level1)118 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0600, Level1)
119 {
120 GTEST_LOG_(INFO) << "CommonEventControlManager_0600 start";
121 CommonEventControlManager commonEventControlManager;
122 std::shared_ptr<OrderedEventRecord> eventRecordPtr = std::make_shared<OrderedEventRecord>();
123 size_t index = -1;
124 EXPECT_EQ(false, commonEventControlManager.NotifyOrderedEvent(eventRecordPtr, index));
125 GTEST_LOG_(INFO) << "CommonEventControlManager_0600 end";
126 }
127
128 /**
129 * @tc.name: CommonEventControlManager_0700
130 * @tc.desc: test NotifyOrderedEvent function.
131 * @tc.type: FUNC
132 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0700,Level1)133 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0700, Level1)
134 {
135 GTEST_LOG_(INFO) << "CommonEventControlManager_0700 start";
136 CommonEventControlManager commonEventControlManager;
137 std::shared_ptr<OrderedEventRecord> eventRecordPtr = std::make_shared<OrderedEventRecord>();
138 size_t index = 0;
139 EXPECT_EQ(false, commonEventControlManager.NotifyOrderedEvent(eventRecordPtr, index));
140 GTEST_LOG_(INFO) << "CommonEventControlManager_0700 end";
141 }
142
143 /**
144 * @tc.name: CommonEventControlManager_0800
145 * @tc.desc: test SetTimeout function.
146 * @tc.type: FUNC
147 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0800,Level1)148 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0800, Level1)
149 {
150 GTEST_LOG_(INFO) << "CommonEventControlManager_0800 start";
151 CommonEventControlManager commonEventControlManager;
152 commonEventControlManager.pendingTimeoutMessage_ = true;
153 EXPECT_EQ(true, commonEventControlManager.SetTimeout());
154 GTEST_LOG_(INFO) << "CommonEventControlManager_0800 end";
155 }
156
157 /**
158 * @tc.name: CommonEventControlManager_0900
159 * @tc.desc: test FinishReceiverAction function and recordPtr is nullptr.
160 * @tc.type: FUNC
161 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0900,Level1)162 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0900, Level1)
163 {
164 GTEST_LOG_(INFO) << "CommonEventControlManager_0900 start";
165 CommonEventControlManager commonEventControlManager;
166 std::shared_ptr<OrderedEventRecord> recordPtr = nullptr;
167 int32_t code = 1;
168 std::string receiverData = "aa";
169 bool abortEvent = false;
170 EXPECT_EQ(false, commonEventControlManager.FinishReceiverAction(recordPtr, code, receiverData, abortEvent));
171 GTEST_LOG_(INFO) << "CommonEventControlManager_0900 end";
172 }
173
174 /**
175 * @tc.name: CommonEventControlManager_1300
176 * @tc.desc: test GetUnorderedEventRecords function.
177 * @tc.type: FUNC
178 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1300,Level1)179 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1300, Level1)
180 {
181 GTEST_LOG_(INFO) << "CommonEventControlManager_1300 start";
182 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
183 std::make_shared<CommonEventControlManager>();
184 ASSERT_NE(nullptr, commonEventControlManager);
185 std::string event = "";
186 int32_t userId = ALL_USER;
187 std::vector<std::shared_ptr<OrderedEventRecord>> records;
188 commonEventControlManager->GetUnorderedEventRecords(event, userId, records);
189 GTEST_LOG_(INFO) << "CommonEventControlManager_1300 end";
190 }
191
192 /**
193 * @tc.name: CommonEventControlManager_1400
194 * @tc.desc: test GetUnorderedEventRecords function.
195 * @tc.type: FUNC
196 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1400,Level1)197 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1400, Level1)
198 {
199 GTEST_LOG_(INFO) << "CommonEventControlManager_1400 start";
200 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
201 std::make_shared<CommonEventControlManager>();
202 ASSERT_NE(nullptr, commonEventControlManager);
203 std::string event = "";
204 int32_t userId = ALL_USER + 1;
205 std::vector<std::shared_ptr<OrderedEventRecord>> records;
206 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
207 record->userId = ALL_USER + 1;
208 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
209 commonEventControlManager->GetUnorderedEventRecords(event, userId, records);
210 GTEST_LOG_(INFO) << "CommonEventControlManager_1400 end";
211 }
212
213 /**
214 * @tc.name: CommonEventControlManager_1500
215 * @tc.desc: test GetUnorderedEventRecords function.
216 * @tc.type: FUNC
217 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1500,Level1)218 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1500, Level1)
219 {
220 GTEST_LOG_(INFO) << "CommonEventControlManager_1500 start";
221 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
222 std::make_shared<CommonEventControlManager>();
223 ASSERT_NE(nullptr, commonEventControlManager);
224 std::string event = "";
225 int32_t userId = ALL_USER + 1;
226 std::vector<std::shared_ptr<OrderedEventRecord>> records;
227 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
228 record->userId = ALL_USER + 2;
229 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
230 commonEventControlManager->GetUnorderedEventRecords(event, userId, records);
231 GTEST_LOG_(INFO) << "CommonEventControlManager_1500 end";
232 }
233
234 /**
235 * @tc.name: CommonEventControlManager_1600
236 * @tc.desc: test GetUnorderedEventRecords function.
237 * @tc.type: FUNC
238 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1600,Level1)239 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1600, Level1)
240 {
241 GTEST_LOG_(INFO) << "CommonEventControlManager_1600 start";
242 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
243 std::make_shared<CommonEventControlManager>();
244 ASSERT_NE(nullptr, commonEventControlManager);
245 std::string event = "aa";
246 int32_t userId = ALL_USER;
247 std::vector<std::shared_ptr<OrderedEventRecord>> records;
248 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
249 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
250 record->commonEventData = commonEventData;
251 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
252 commonEventControlManager->GetUnorderedEventRecords(event, userId, records);
253 GTEST_LOG_(INFO) << "CommonEventControlManager_1600 end";
254 }
255
256 /**
257 * @tc.name: CommonEventControlManager_1700
258 * @tc.desc: test GetUnorderedEventRecords function.
259 * @tc.type: FUNC
260 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1700,Level1)261 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1700, Level1)
262 {
263 GTEST_LOG_(INFO) << "CommonEventControlManager_1700 start";
264 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
265 std::make_shared<CommonEventControlManager>();
266 ASSERT_NE(nullptr, commonEventControlManager);
267 std::string event = "aa";
268 int32_t userId = ALL_USER + 1;
269 std::vector<std::shared_ptr<OrderedEventRecord>> records;
270 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
271 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
272 record->commonEventData = commonEventData;
273 record->userId = ALL_USER + 1;
274 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
275 commonEventControlManager->GetUnorderedEventRecords(event, userId, records);
276 GTEST_LOG_(INFO) << "CommonEventControlManager_1700 end";
277 }
278
279 /**
280 * @tc.name: CommonEventControlManager_1800
281 * @tc.desc: test GetUnorderedEventRecords function.
282 * @tc.type: FUNC
283 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1800,Level1)284 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1800, Level1)
285 {
286 GTEST_LOG_(INFO) << "CommonEventControlManager_1800 start";
287 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
288 std::make_shared<CommonEventControlManager>();
289 ASSERT_NE(nullptr, commonEventControlManager);
290 std::string event = "aa";
291 int32_t userId = ALL_USER + 1;
292 std::vector<std::shared_ptr<OrderedEventRecord>> records;
293 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
294 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
295 record->commonEventData = commonEventData;
296 record->userId = ALL_USER;
297 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
298 commonEventControlManager->GetUnorderedEventRecords(event, userId, records);
299 GTEST_LOG_(INFO) << "CommonEventControlManager_1800 end";
300 }
301
302 /**
303 * @tc.name: CommonEventControlManager_1900
304 * @tc.desc: test GetOrderedEventRecords function.
305 * @tc.type: FUNC
306 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1900,Level1)307 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1900, Level1)
308 {
309 GTEST_LOG_(INFO) << "CommonEventControlManager_1900 start";
310 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
311 std::make_shared<CommonEventControlManager>();
312 ASSERT_NE(nullptr, commonEventControlManager);
313 std::string event = "";
314 int32_t userId = ALL_USER;
315 std::vector<std::shared_ptr<OrderedEventRecord>> records;
316 commonEventControlManager->GetOrderedEventRecords(event, userId, records);
317 GTEST_LOG_(INFO) << "CommonEventControlManager_1900 end";
318 }
319
320 /**
321 * @tc.name: CommonEventControlManager_2000
322 * @tc.desc: test GetOrderedEventRecords function.
323 * @tc.type: FUNC
324 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2000,Level1)325 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2000, Level1)
326 {
327 GTEST_LOG_(INFO) << "CommonEventControlManager_2000 start";
328 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
329 std::make_shared<CommonEventControlManager>();
330 ASSERT_NE(nullptr, commonEventControlManager);
331 std::string event = "";
332 int32_t userId = ALL_USER + 1;
333 std::vector<std::shared_ptr<OrderedEventRecord>> records;
334 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
335 record->userId = ALL_USER + 1;
336 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
337 commonEventControlManager->GetOrderedEventRecords(event, userId, records);
338 GTEST_LOG_(INFO) << "CommonEventControlManager_2000 end";
339 }
340
341 /**
342 * @tc.name: CommonEventControlManager_2100
343 * @tc.desc: test GetOrderedEventRecords function.
344 * @tc.type: FUNC
345 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2100,Level1)346 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2100, Level1)
347 {
348 GTEST_LOG_(INFO) << "CommonEventControlManager_2100 start";
349 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
350 std::make_shared<CommonEventControlManager>();
351 ASSERT_NE(nullptr, commonEventControlManager);
352 std::string event = "";
353 int32_t userId = ALL_USER + 1;
354 std::vector<std::shared_ptr<OrderedEventRecord>> records;
355 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
356 record->userId = ALL_USER + 2;
357 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
358 commonEventControlManager->GetOrderedEventRecords(event, userId, records);
359 GTEST_LOG_(INFO) << "CommonEventControlManager_2100 end";
360 }
361
362 /**
363 * @tc.name: CommonEventControlManager_2200
364 * @tc.desc: test GetOrderedEventRecords function.
365 * @tc.type: FUNC
366 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2200,Level1)367 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2200, Level1)
368 {
369 GTEST_LOG_(INFO) << "CommonEventControlManager_2200 start";
370 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
371 std::make_shared<CommonEventControlManager>();
372 ASSERT_NE(nullptr, commonEventControlManager);
373 std::string event = "aa";
374 int32_t userId = ALL_USER;
375 std::vector<std::shared_ptr<OrderedEventRecord>> records;
376 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
377 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
378 record->commonEventData = commonEventData;
379 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
380 commonEventControlManager->GetOrderedEventRecords(event, userId, records);
381 GTEST_LOG_(INFO) << "CommonEventControlManager_2200 end";
382 }
383
384 /**
385 * @tc.name: CommonEventControlManager_2300
386 * @tc.desc: test GetOrderedEventRecords function.
387 * @tc.type: FUNC
388 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2300,Level1)389 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2300, Level1)
390 {
391 GTEST_LOG_(INFO) << "CommonEventControlManager_2300 start";
392 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
393 std::make_shared<CommonEventControlManager>();
394 ASSERT_NE(nullptr, commonEventControlManager);
395 std::string event = "aa";
396 int32_t userId = ALL_USER + 1;
397 std::vector<std::shared_ptr<OrderedEventRecord>> records;
398 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
399 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
400 record->commonEventData = commonEventData;
401 record->userId = ALL_USER + 1;
402 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
403 commonEventControlManager->GetOrderedEventRecords(event, userId, records);
404 GTEST_LOG_(INFO) << "CommonEventControlManager_2300 end";
405 }
406
407 /**
408 * @tc.name: CommonEventControlManager_2400
409 * @tc.desc: test GetOrderedEventRecords function.
410 * @tc.type: FUNC
411 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2400,Level1)412 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2400, Level1)
413 {
414 GTEST_LOG_(INFO) << "CommonEventControlManager_2400 start";
415 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
416 std::make_shared<CommonEventControlManager>();
417 ASSERT_NE(nullptr, commonEventControlManager);
418 std::string event = "aa";
419 int32_t userId = ALL_USER + 1;
420 std::vector<std::shared_ptr<OrderedEventRecord>> records;
421 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
422 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
423 record->commonEventData = commonEventData;
424 record->userId = ALL_USER + 2;
425 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
426 commonEventControlManager->GetOrderedEventRecords(event, userId, records);
427 GTEST_LOG_(INFO) << "CommonEventControlManager_2400 end";
428 }
429
430 }
431 }
432