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 extern void MockIsVerfyPermisson(bool isVerify);
27 extern void MockGetEventPermission(bool mockRet);
28
29 class CommonEventControlManagerTest : public testing::Test {
30 public:
CommonEventControlManagerTest()31 CommonEventControlManagerTest()
32 {}
~CommonEventControlManagerTest()33 ~CommonEventControlManagerTest()
34 {}
35
36 static void SetUpTestCase(void);
37 static void TearDownTestCase(void);
38 void SetUp();
39 void TearDown();
40 };
41
SetUpTestCase(void)42 void CommonEventControlManagerTest::SetUpTestCase(void)
43 {}
44
TearDownTestCase(void)45 void CommonEventControlManagerTest::TearDownTestCase(void)
46 {}
47
SetUp(void)48 void CommonEventControlManagerTest::SetUp(void)
49 {}
50
TearDown(void)51 void CommonEventControlManagerTest::TearDown(void)
52 {}
53
54 /**
55 * @tc.name: CommonEventControlManager_0100
56 * @tc.desc: test PublishStickyCommonEvent function and subscriberRecord is nullptr.
57 * @tc.type: FUNC
58 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0100,Level1)59 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0100, Level1)
60 {
61 GTEST_LOG_(INFO) << "CommonEventControlManager_0100 start";
62 CommonEventControlManager commonEventControlManager;
63 CommonEventRecord eventRecord;
64 std::shared_ptr<EventSubscriberRecord> subscriberRecord = nullptr;
65 bool sticky = commonEventControlManager.PublishStickyCommonEvent(eventRecord, subscriberRecord);
66 EXPECT_EQ(false, sticky);
67 GTEST_LOG_(INFO) << "CommonEventControlManager_0100 end";
68 }
69
70 /**
71 * @tc.name: CommonEventControlManager_0200
72 * @tc.desc: test NotifyUnorderedEvent function and eventRecord is nullptr.
73 * @tc.type: FUNC
74 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0200,Level1)75 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0200, Level1)
76 {
77 GTEST_LOG_(INFO) << "CommonEventControlManager_0200 start";
78 CommonEventControlManager commonEventControlManager;
79 std::shared_ptr<OrderedEventRecord> eventRecord = nullptr;
80 bool sticky = commonEventControlManager.NotifyUnorderedEvent(eventRecord);
81 EXPECT_EQ(false, sticky);
82 GTEST_LOG_(INFO) << "CommonEventControlManager_0200 end";
83 }
84
85 /**
86 * @tc.name: CommonEventControlManager_0300
87 * @tc.desc: test EnqueueUnorderedRecord function and eventRecordPtr is nullptr.
88 * @tc.type: FUNC
89 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0300,Level1)90 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0300, Level1)
91 {
92 GTEST_LOG_(INFO) << "CommonEventControlManager_0300 start";
93 CommonEventControlManager commonEventControlManager;
94 std::shared_ptr<OrderedEventRecord> eventRecordPtr = nullptr;
95 bool sticky = commonEventControlManager.EnqueueUnorderedRecord(eventRecordPtr);
96 EXPECT_EQ(false, sticky);
97 GTEST_LOG_(INFO) << "CommonEventControlManager_0300 end";
98 }
99
100 /**
101 * @tc.name: CommonEventControlManager_0400
102 * @tc.desc: test EnqueueHistoryEventRecord function and eventRecordPtr is nullptr.
103 * @tc.type: FUNC
104 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0400,Level1)105 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0400, Level1)
106 {
107 GTEST_LOG_(INFO) << "CommonEventControlManager_0400 start";
108 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
109 std::make_shared<CommonEventControlManager>();
110 ASSERT_NE(nullptr, commonEventControlManager);
111 std::shared_ptr<OrderedEventRecord> eventRecordPtr = nullptr;
112 bool hasLastSubscribe = true;
113 commonEventControlManager->EnqueueHistoryEventRecord(eventRecordPtr, hasLastSubscribe);
114 GTEST_LOG_(INFO) << "CommonEventControlManager_0400 end";
115 }
116
117 /**
118 * @tc.name: CommonEventControlManager_0500
119 * @tc.desc: test NotifyOrderedEvent function and eventRecordPtr is nullptr.
120 * @tc.type: FUNC
121 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0500,Level1)122 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0500, Level1)
123 {
124 GTEST_LOG_(INFO) << "CommonEventControlManager_0500 start";
125 CommonEventControlManager commonEventControlManager;
126 std::shared_ptr<OrderedEventRecord> eventRecordPtr = nullptr;
127 size_t index = 1;
128 EXPECT_EQ(false, commonEventControlManager.NotifyOrderedEvent(eventRecordPtr, index));
129 GTEST_LOG_(INFO) << "CommonEventControlManager_0500 end";
130 }
131
132 /**
133 * @tc.name: CommonEventControlManager_0600
134 * @tc.desc: test NotifyOrderedEvent function.
135 * @tc.type: FUNC
136 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0600,Level1)137 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0600, Level1)
138 {
139 GTEST_LOG_(INFO) << "CommonEventControlManager_0600 start";
140 CommonEventControlManager commonEventControlManager;
141 std::shared_ptr<OrderedEventRecord> eventRecordPtr = std::make_shared<OrderedEventRecord>();
142 size_t index = -1;
143 EXPECT_EQ(false, commonEventControlManager.NotifyOrderedEvent(eventRecordPtr, index));
144 GTEST_LOG_(INFO) << "CommonEventControlManager_0600 end";
145 }
146
147 /**
148 * @tc.name: CommonEventControlManager_0700
149 * @tc.desc: test NotifyOrderedEvent function.
150 * @tc.type: FUNC
151 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0700,Level1)152 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0700, Level1)
153 {
154 GTEST_LOG_(INFO) << "CommonEventControlManager_0700 start";
155 CommonEventControlManager commonEventControlManager;
156 std::shared_ptr<OrderedEventRecord> eventRecordPtr = std::make_shared<OrderedEventRecord>();
157 size_t index = 0;
158 EXPECT_EQ(false, commonEventControlManager.NotifyOrderedEvent(eventRecordPtr, index));
159 GTEST_LOG_(INFO) << "CommonEventControlManager_0700 end";
160 }
161
162 /**
163 * @tc.name: CommonEventControlManager_0800
164 * @tc.desc: test SetTimeout function.
165 * @tc.type: FUNC
166 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0800,Level1)167 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0800, Level1)
168 {
169 GTEST_LOG_(INFO) << "CommonEventControlManager_0800 start";
170 CommonEventControlManager commonEventControlManager;
171 commonEventControlManager.pendingTimeoutMessage_ = true;
172 EXPECT_EQ(true, commonEventControlManager.SetTimeout());
173 GTEST_LOG_(INFO) << "CommonEventControlManager_0800 end";
174 }
175
176 /**
177 * @tc.name: CommonEventControlManager_0900
178 * @tc.desc: test FinishReceiverAction function and recordPtr is nullptr.
179 * @tc.type: FUNC
180 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0900,Level1)181 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0900, Level1)
182 {
183 GTEST_LOG_(INFO) << "CommonEventControlManager_0900 start";
184 CommonEventControlManager commonEventControlManager;
185 std::shared_ptr<OrderedEventRecord> recordPtr = nullptr;
186 int32_t code = 1;
187 std::string receiverData = "aa";
188 bool abortEvent = false;
189 EXPECT_EQ(false, commonEventControlManager.FinishReceiverAction(recordPtr, code, receiverData, abortEvent));
190 GTEST_LOG_(INFO) << "CommonEventControlManager_0900 end";
191 }
192
193 /**
194 * @tc.name: CommonEventControlManager_1000
195 * @tc.desc: test CheckSubscriberPermission function.
196 * @tc.type: FUNC
197 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1000,Level1)198 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1000, Level1)
199 {
200 GTEST_LOG_(INFO) << "CommonEventControlManager_1000 start";
201 CommonEventControlManager commonEventControlManager;
202 EventSubscriberRecord subscriberRecord;
203 subscriberRecord.eventRecordInfo.isProxy = false;
204 subscriberRecord.eventRecordInfo.isSubsystem = true;
205 subscriberRecord.eventRecordInfo.isSystemApp = true;
206 CommonEventRecord eventRecord;
207 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
208 eventRecord.commonEventData = commonEventData;
209 MockGetEventPermission(true);
210 EXPECT_EQ(true, commonEventControlManager.CheckSubscriberPermission(subscriberRecord, eventRecord));
211 GTEST_LOG_(INFO) << "CommonEventControlManager_1000 end";
212 }
213
214 /**
215 * @tc.name: CommonEventControlManager_1100
216 * @tc.desc: test CheckSubscriberPermission function.
217 * @tc.type: FUNC
218 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1100,Level1)219 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1100, Level1)
220 {
221 GTEST_LOG_(INFO) << "CommonEventControlManager_1100 start";
222 CommonEventControlManager commonEventControlManager;
223 EventSubscriberRecord subscriberRecord;
224 subscriberRecord.eventRecordInfo.isProxy = true;
225 subscriberRecord.eventRecordInfo.isSubsystem = false;
226 subscriberRecord.eventRecordInfo.isSystemApp = false;
227 CommonEventRecord eventRecord;
228 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
229 eventRecord.commonEventData = commonEventData;
230 MockGetEventPermission(true);
231 MockIsVerfyPermisson(true);
232 EXPECT_EQ(true, commonEventControlManager.CheckSubscriberPermission(subscriberRecord, eventRecord));
233 GTEST_LOG_(INFO) << "CommonEventControlManager_1100 end";
234 }
235
236 /**
237 * @tc.name: CommonEventControlManager_1200
238 * @tc.desc: test CheckSubscriberPermission function.
239 * @tc.type: FUNC
240 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1200,Level1)241 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1200, Level1)
242 {
243 GTEST_LOG_(INFO) << "CommonEventControlManager_1200 start";
244 CommonEventControlManager commonEventControlManager;
245 EventSubscriberRecord subscriberRecord;
246 subscriberRecord.eventRecordInfo.isProxy = true;
247 subscriberRecord.eventRecordInfo.isSubsystem = false;
248 subscriberRecord.eventRecordInfo.isSystemApp = false;
249 CommonEventRecord eventRecord;
250 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
251 OHOS::AAFwk::Want want;
252 want.SetAction("usual.event.BOOT_COMPLETED");
253 commonEventData->SetWant(want);
254 eventRecord.commonEventData = commonEventData;
255 MockGetEventPermission(true);
256 MockIsVerfyPermisson(false);
257 EXPECT_EQ(false, commonEventControlManager.CheckSubscriberPermission(subscriberRecord, eventRecord));
258 GTEST_LOG_(INFO) << "CommonEventControlManager_1200 end";
259 }
260
261 /**
262 * @tc.name: CommonEventControlManager_1300
263 * @tc.desc: test GetUnorderedEventRecords function.
264 * @tc.type: FUNC
265 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1300,Level1)266 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1300, Level1)
267 {
268 GTEST_LOG_(INFO) << "CommonEventControlManager_1300 start";
269 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
270 std::make_shared<CommonEventControlManager>();
271 ASSERT_NE(nullptr, commonEventControlManager);
272 std::string event = "";
273 int32_t userId = ALL_USER;
274 std::vector<std::shared_ptr<OrderedEventRecord>> records;
275 commonEventControlManager->GetUnorderedEventRecords(event, userId, records);
276 GTEST_LOG_(INFO) << "CommonEventControlManager_1300 end";
277 }
278
279 /**
280 * @tc.name: CommonEventControlManager_1400
281 * @tc.desc: test GetUnorderedEventRecords function.
282 * @tc.type: FUNC
283 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1400,Level1)284 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1400, Level1)
285 {
286 GTEST_LOG_(INFO) << "CommonEventControlManager_1400 start";
287 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
288 std::make_shared<CommonEventControlManager>();
289 ASSERT_NE(nullptr, commonEventControlManager);
290 std::string event = "";
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 record->userId = ALL_USER + 1;
295 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
296 commonEventControlManager->GetUnorderedEventRecords(event, userId, records);
297 GTEST_LOG_(INFO) << "CommonEventControlManager_1400 end";
298 }
299
300 /**
301 * @tc.name: CommonEventControlManager_1500
302 * @tc.desc: test GetUnorderedEventRecords function.
303 * @tc.type: FUNC
304 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1500,Level1)305 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1500, Level1)
306 {
307 GTEST_LOG_(INFO) << "CommonEventControlManager_1500 start";
308 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
309 std::make_shared<CommonEventControlManager>();
310 ASSERT_NE(nullptr, commonEventControlManager);
311 std::string event = "";
312 int32_t userId = ALL_USER + 1;
313 std::vector<std::shared_ptr<OrderedEventRecord>> records;
314 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
315 record->userId = ALL_USER + 2;
316 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
317 commonEventControlManager->GetUnorderedEventRecords(event, userId, records);
318 GTEST_LOG_(INFO) << "CommonEventControlManager_1500 end";
319 }
320
321 /**
322 * @tc.name: CommonEventControlManager_1600
323 * @tc.desc: test GetUnorderedEventRecords function.
324 * @tc.type: FUNC
325 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1600,Level1)326 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1600, Level1)
327 {
328 GTEST_LOG_(INFO) << "CommonEventControlManager_1600 start";
329 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
330 std::make_shared<CommonEventControlManager>();
331 ASSERT_NE(nullptr, commonEventControlManager);
332 std::string event = "aa";
333 int32_t userId = ALL_USER;
334 std::vector<std::shared_ptr<OrderedEventRecord>> records;
335 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
336 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
337 record->commonEventData = commonEventData;
338 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
339 commonEventControlManager->GetUnorderedEventRecords(event, userId, records);
340 GTEST_LOG_(INFO) << "CommonEventControlManager_1600 end";
341 }
342
343 /**
344 * @tc.name: CommonEventControlManager_1700
345 * @tc.desc: test GetUnorderedEventRecords function.
346 * @tc.type: FUNC
347 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1700,Level1)348 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1700, Level1)
349 {
350 GTEST_LOG_(INFO) << "CommonEventControlManager_1700 start";
351 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
352 std::make_shared<CommonEventControlManager>();
353 ASSERT_NE(nullptr, commonEventControlManager);
354 std::string event = "aa";
355 int32_t userId = ALL_USER + 1;
356 std::vector<std::shared_ptr<OrderedEventRecord>> records;
357 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
358 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
359 record->commonEventData = commonEventData;
360 record->userId = ALL_USER + 1;
361 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
362 commonEventControlManager->GetUnorderedEventRecords(event, userId, records);
363 GTEST_LOG_(INFO) << "CommonEventControlManager_1700 end";
364 }
365
366 /**
367 * @tc.name: CommonEventControlManager_1800
368 * @tc.desc: test GetUnorderedEventRecords function.
369 * @tc.type: FUNC
370 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1800,Level1)371 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1800, Level1)
372 {
373 GTEST_LOG_(INFO) << "CommonEventControlManager_1800 start";
374 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
375 std::make_shared<CommonEventControlManager>();
376 ASSERT_NE(nullptr, commonEventControlManager);
377 std::string event = "aa";
378 int32_t userId = ALL_USER + 1;
379 std::vector<std::shared_ptr<OrderedEventRecord>> records;
380 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
381 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
382 record->commonEventData = commonEventData;
383 record->userId = ALL_USER;
384 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
385 commonEventControlManager->GetUnorderedEventRecords(event, userId, records);
386 GTEST_LOG_(INFO) << "CommonEventControlManager_1800 end";
387 }
388
389 /**
390 * @tc.name: CommonEventControlManager_1900
391 * @tc.desc: test GetOrderedEventRecords function.
392 * @tc.type: FUNC
393 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1900,Level1)394 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1900, Level1)
395 {
396 GTEST_LOG_(INFO) << "CommonEventControlManager_1900 start";
397 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
398 std::make_shared<CommonEventControlManager>();
399 ASSERT_NE(nullptr, commonEventControlManager);
400 std::string event = "";
401 int32_t userId = ALL_USER;
402 std::vector<std::shared_ptr<OrderedEventRecord>> records;
403 commonEventControlManager->GetOrderedEventRecords(event, userId, records);
404 GTEST_LOG_(INFO) << "CommonEventControlManager_1900 end";
405 }
406
407 /**
408 * @tc.name: CommonEventControlManager_2000
409 * @tc.desc: test GetOrderedEventRecords function.
410 * @tc.type: FUNC
411 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2000,Level1)412 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2000, Level1)
413 {
414 GTEST_LOG_(INFO) << "CommonEventControlManager_2000 start";
415 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
416 std::make_shared<CommonEventControlManager>();
417 ASSERT_NE(nullptr, commonEventControlManager);
418 std::string event = "";
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 record->userId = ALL_USER + 1;
423 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
424 commonEventControlManager->GetOrderedEventRecords(event, userId, records);
425 GTEST_LOG_(INFO) << "CommonEventControlManager_2000 end";
426 }
427
428 /**
429 * @tc.name: CommonEventControlManager_2100
430 * @tc.desc: test GetOrderedEventRecords function.
431 * @tc.type: FUNC
432 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2100,Level1)433 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2100, Level1)
434 {
435 GTEST_LOG_(INFO) << "CommonEventControlManager_2100 start";
436 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
437 std::make_shared<CommonEventControlManager>();
438 ASSERT_NE(nullptr, commonEventControlManager);
439 std::string event = "";
440 int32_t userId = ALL_USER + 1;
441 std::vector<std::shared_ptr<OrderedEventRecord>> records;
442 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
443 record->userId = ALL_USER + 2;
444 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
445 commonEventControlManager->GetOrderedEventRecords(event, userId, records);
446 GTEST_LOG_(INFO) << "CommonEventControlManager_2100 end";
447 }
448
449 /**
450 * @tc.name: CommonEventControlManager_2200
451 * @tc.desc: test GetOrderedEventRecords function.
452 * @tc.type: FUNC
453 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2200,Level1)454 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2200, Level1)
455 {
456 GTEST_LOG_(INFO) << "CommonEventControlManager_2200 start";
457 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
458 std::make_shared<CommonEventControlManager>();
459 ASSERT_NE(nullptr, commonEventControlManager);
460 std::string event = "aa";
461 int32_t userId = ALL_USER;
462 std::vector<std::shared_ptr<OrderedEventRecord>> records;
463 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
464 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
465 record->commonEventData = commonEventData;
466 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
467 commonEventControlManager->GetOrderedEventRecords(event, userId, records);
468 GTEST_LOG_(INFO) << "CommonEventControlManager_2200 end";
469 }
470
471 /**
472 * @tc.name: CommonEventControlManager_2300
473 * @tc.desc: test GetOrderedEventRecords function.
474 * @tc.type: FUNC
475 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2300,Level1)476 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2300, Level1)
477 {
478 GTEST_LOG_(INFO) << "CommonEventControlManager_2300 start";
479 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
480 std::make_shared<CommonEventControlManager>();
481 ASSERT_NE(nullptr, commonEventControlManager);
482 std::string event = "aa";
483 int32_t userId = ALL_USER + 1;
484 std::vector<std::shared_ptr<OrderedEventRecord>> records;
485 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
486 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
487 record->commonEventData = commonEventData;
488 record->userId = ALL_USER + 1;
489 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
490 commonEventControlManager->GetOrderedEventRecords(event, userId, records);
491 GTEST_LOG_(INFO) << "CommonEventControlManager_2300 end";
492 }
493
494 /**
495 * @tc.name: CommonEventControlManager_2400
496 * @tc.desc: test GetOrderedEventRecords function.
497 * @tc.type: FUNC
498 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2400,Level1)499 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2400, Level1)
500 {
501 GTEST_LOG_(INFO) << "CommonEventControlManager_2400 start";
502 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
503 std::make_shared<CommonEventControlManager>();
504 ASSERT_NE(nullptr, commonEventControlManager);
505 std::string event = "aa";
506 int32_t userId = ALL_USER + 1;
507 std::vector<std::shared_ptr<OrderedEventRecord>> records;
508 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
509 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
510 record->commonEventData = commonEventData;
511 record->userId = ALL_USER + 2;
512 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
513 commonEventControlManager->GetOrderedEventRecords(event, userId, records);
514 GTEST_LOG_(INFO) << "CommonEventControlManager_2400 end";
515 }
516
517 /**
518 * @tc.name: CommonEventControlManager_2500
519 * @tc.desc: test GetHistoryEventRecords function.
520 * @tc.type: FUNC
521 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2500,Level1)522 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2500, Level1)
523 {
524 GTEST_LOG_(INFO) << "CommonEventControlManager_2500 start";
525 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
526 std::make_shared<CommonEventControlManager>();
527 ASSERT_NE(nullptr, commonEventControlManager);
528 std::string event = "";
529 int32_t userId = ALL_USER;
530 std::list<HistoryEventRecord> records;
531 commonEventControlManager->GetHistoryEventRecords(event, userId, records);
532 GTEST_LOG_(INFO) << "CommonEventControlManager_2500 end";
533 }
534
535 /**
536 * @tc.name: CommonEventControlManager_2600
537 * @tc.desc: test GetHistoryEventRecords function.
538 * @tc.type: FUNC
539 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2600,Level1)540 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2600, Level1)
541 {
542 GTEST_LOG_(INFO) << "CommonEventControlManager_2600 start";
543 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
544 std::make_shared<CommonEventControlManager>();
545 ASSERT_NE(nullptr, commonEventControlManager);
546 std::string event = "";
547 int32_t userId = ALL_USER - 1;
548 std::list<HistoryEventRecord> records;
549 HistoryEventRecord historyEventRecord;
550 historyEventRecord.userId = ALL_USER - 1;
551 commonEventControlManager->historyEventRecords_.emplace_back();
552 commonEventControlManager->GetHistoryEventRecords(event, userId, records);
553 GTEST_LOG_(INFO) << "CommonEventControlManager_2600 end";
554 }
555
556 /**
557 * @tc.name: CommonEventControlManager_2700
558 * @tc.desc: test GetHistoryEventRecords function.
559 * @tc.type: FUNC
560 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2700,Level1)561 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2700, Level1)
562 {
563 GTEST_LOG_(INFO) << "CommonEventControlManager_2700 start";
564 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
565 std::make_shared<CommonEventControlManager>();
566 ASSERT_NE(nullptr, commonEventControlManager);
567 std::string event = "";
568 int32_t userId = ALL_USER + 1;
569 std::list<HistoryEventRecord> records;
570 HistoryEventRecord historyEventRecord;
571 historyEventRecord.userId = ALL_USER + 2;
572 commonEventControlManager->historyEventRecords_.emplace_back();
573 commonEventControlManager->GetHistoryEventRecords(event, userId, records);
574 GTEST_LOG_(INFO) << "CommonEventControlManager_2700 end";
575 }
576
577 /**
578 * @tc.name: CommonEventControlManager_2800
579 * @tc.desc: test GetHistoryEventRecords function.
580 * @tc.type: FUNC
581 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2800,Level1)582 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2800, Level1)
583 {
584 GTEST_LOG_(INFO) << "CommonEventControlManager_2800 start";
585 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
586 std::make_shared<CommonEventControlManager>();
587 ASSERT_NE(nullptr, commonEventControlManager);
588 std::string event = "aa";
589 int32_t userId = ALL_USER + 1;
590 std::list<HistoryEventRecord> records;
591 HistoryEventRecord historyEventRecord;
592 historyEventRecord.userId = ALL_USER + 2;
593 commonEventControlManager->historyEventRecords_.emplace_back();
594 commonEventControlManager->GetHistoryEventRecords(event, userId, records);
595 GTEST_LOG_(INFO) << "CommonEventControlManager_2800 end";
596 }
597
598 /**
599 * @tc.name: CommonEventControlManager_2900
600 * @tc.desc: test GetHistoryEventRecords function.
601 * @tc.type: FUNC
602 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2900,Level1)603 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2900, Level1)
604 {
605 GTEST_LOG_(INFO) << "CommonEventControlManager_2900 start";
606 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
607 std::make_shared<CommonEventControlManager>();
608 ASSERT_NE(nullptr, commonEventControlManager);
609 std::string event = "aa";
610 int32_t userId = ALL_USER + 1;
611 std::list<HistoryEventRecord> records;
612 HistoryEventRecord historyEventRecord;
613 historyEventRecord.userId = ALL_USER + 1;
614 commonEventControlManager->historyEventRecords_.emplace_back();
615 commonEventControlManager->GetHistoryEventRecords(event, userId, records);
616 GTEST_LOG_(INFO) << "CommonEventControlManager_2900 end";
617 }
618
619 }
620 }
621