1 /*
2  * Copyright (c) 2021-2022 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 
18 #define private public
19 #define protected public
20 #include "common_event_control_manager.h"
21 #include "common_event_subscriber_manager.h"
22 #undef private
23 #undef protected
24 #include "common_event_listener.h"
25 #include "common_event_subscriber.h"
26 #include "event_report.h"
27 
28 using namespace testing::ext;
29 using namespace OHOS;
30 using namespace OHOS::EventFwk;
31 namespace {
32 const std::string EVENT = "com.ces.test.event";
33 const static uid_t TEST_UID = 10101;
34 
35 class SubscriberTest : public CommonEventSubscriber {
36 public:
SubscriberTest(const CommonEventSubscribeInfo & sp)37     explicit SubscriberTest(const CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp) {}
38 
~SubscriberTest()39     virtual ~SubscriberTest() {}
40 
OnReceiveEvent(const CommonEventData & data)41     void OnReceiveEvent(const CommonEventData &data) override {}
42 };
43 
44 class CommonEventFreezeUnitTest : public testing::Test {
45 public:
CommonEventFreezeUnitTest()46     CommonEventFreezeUnitTest() {}
47 
~CommonEventFreezeUnitTest()48     virtual ~CommonEventFreezeUnitTest() {}
49 
50     static void SetUpTestCase();
51 
52     static void TearDownTestCase();
53 
54     void SetUp();
55 
56     void TearDown();
57 protected:
58     MatchingSkills matchingSkills_;
59     EventRecordInfo eventRecordInfo_;
60 };
61 
SetUpTestCase()62 void CommonEventFreezeUnitTest::SetUpTestCase() {}
63 
TearDownTestCase()64 void CommonEventFreezeUnitTest::TearDownTestCase() {}
65 
SetUp()66 void CommonEventFreezeUnitTest::SetUp()
67 {
68     matchingSkills_.AddEvent(EVENT);
69     eventRecordInfo_.pid = 0;
70     eventRecordInfo_.uid = TEST_UID;
71     eventRecordInfo_.bundleName = "bundleName";
72 }
73 
TearDown()74 void CommonEventFreezeUnitTest::TearDown() {}
75 
76 /*
77  * @tc.number: CommonEventFreezeUnitTest_0100
78  * @tc.name: test CommonEventSubscriberManager UpdateFreezeInfo set freeze state to true.
79  */
80 HWTEST_F(CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0100,
81     Function | MediumTest | Level1)
82 {
83     GTEST_LOG_(INFO)
84         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0100, TestSize.Level1";
85 
86     // make subscribeInfoPtr
87     std::shared_ptr<CommonEventSubscribeInfo> subscribeInfoPtr =
88         std::make_shared<CommonEventSubscribeInfo>(matchingSkills_);
89     // make subscriber
90     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(*subscribeInfoPtr);
91     // make commonEventListener
92     OHOS::sptr<CommonEventListener> commonEventListener = new CommonEventListener(subscriber);
93     struct tm curTime {0};
94     // insert subscriber
95     CommonEventSubscriberManager commonEventSubscriberManager;
96     auto result = commonEventSubscriberManager.InsertSubscriber(
97         subscribeInfoPtr, commonEventListener, curTime, eventRecordInfo_);
98     EXPECT_NE(nullptr, result);
99     // update freeze info
100     commonEventSubscriberManager.UpdateFreezeInfo(TEST_UID, true);
101     size_t expectSize = 1;
102     ASSERT_EQ(expectSize, commonEventSubscriberManager.subscribers_.size());
103     // get freeze records info
104     EXPECT_EQ(true, commonEventSubscriberManager.subscribers_[0]->isFreeze);
105     GTEST_LOG_(INFO)
106         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0100, TestSize.Level1 end";
107 }
108 
109 /*
110  * @tc.number: CommonEventFreezeUnitTest_0200
111  * @tc.name: test CommonEventSubscriberManager UpdateFreezeInfo set freeze state to false.
112  */
113 HWTEST_F(CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0200,
114     Function | MediumTest | Level1)
115 {
116     GTEST_LOG_(INFO)
117         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0200, TestSize.Level1";
118     // make subscribeInfoPtr
119     std::shared_ptr<CommonEventSubscribeInfo> subscribeInfoPtr =
120         std::make_shared<CommonEventSubscribeInfo>(matchingSkills_);
121     // make subscriber
122     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(*subscribeInfoPtr);
123     // make common event listener
124     OHOS::sptr<CommonEventListener> commonEventListener = new CommonEventListener(subscriber);
125     struct tm curTime {0};
126     // InsertSubscriber
127     CommonEventSubscriberManager commonEventSubscriberManager;
128     auto result = commonEventSubscriberManager.InsertSubscriber(
129         subscribeInfoPtr, commonEventListener, curTime, eventRecordInfo_);
130     EXPECT_NE(nullptr, result);
131     // update freeze info
132     commonEventSubscriberManager.UpdateFreezeInfo(TEST_UID, false);
133     size_t expectSize = 1;
134     ASSERT_EQ(expectSize, commonEventSubscriberManager.subscribers_.size());
135     // get freeze records info
136     EXPECT_EQ(false, commonEventSubscriberManager.subscribers_[0]->isFreeze);
137     GTEST_LOG_(INFO)
138         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0200, TestSize.Level1 end";
139 }
140 
141 /*
142  * @tc.number: CommonEventFreezeUnitTest_0300
143  * @tc.name: test CommonEventSubscriberManager insert frozen event record.
144  */
145 HWTEST_F(CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0300,
146     Function | MediumTest | Level1)
147 {
148     GTEST_LOG_(INFO)
149         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0300, TestSize.Level1";
150     // make subscriber info
151     std::shared_ptr<CommonEventSubscribeInfo> subscribeInfoPtr =
152         std::make_shared<CommonEventSubscribeInfo>(matchingSkills_);
153     // make subscriber
154     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(*subscribeInfoPtr);
155     // make common event listener
156     OHOS::sptr<CommonEventListener> commonEventListener = new CommonEventListener(subscriber);
157     struct tm curTime {0};
158     // InsertSubscriber
159     CommonEventSubscriberManager commonEventSubscriberManager;
160     auto result = commonEventSubscriberManager.InsertSubscriber(
161         subscribeInfoPtr, commonEventListener, curTime, eventRecordInfo_);
162     EXPECT_NE(nullptr, result);
163     // clear frozen events
164     std::map<uid_t, FrozenRecords> allFrozenRecords = commonEventSubscriberManager.GetAllFrozenEvents();
165     size_t expectSize = 0;
166     EXPECT_EQ(expectSize, allFrozenRecords.size());
167     // make SubscriberRecordPtr
168     SubscriberRecordPtr eventSubscriberRecord = std::make_shared<EventSubscriberRecord>();
169     eventSubscriberRecord->eventSubscribeInfo = subscribeInfoPtr;
170     eventSubscriberRecord->commonEventListener = commonEventListener;
171     eventSubscriberRecord->eventRecordInfo = eventRecordInfo_;
172     eventSubscriberRecord->isFreeze = true;
173     // make commonEventData
174     std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
175     // make commonEventPublishInfo
176     std::shared_ptr<CommonEventPublishInfo> publishInfo = std::make_shared<CommonEventPublishInfo>();
177     // make commonEventRecord
178     CommonEventRecord commonEventRecord;
179     commonEventRecord.commonEventData = commonEventData;
180     commonEventRecord.publishInfo = publishInfo;
181     commonEventRecord.eventRecordInfo = eventRecordInfo_;
182     // insert frozen events
183     commonEventSubscriberManager.InsertFrozenEvents(eventSubscriberRecord, commonEventRecord);
184     std::map<uid_t, FrozenRecords> allFrozenRecords1 = commonEventSubscriberManager.GetAllFrozenEvents();
185     expectSize = 1;
186     EXPECT_EQ(expectSize, allFrozenRecords1.size());
187     GTEST_LOG_(INFO)
188         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0300, TestSize.Level1 end";
189 }
190 
191 /*
192  * @tc.number: CommonEventFreezeUnitTest_0400
193  * @tc.name: test CommonEventSubscriberManager insert frozen event record.
194  */
195 HWTEST_F(CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0400,
196     Function | MediumTest | Level1)
197 {
198     GTEST_LOG_(INFO)
199         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0400, TestSize.Level1";
200     // make subscriber info
201     std::shared_ptr<CommonEventSubscribeInfo> subscribeInfoPtr =
202         std::make_shared<CommonEventSubscribeInfo>(matchingSkills_);
203     // make subscriber
204     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(*subscribeInfoPtr);
205     // make common event listener
206     OHOS::sptr<CommonEventListener> commonEventListener = new CommonEventListener(subscriber);
207     struct tm curTime {0};
208     // InsertSubscriber
209     CommonEventSubscriberManager commonEventSubscriberManager;
210     auto result = commonEventSubscriberManager.InsertSubscriber(
211         subscribeInfoPtr, commonEventListener, curTime, eventRecordInfo_);
212     EXPECT_NE(nullptr, result);
213     // clear frozen events
214     std::map<uid_t, FrozenRecords> allFrozenRecords = commonEventSubscriberManager.GetAllFrozenEvents();
215     size_t expectSize = 0;
216     EXPECT_EQ(expectSize, allFrozenRecords.size());
217     // make SubscriberRecordPtr
218     SubscriberRecordPtr eventSubscriberRecord = std::make_shared<EventSubscriberRecord>();
219     eventSubscriberRecord->eventSubscribeInfo = subscribeInfoPtr;
220     eventSubscriberRecord->commonEventListener = commonEventListener;
221     eventSubscriberRecord->eventRecordInfo = eventRecordInfo_;
222     eventSubscriberRecord->isFreeze = true;
223     // make commonEventData
224     std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
225     // make commonEventPublishInfo
226     std::shared_ptr<CommonEventPublishInfo> publishInfo = std::make_shared<CommonEventPublishInfo>();
227     // make commonEventRecord
228     CommonEventRecord commonEventRecord;
229     commonEventRecord.commonEventData = commonEventData;
230     commonEventRecord.publishInfo = publishInfo;
231     commonEventRecord.eventRecordInfo = eventRecordInfo_;
232     // insert frozen events
233     commonEventSubscriberManager.InsertFrozenEvents(eventSubscriberRecord, commonEventRecord);
234     commonEventSubscriberManager.InsertFrozenEvents(eventSubscriberRecord, commonEventRecord);
235     std::map<uid_t, FrozenRecords> allFrozenRecords1 = commonEventSubscriberManager.GetAllFrozenEvents();
236     expectSize = 1;
237     EXPECT_EQ(expectSize, allFrozenRecords1.size());
238     GTEST_LOG_(INFO)
239         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0400, TestSize.Level1 end";
240 }
241 
242 /*
243  * @tc.number: CommonEventFreezeUnitTest_0500
244  * @tc.name: test CommonEventControlManager NotifyUnorderedEvent with frozen subscriber.
245  */
246 HWTEST_F(CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0500,
247     Function | MediumTest | Level1)
248 {
249     GTEST_LOG_(INFO)
250         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0500, TestSize.Level1";
251     // make subscriber info
252     std::shared_ptr<CommonEventSubscribeInfo> subscribeInfoPtr =
253         std::make_shared<CommonEventSubscribeInfo>(matchingSkills_);
254     // make subscriber
255     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(*subscribeInfoPtr);
256     // make common event listener
257     OHOS::sptr<CommonEventListener> commonEventListener = new CommonEventListener(subscriber);
258     // make eventSubscriberRecord
259     SubscriberRecordPtr eventSubscriberRecord = std::make_shared<EventSubscriberRecord>();
260     eventSubscriberRecord->eventSubscribeInfo = subscribeInfoPtr;
261     eventSubscriberRecord->commonEventListener = commonEventListener;
262     eventSubscriberRecord->eventRecordInfo = eventRecordInfo_;
263     eventSubscriberRecord->isFreeze = true;
264     // make commonEventData
265     std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
266     // make publishInfo
267     std::shared_ptr<CommonEventPublishInfo> publishInfo = std::make_shared<CommonEventPublishInfo>();
268     // make eventRecord
269     std::shared_ptr<OrderedEventRecord> eventRecord = std::make_shared<OrderedEventRecord>();
270     eventRecord->commonEventData = commonEventData;
271     eventRecord->publishInfo = publishInfo;
272     eventRecord->resultTo = nullptr;
273     eventRecord->state = OrderedEventRecord::IDLE;
274     eventRecord->nextReceiver = 0;
275     eventRecord->receivers.emplace_back(eventSubscriberRecord);
276     eventRecord->deliveryState.emplace_back(OrderedEventRecord::PENDING);
277     // NotifyUnorderedEvent
278     CommonEventControlManager controlManager;
279     controlManager.NotifyUnorderedEvent(eventRecord);
280     EXPECT_EQ(OrderedEventRecord::DeliveryState::SKIPPED, eventRecord->deliveryState[0]);
281     GTEST_LOG_(INFO)
282         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0500, TestSize.Level1 end";
283 }
284 
285 /*
286  * @tc.number: CommonEventFreezeUnitTest_0600
287  * @tc.name: test CommonEventControlManager NotifyUnorderedEvent without frozen subscriber.
288  */
289 HWTEST_F(CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0600,
290     Function | MediumTest | Level1)
291 {
292     GTEST_LOG_(INFO)
293         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0600, TestSize.Level1";
294     // make subscribeInfoPtr
295     std::shared_ptr<CommonEventSubscribeInfo> subscribeInfoPtr =
296         std::make_shared<CommonEventSubscribeInfo>(matchingSkills_);
297     // make subscriber
298     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(*subscribeInfoPtr);
299     // make commonEventListener
300     OHOS::sptr<CommonEventListener> commonEventListener = new CommonEventListener(subscriber);
301     // make eventSubscriberRecord
302     SubscriberRecordPtr eventSubscriberRecord = std::make_shared<EventSubscriberRecord>();
303     eventSubscriberRecord->eventSubscribeInfo = subscribeInfoPtr;
304     eventSubscriberRecord->commonEventListener = commonEventListener;
305     eventSubscriberRecord->eventRecordInfo = eventRecordInfo_;
306     eventSubscriberRecord->isFreeze = false;
307     // make commonEventData
308     std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
309     // make publishInfo
310     std::shared_ptr<CommonEventPublishInfo> publishInfo = std::make_shared<CommonEventPublishInfo>();
311     // make eventRecord
312     std::shared_ptr<OrderedEventRecord> eventRecord = std::make_shared<OrderedEventRecord>();
313     eventRecord->commonEventData = commonEventData;
314     eventRecord->publishInfo = publishInfo;
315     eventRecord->resultTo = nullptr;
316     eventRecord->state = OrderedEventRecord::IDLE;
317     eventRecord->nextReceiver = 0;
318     eventRecord->receivers.emplace_back(eventSubscriberRecord);
319     eventRecord->deliveryState.emplace_back(OrderedEventRecord::PENDING);
320     // NotifyUnorderedEvent
321     CommonEventControlManager controlManager;
322     controlManager.NotifyUnorderedEvent(eventRecord);
323     EXPECT_NE(OrderedEventRecord::DeliveryState::SKIPPED, eventRecord->deliveryState[0]);
324     GTEST_LOG_(INFO)
325         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0600, TestSize.Level1 end";
326 }
327 
328 /*
329  * @tc.number: CommonEventFreezeUnitTest_0700
330  * @tc.name: test CommonEventControlManager NotifyOrderedEvent with frozen subscriber.
331  */
332 HWTEST_F(CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0700,
333     Function | MediumTest | Level1)
334 {
335     GTEST_LOG_(INFO)
336         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0700, TestSize.Level1";
337     // make subscribeInfoPtr
338     std::shared_ptr<CommonEventSubscribeInfo> subscribeInfoPtr =
339         std::make_shared<CommonEventSubscribeInfo>(matchingSkills_);
340     // make subscriber
341     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(*subscribeInfoPtr);
342     // make commonEventListener
343     OHOS::sptr<CommonEventListener> commonEventListener = new CommonEventListener(subscriber);
344     // make eventSubscriberRecord
345     SubscriberRecordPtr eventSubscriberRecord = std::make_shared<EventSubscriberRecord>();
346     eventSubscriberRecord->eventSubscribeInfo = subscribeInfoPtr;
347     eventSubscriberRecord->commonEventListener = commonEventListener;
348     eventSubscriberRecord->eventRecordInfo = eventRecordInfo_;
349     eventSubscriberRecord->isFreeze = true;
350     // make commonEventData
351     std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
352     // make publishInfo
353     std::shared_ptr<CommonEventPublishInfo> publishInfo = std::make_shared<CommonEventPublishInfo>();
354     // make eventRecord
355     std::shared_ptr<OrderedEventRecord> eventRecord = std::make_shared<OrderedEventRecord>();
356     eventRecord->commonEventData = commonEventData;
357     eventRecord->publishInfo = publishInfo;
358     eventRecord->resultTo = nullptr;
359     eventRecord->state = OrderedEventRecord::IDLE;
360     eventRecord->nextReceiver = 0;
361     eventRecord->receivers.emplace_back(eventSubscriberRecord);
362     eventRecord->deliveryState.emplace_back(OrderedEventRecord::PENDING);
363     // NotifyOrderedEvent
364     CommonEventControlManager controlManager;
365     controlManager.NotifyOrderedEvent(eventRecord, 0);
366     EXPECT_EQ(OrderedEventRecord::DeliveryState::SKIPPED, eventRecord->deliveryState[0]);
367     GTEST_LOG_(INFO)
368         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0700, TestSize.Level1 end";
369 }
370 
371 /*
372  * @tc.number: CommonEventFreezeUnitTest_0800
373  * @tc.name: test CommonEventControlManager NotifyOrderedEvent without frozen subscriber.
374  */
375 HWTEST_F(CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0800,
376     Function | MediumTest | Level1)
377 {
378     GTEST_LOG_(INFO)
379         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0800, TestSize.Level1";
380     // make subscribeInfoPtr
381     std::shared_ptr<CommonEventSubscribeInfo> subscribeInfoPtr =
382         std::make_shared<CommonEventSubscribeInfo>(matchingSkills_);
383     // make subscriber
384     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(*subscribeInfoPtr);
385     // make commonEventListener
386     OHOS::sptr<CommonEventListener> commonEventListener = new CommonEventListener(subscriber);
387     // make eventSubscriberRecord
388     SubscriberRecordPtr eventSubscriberRecord = std::make_shared<EventSubscriberRecord>();
389     eventSubscriberRecord->eventSubscribeInfo = subscribeInfoPtr;
390     eventSubscriberRecord->commonEventListener = commonEventListener;
391     eventSubscriberRecord->eventRecordInfo = eventRecordInfo_;
392     eventSubscriberRecord->isFreeze = false;
393     // make commonEventData
394     std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
395     // make publishInfo
396     std::shared_ptr<CommonEventPublishInfo> publishInfo = std::make_shared<CommonEventPublishInfo>();
397     // make eventRecord
398     std::shared_ptr<OrderedEventRecord> eventRecord = std::make_shared<OrderedEventRecord>();
399     eventRecord->commonEventData = commonEventData;
400     eventRecord->publishInfo = publishInfo;
401     eventRecord->resultTo = nullptr;
402     eventRecord->state = OrderedEventRecord::IDLE;
403     eventRecord->nextReceiver = 0;
404     eventRecord->receivers.emplace_back(eventSubscriberRecord);
405     eventRecord->deliveryState.emplace_back(OrderedEventRecord::PENDING);
406     // NotifyOrderedEvent
407     CommonEventControlManager controlManager;
408     controlManager.NotifyOrderedEvent(eventRecord, 0);
409     EXPECT_NE(OrderedEventRecord::DeliveryState::SKIPPED, eventRecord->deliveryState[0]);
410     GTEST_LOG_(INFO)
411         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0800, TestSize.Level1 end";
412 }
413 
414 /**
415  * @tc.name: CommonEventFreezeUnitTest_0900
416  * @tc.desc: UpdateAllFreezeInfos
417  * @tc.type: FUNC
418  * @tc.require: I5R11Y
419  */
420 HWTEST_F(CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_0900,
421     Function | MediumTest | Level1)
422 {
423     // make subscribeInfoPtr
424     std::shared_ptr<CommonEventSubscribeInfo> subscribeInfoPtr =
425         std::make_shared<CommonEventSubscribeInfo>(matchingSkills_);
426     // make subscriber
427     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(*subscribeInfoPtr);
428     // make commonEventListener
429     OHOS::sptr<CommonEventListener> commonEventListener = new CommonEventListener(subscriber);
430     struct tm curTime {0};
431     // insert subscriber
432     CommonEventSubscriberManager commonEventSubscriberManager;
433     auto result = commonEventSubscriberManager.InsertSubscriber(
434         subscribeInfoPtr, commonEventListener, curTime, eventRecordInfo_);
435     EXPECT_NE(result, nullptr);
436     // update freeze info
437     commonEventSubscriberManager.UpdateAllFreezeInfos(true);
438     size_t expectSize = 1;
439     ASSERT_EQ(commonEventSubscriberManager.subscribers_.size(), expectSize);
440     // get freeze records info
441     EXPECT_EQ(commonEventSubscriberManager.subscribers_[0]->isFreeze, true);
442 }
443 
444 /**
445  * @tc.name: CommonEventFreezeUnitTest_1000
446  * @tc.desc: UpdateAllFreezeInfos
447  * @tc.type: FUNC
448  * @tc.require: I5R11Y
449  */
450 HWTEST_F(CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_1000,
451     Function | MediumTest | Level1)
452 {
453     // make subscribeInfoPtr
454     std::shared_ptr<CommonEventSubscribeInfo> subscribeInfoPtr =
455         std::make_shared<CommonEventSubscribeInfo>(matchingSkills_);
456     // make subscriber
457     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(*subscribeInfoPtr);
458     // make common event listener
459     OHOS::sptr<CommonEventListener> commonEventListener = new CommonEventListener(subscriber);
460     struct tm curTime {0};
461     // InsertSubscriber
462     CommonEventSubscriberManager commonEventSubscriberManager;
463     auto result = commonEventSubscriberManager.InsertSubscriber(
464         subscribeInfoPtr, commonEventListener, curTime, eventRecordInfo_);
465     EXPECT_NE(result, nullptr);
466     // update freeze info
467     commonEventSubscriberManager.UpdateAllFreezeInfos(false);
468     size_t expectSize = 1;
469     ASSERT_EQ(commonEventSubscriberManager.subscribers_.size(), expectSize);
470     // get freeze records info
471     EXPECT_EQ(commonEventSubscriberManager.subscribers_[0]->isFreeze, false);
472 }
473 
474 /**
475  * @tc.name: CommonEventFreezeUnitTest_1001
476  * @tc.desc: InsertFrozenEvents
477  * @tc.type: FUNC
478  * @tc.require: I5R11Y
479  */
480 HWTEST_F(CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_1001,
481     Function | MediumTest | Level1)
482 {
483     GTEST_LOG_(INFO)
484         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_1001, TestSize.Level1";
485     // make subscriber info
486     std::shared_ptr<CommonEventSubscribeInfo> subscribeInfoPtr =
487         std::make_shared<CommonEventSubscribeInfo>(matchingSkills_);
488     // make subscriber
489     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(*subscribeInfoPtr);
490     // make common event listener
491     OHOS::sptr<CommonEventListener> commonEventListener = new CommonEventListener(subscriber);
492     struct tm curTime {0};
493     // InsertSubscriber
494     CommonEventSubscriberManager commonEventSubscriberManager;
495     auto result = commonEventSubscriberManager.InsertSubscriber(
496         subscribeInfoPtr, commonEventListener, curTime, eventRecordInfo_);
497     EXPECT_NE(result, nullptr);
498     // clear frozen events
499     std::map<uid_t, FrozenRecords> allFrozenRecords = commonEventSubscriberManager.GetAllFrozenEvents();
500     size_t expectSize = 0;
501     EXPECT_EQ(allFrozenRecords.size(), expectSize);
502     // make SubscriberRecordPtr
503     SubscriberRecordPtr eventSubscriberRecord = nullptr;
504     // make commonEventData
505     std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
506     // make commonEventPublishInfo
507     std::shared_ptr<CommonEventPublishInfo> publishInfo = std::make_shared<CommonEventPublishInfo>();
508     // make commonEventRecord
509     CommonEventRecord commonEventRecord;
510     commonEventRecord.commonEventData = commonEventData;
511     commonEventRecord.publishInfo = publishInfo;
512     commonEventRecord.eventRecordInfo = eventRecordInfo_;
513     // insert frozen events
514     commonEventSubscriberManager.InsertFrozenEvents(eventSubscriberRecord, commonEventRecord);
515     std::map<uid_t, FrozenRecords> allFrozenRecords1 = commonEventSubscriberManager.GetAllFrozenEvents();
516     expectSize = 0;
517     EXPECT_EQ(allFrozenRecords1.size(), expectSize);
518     GTEST_LOG_(INFO)
519         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_1001, TestSize.Level1 end";
520 }
521 
522 /**
523  * @tc.name: CommonEventFreezeUnitTest_1002
524  * @tc.desc: RemoveFrozenEventsBySubscriber
525  * @tc.type: FUNC
526  * @tc.require: I5R11Y
527  */
528 HWTEST_F(CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_1002,
529     Function | MediumTest | Level1)
530 {
531     GTEST_LOG_(INFO)
532         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_1002, TestSize.Level1";
533     // make subscriber info
534     std::shared_ptr<CommonEventSubscribeInfo> subscribeInfoPtr =
535         std::make_shared<CommonEventSubscribeInfo>(matchingSkills_);
536     // make subscriber
537     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(*subscribeInfoPtr);
538     // make common event listener
539     OHOS::sptr<CommonEventListener> commonEventListener = new CommonEventListener(subscriber);
540     struct tm curTime {0};
541     // InsertSubscriber
542     CommonEventSubscriberManager commonEventSubscriberManager;
543     auto result = commonEventSubscriberManager.InsertSubscriber(
544         subscribeInfoPtr, commonEventListener, curTime, eventRecordInfo_);
545     EXPECT_NE(result, nullptr);
546     // clear frozen events
547     std::map<uid_t, FrozenRecords> allFrozenRecords = commonEventSubscriberManager.GetAllFrozenEvents();
548     size_t expectSize = 0;
549     EXPECT_EQ(allFrozenRecords.size(), expectSize);
550     // make SubscriberRecordPtr
551     SubscriberRecordPtr eventSubscriberRecord = std::make_shared<EventSubscriberRecord>();
552     eventSubscriberRecord->eventSubscribeInfo = subscribeInfoPtr;
553     eventSubscriberRecord->commonEventListener = commonEventListener;
554     eventSubscriberRecord->eventRecordInfo = eventRecordInfo_;
555     eventSubscriberRecord->isFreeze = true;
556     // insert frozen events
557     commonEventSubscriberManager.RemoveFrozenEventsBySubscriber(eventSubscriberRecord);
558     std::map<uid_t, FrozenRecords> allFrozenRecords1 = commonEventSubscriberManager.GetAllFrozenEvents();
559     expectSize = 0;
560     EXPECT_EQ(allFrozenRecords1.size(), expectSize);
561     GTEST_LOG_(INFO)
562         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_1002, TestSize.Level1 end";
563 }
564 
565 /**
566  * @tc.name: CommonEventFreezeUnitTest_1003
567  * @tc.desc: SendSubscriberExceedMaximumHiSysEvent
568  * @tc.type: FUNC
569  * @tc.require: I5R11Y
570  */
571 HWTEST_F(CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_1003,
572     Function | MediumTest | Level1)
573 {
574     GTEST_LOG_(INFO)
575         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_1003, TestSize.Level1";
576     int32_t userId = 0;
577     std::string eventName = "EventName";
578     uint32_t subscriberNum = 0;
579     CommonEventSubscriberManager commonEventSubscriberManager;
580     commonEventSubscriberManager.SendSubscriberExceedMaximumHiSysEvent(userId, eventName, subscriberNum);
581     size_t expectSize = 0;
582     ASSERT_EQ(commonEventSubscriberManager.subscribers_.size(), expectSize);
583     GTEST_LOG_(INFO)
584         << "CommonEventFreezeUnitTest, CommonEventFreezeUnitTest_1003, TestSize.Level1 end";
585 }
586 }  // namespace
587