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