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