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_0500
102 * @tc.desc: test NotifyOrderedEvent function and eventRecordPtr is nullptr.
103 * @tc.type: FUNC
104 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0500,Level1)105 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0500, Level1)
106 {
107 GTEST_LOG_(INFO) << "CommonEventControlManager_0500 start";
108 CommonEventControlManager commonEventControlManager;
109 std::shared_ptr<OrderedEventRecord> eventRecordPtr = nullptr;
110 size_t index = 1;
111 EXPECT_EQ(false, commonEventControlManager.NotifyOrderedEvent(eventRecordPtr, index));
112 GTEST_LOG_(INFO) << "CommonEventControlManager_0500 end";
113 }
114
115 /**
116 * @tc.name: CommonEventControlManager_0600
117 * @tc.desc: test NotifyOrderedEvent function.
118 * @tc.type: FUNC
119 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0600,Level1)120 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0600, Level1)
121 {
122 GTEST_LOG_(INFO) << "CommonEventControlManager_0600 start";
123 CommonEventControlManager commonEventControlManager;
124 std::shared_ptr<OrderedEventRecord> eventRecordPtr = std::make_shared<OrderedEventRecord>();
125 size_t index = -1;
126 EXPECT_EQ(false, commonEventControlManager.NotifyOrderedEvent(eventRecordPtr, index));
127 GTEST_LOG_(INFO) << "CommonEventControlManager_0600 end";
128 }
129
130 /**
131 * @tc.name: CommonEventControlManager_0700
132 * @tc.desc: test NotifyOrderedEvent function.
133 * @tc.type: FUNC
134 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0700,Level1)135 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0700, Level1)
136 {
137 GTEST_LOG_(INFO) << "CommonEventControlManager_0700 start";
138 CommonEventControlManager commonEventControlManager;
139 std::shared_ptr<OrderedEventRecord> eventRecordPtr = std::make_shared<OrderedEventRecord>();
140 size_t index = 0;
141 EXPECT_EQ(false, commonEventControlManager.NotifyOrderedEvent(eventRecordPtr, index));
142 GTEST_LOG_(INFO) << "CommonEventControlManager_0700 end";
143 }
144
145 /**
146 * @tc.name: CommonEventControlManager_0800
147 * @tc.desc: test SetTimeout function.
148 * @tc.type: FUNC
149 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0800,Level1)150 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0800, Level1)
151 {
152 GTEST_LOG_(INFO) << "CommonEventControlManager_0800 start";
153 CommonEventControlManager commonEventControlManager;
154 commonEventControlManager.pendingTimeoutMessage_ = true;
155 EXPECT_EQ(true, commonEventControlManager.SetTimeout());
156 GTEST_LOG_(INFO) << "CommonEventControlManager_0800 end";
157 }
158
159 /**
160 * @tc.name: CommonEventControlManager_0900
161 * @tc.desc: test FinishReceiverAction function and recordPtr is nullptr.
162 * @tc.type: FUNC
163 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_0900,Level1)164 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_0900, Level1)
165 {
166 GTEST_LOG_(INFO) << "CommonEventControlManager_0900 start";
167 CommonEventControlManager commonEventControlManager;
168 std::shared_ptr<OrderedEventRecord> recordPtr = nullptr;
169 int32_t code = 1;
170 std::string receiverData = "aa";
171 bool abortEvent = false;
172 EXPECT_EQ(false, commonEventControlManager.FinishReceiverAction(recordPtr, code, receiverData, abortEvent));
173 GTEST_LOG_(INFO) << "CommonEventControlManager_0900 end";
174 }
175
176 /**
177 * @tc.name: CommonEventControlManager_1000
178 * @tc.desc: test CheckSubscriberPermission function.
179 * @tc.type: FUNC
180 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1000,Level1)181 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1000, Level1)
182 {
183 GTEST_LOG_(INFO) << "CommonEventControlManager_1000 start";
184 CommonEventControlManager commonEventControlManager;
185 EventSubscriberRecord subscriberRecord;
186 subscriberRecord.eventRecordInfo.isProxy = false;
187 subscriberRecord.eventRecordInfo.isSubsystem = true;
188 subscriberRecord.eventRecordInfo.isSystemApp = true;
189 CommonEventRecord eventRecord;
190 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
191 eventRecord.commonEventData = commonEventData;
192 MockGetEventPermission(true);
193 EXPECT_EQ(true, commonEventControlManager.CheckSubscriberPermission(subscriberRecord, eventRecord));
194 GTEST_LOG_(INFO) << "CommonEventControlManager_1000 end";
195 }
196
197 /**
198 * @tc.name: CommonEventControlManager_1100
199 * @tc.desc: test CheckSubscriberPermission function.
200 * @tc.type: FUNC
201 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1100,Level1)202 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1100, Level1)
203 {
204 GTEST_LOG_(INFO) << "CommonEventControlManager_1100 start";
205 CommonEventControlManager commonEventControlManager;
206 EventSubscriberRecord subscriberRecord;
207 subscriberRecord.eventRecordInfo.isProxy = true;
208 subscriberRecord.eventRecordInfo.isSubsystem = false;
209 subscriberRecord.eventRecordInfo.isSystemApp = false;
210 CommonEventRecord eventRecord;
211 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
212 eventRecord.commonEventData = commonEventData;
213 MockGetEventPermission(true);
214 MockIsVerfyPermisson(true);
215 EXPECT_EQ(true, commonEventControlManager.CheckSubscriberPermission(subscriberRecord, eventRecord));
216 GTEST_LOG_(INFO) << "CommonEventControlManager_1100 end";
217 }
218
219 /**
220 * @tc.name: CommonEventControlManager_1200
221 * @tc.desc: test CheckSubscriberPermission function.
222 * @tc.type: FUNC
223 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1200,Level1)224 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1200, Level1)
225 {
226 GTEST_LOG_(INFO) << "CommonEventControlManager_1200 start";
227 CommonEventControlManager commonEventControlManager;
228 EventSubscriberRecord subscriberRecord;
229 subscriberRecord.eventRecordInfo.isProxy = true;
230 subscriberRecord.eventRecordInfo.isSubsystem = false;
231 subscriberRecord.eventRecordInfo.isSystemApp = false;
232 CommonEventRecord eventRecord;
233 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
234 OHOS::AAFwk::Want want;
235 want.SetAction("usual.event.BOOT_COMPLETED");
236 commonEventData->SetWant(want);
237 eventRecord.commonEventData = commonEventData;
238 MockGetEventPermission(true);
239 MockIsVerfyPermisson(false);
240 EXPECT_EQ(false, commonEventControlManager.CheckSubscriberPermission(subscriberRecord, eventRecord));
241 GTEST_LOG_(INFO) << "CommonEventControlManager_1200 end";
242 }
243
244 /**
245 * @tc.name: CommonEventControlManager_1300
246 * @tc.desc: test GetUnorderedEventRecords function.
247 * @tc.type: FUNC
248 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1300,Level1)249 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1300, Level1)
250 {
251 GTEST_LOG_(INFO) << "CommonEventControlManager_1300 start";
252 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
253 std::make_shared<CommonEventControlManager>();
254 ASSERT_NE(nullptr, commonEventControlManager);
255 std::string event = "";
256 int32_t userId = ALL_USER;
257 std::vector<std::shared_ptr<OrderedEventRecord>> records;
258 commonEventControlManager->GetUnorderedEventRecords(event, userId, records);
259 GTEST_LOG_(INFO) << "CommonEventControlManager_1300 end";
260 }
261
262 /**
263 * @tc.name: CommonEventControlManager_1400
264 * @tc.desc: test GetUnorderedEventRecords function.
265 * @tc.type: FUNC
266 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1400,Level1)267 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1400, Level1)
268 {
269 GTEST_LOG_(INFO) << "CommonEventControlManager_1400 start";
270 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
271 std::make_shared<CommonEventControlManager>();
272 ASSERT_NE(nullptr, commonEventControlManager);
273 std::string event = "";
274 int32_t userId = ALL_USER + 1;
275 std::vector<std::shared_ptr<OrderedEventRecord>> records;
276 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
277 record->userId = ALL_USER + 1;
278 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
279 commonEventControlManager->GetUnorderedEventRecords(event, userId, records);
280 GTEST_LOG_(INFO) << "CommonEventControlManager_1400 end";
281 }
282
283 /**
284 * @tc.name: CommonEventControlManager_1500
285 * @tc.desc: test GetUnorderedEventRecords function.
286 * @tc.type: FUNC
287 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1500,Level1)288 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1500, Level1)
289 {
290 GTEST_LOG_(INFO) << "CommonEventControlManager_1500 start";
291 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
292 std::make_shared<CommonEventControlManager>();
293 ASSERT_NE(nullptr, commonEventControlManager);
294 std::string event = "";
295 int32_t userId = ALL_USER + 1;
296 std::vector<std::shared_ptr<OrderedEventRecord>> records;
297 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
298 record->userId = ALL_USER + 2;
299 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
300 commonEventControlManager->GetUnorderedEventRecords(event, userId, records);
301 GTEST_LOG_(INFO) << "CommonEventControlManager_1500 end";
302 }
303
304 /**
305 * @tc.name: CommonEventControlManager_1600
306 * @tc.desc: test GetUnorderedEventRecords function.
307 * @tc.type: FUNC
308 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1600,Level1)309 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1600, Level1)
310 {
311 GTEST_LOG_(INFO) << "CommonEventControlManager_1600 start";
312 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
313 std::make_shared<CommonEventControlManager>();
314 ASSERT_NE(nullptr, commonEventControlManager);
315 std::string event = "aa";
316 int32_t userId = ALL_USER;
317 std::vector<std::shared_ptr<OrderedEventRecord>> records;
318 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
319 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
320 record->commonEventData = commonEventData;
321 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
322 commonEventControlManager->GetUnorderedEventRecords(event, userId, records);
323 GTEST_LOG_(INFO) << "CommonEventControlManager_1600 end";
324 }
325
326 /**
327 * @tc.name: CommonEventControlManager_1700
328 * @tc.desc: test GetUnorderedEventRecords function.
329 * @tc.type: FUNC
330 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1700,Level1)331 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1700, Level1)
332 {
333 GTEST_LOG_(INFO) << "CommonEventControlManager_1700 start";
334 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
335 std::make_shared<CommonEventControlManager>();
336 ASSERT_NE(nullptr, commonEventControlManager);
337 std::string event = "aa";
338 int32_t userId = ALL_USER + 1;
339 std::vector<std::shared_ptr<OrderedEventRecord>> records;
340 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
341 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
342 record->commonEventData = commonEventData;
343 record->userId = ALL_USER + 1;
344 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
345 commonEventControlManager->GetUnorderedEventRecords(event, userId, records);
346 GTEST_LOG_(INFO) << "CommonEventControlManager_1700 end";
347 }
348
349 /**
350 * @tc.name: CommonEventControlManager_1800
351 * @tc.desc: test GetUnorderedEventRecords function.
352 * @tc.type: FUNC
353 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1800,Level1)354 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1800, Level1)
355 {
356 GTEST_LOG_(INFO) << "CommonEventControlManager_1800 start";
357 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
358 std::make_shared<CommonEventControlManager>();
359 ASSERT_NE(nullptr, commonEventControlManager);
360 std::string event = "aa";
361 int32_t userId = ALL_USER + 1;
362 std::vector<std::shared_ptr<OrderedEventRecord>> records;
363 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
364 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
365 record->commonEventData = commonEventData;
366 record->userId = ALL_USER;
367 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
368 commonEventControlManager->GetUnorderedEventRecords(event, userId, records);
369 GTEST_LOG_(INFO) << "CommonEventControlManager_1800 end";
370 }
371
372 /**
373 * @tc.name: CommonEventControlManager_1900
374 * @tc.desc: test GetOrderedEventRecords function.
375 * @tc.type: FUNC
376 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_1900,Level1)377 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_1900, Level1)
378 {
379 GTEST_LOG_(INFO) << "CommonEventControlManager_1900 start";
380 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
381 std::make_shared<CommonEventControlManager>();
382 ASSERT_NE(nullptr, commonEventControlManager);
383 std::string event = "";
384 int32_t userId = ALL_USER;
385 std::vector<std::shared_ptr<OrderedEventRecord>> records;
386 commonEventControlManager->GetOrderedEventRecords(event, userId, records);
387 GTEST_LOG_(INFO) << "CommonEventControlManager_1900 end";
388 }
389
390 /**
391 * @tc.name: CommonEventControlManager_2000
392 * @tc.desc: test GetOrderedEventRecords function.
393 * @tc.type: FUNC
394 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2000,Level1)395 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2000, Level1)
396 {
397 GTEST_LOG_(INFO) << "CommonEventControlManager_2000 start";
398 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
399 std::make_shared<CommonEventControlManager>();
400 ASSERT_NE(nullptr, commonEventControlManager);
401 std::string event = "";
402 int32_t userId = ALL_USER + 1;
403 std::vector<std::shared_ptr<OrderedEventRecord>> records;
404 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
405 record->userId = ALL_USER + 1;
406 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
407 commonEventControlManager->GetOrderedEventRecords(event, userId, records);
408 GTEST_LOG_(INFO) << "CommonEventControlManager_2000 end";
409 }
410
411 /**
412 * @tc.name: CommonEventControlManager_2100
413 * @tc.desc: test GetOrderedEventRecords function.
414 * @tc.type: FUNC
415 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2100,Level1)416 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2100, Level1)
417 {
418 GTEST_LOG_(INFO) << "CommonEventControlManager_2100 start";
419 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
420 std::make_shared<CommonEventControlManager>();
421 ASSERT_NE(nullptr, commonEventControlManager);
422 std::string event = "";
423 int32_t userId = ALL_USER + 1;
424 std::vector<std::shared_ptr<OrderedEventRecord>> records;
425 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
426 record->userId = ALL_USER + 2;
427 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
428 commonEventControlManager->GetOrderedEventRecords(event, userId, records);
429 GTEST_LOG_(INFO) << "CommonEventControlManager_2100 end";
430 }
431
432 /**
433 * @tc.name: CommonEventControlManager_2200
434 * @tc.desc: test GetOrderedEventRecords function.
435 * @tc.type: FUNC
436 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2200,Level1)437 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2200, Level1)
438 {
439 GTEST_LOG_(INFO) << "CommonEventControlManager_2200 start";
440 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
441 std::make_shared<CommonEventControlManager>();
442 ASSERT_NE(nullptr, commonEventControlManager);
443 std::string event = "aa";
444 int32_t userId = ALL_USER;
445 std::vector<std::shared_ptr<OrderedEventRecord>> records;
446 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
447 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
448 record->commonEventData = commonEventData;
449 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
450 commonEventControlManager->GetOrderedEventRecords(event, userId, records);
451 GTEST_LOG_(INFO) << "CommonEventControlManager_2200 end";
452 }
453
454 /**
455 * @tc.name: CommonEventControlManager_2300
456 * @tc.desc: test GetOrderedEventRecords function.
457 * @tc.type: FUNC
458 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2300,Level1)459 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2300, Level1)
460 {
461 GTEST_LOG_(INFO) << "CommonEventControlManager_2300 start";
462 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
463 std::make_shared<CommonEventControlManager>();
464 ASSERT_NE(nullptr, commonEventControlManager);
465 std::string event = "aa";
466 int32_t userId = ALL_USER + 1;
467 std::vector<std::shared_ptr<OrderedEventRecord>> records;
468 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
469 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
470 record->commonEventData = commonEventData;
471 record->userId = ALL_USER + 1;
472 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
473 commonEventControlManager->GetOrderedEventRecords(event, userId, records);
474 GTEST_LOG_(INFO) << "CommonEventControlManager_2300 end";
475 }
476
477 /**
478 * @tc.name: CommonEventControlManager_2400
479 * @tc.desc: test GetOrderedEventRecords function.
480 * @tc.type: FUNC
481 */
HWTEST_F(CommonEventControlManagerTest,CommonEventControlManager_2400,Level1)482 HWTEST_F(CommonEventControlManagerTest, CommonEventControlManager_2400, Level1)
483 {
484 GTEST_LOG_(INFO) << "CommonEventControlManager_2400 start";
485 std::shared_ptr<CommonEventControlManager> commonEventControlManager =
486 std::make_shared<CommonEventControlManager>();
487 ASSERT_NE(nullptr, commonEventControlManager);
488 std::string event = "aa";
489 int32_t userId = ALL_USER + 1;
490 std::vector<std::shared_ptr<OrderedEventRecord>> records;
491 std::shared_ptr<OrderedEventRecord> record = std::make_shared<OrderedEventRecord>();
492 std::shared_ptr<CommonEventData> commonEventData = std::make_shared<CommonEventData>();
493 record->commonEventData = commonEventData;
494 record->userId = ALL_USER + 2;
495 commonEventControlManager->unorderedEventQueue_.emplace_back(record);
496 commonEventControlManager->GetOrderedEventRecords(event, userId, records);
497 GTEST_LOG_(INFO) << "CommonEventControlManager_2400 end";
498 }
499
500 }
501 }
502