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 "bundle_manager_helper.h"
21 #include "inner_common_event_manager.h"
22 #undef private
23 #undef protected
24 
25 #include "common_event_constant.h"
26 #include "common_event_listener.h"
27 #include "datetime_ex.h"
28 #include "mock_bundle_manager.h"
29 
30 using namespace testing::ext;
31 using namespace OHOS::EventFwk;
32 using namespace OHOS::AppExecFwk;
33 
34 namespace {
35 const std::string EVENT = "com.ces.test.event";
36 const std::string ENTITY = "com.ces.test.entity";
37 const std::string SCHEME = "com.ces.test.scheme";
38 const std::string PERMISSION = "com.ces.test.permission";
39 const std::string DEVICEDID = "deviceId";
40 const std::string TYPE = "type";
41 const std::string BUNDLE = "BundleName";
42 const std::string ABILITY = "AbilityName";
43 constexpr uint8_t PRIORITY = 1;
44 constexpr uint8_t FLAG = 1;
45 constexpr uint8_t CODE = 1;
46 const std::string DATA = "DATA";
47 
48 const std::string EVENT2 = "com.ces.test.event2";
49 const std::string ENTITY2 = "com.ces.test.entity2";
50 const std::string SCHEME2 = "com.ces.test.scheme2";
51 const std::string PERMISSION2 = "com.ces.test.permission2";
52 const std::string DEVICEDID2 = "deviceId2";
53 const std::string TYPE2 = "type2";
54 constexpr uint8_t PRIORITY2 = 2;
55 constexpr uint8_t FLAG2 = 2;
56 constexpr uint8_t CODE2 = 2;
57 const std::string DATA2 = "DATA2";
58 
59 const std::string EVENT3 = "com.ces.test.event3";
60 constexpr uint8_t INNITCODE = 0;
61 constexpr uint8_t CHANGECODE = 1;
62 constexpr uint8_t CHANGECODE2 = 2;
63 const std::string EVENTCASE1 = "com.ces.test.event.case1";
64 const std::string EVENTCASE2 = "com.ces.test.event.case2";
65 const std::string EVENTCASE3 = "com.ces.test.event.case3";
66 const std::string INNITDATA = "com.ces.test.initdata";
67 const std::string CHANGEDATA = "com.ces.test.changedata";
68 const std::string CHANGEDATA2 = "com.ces.test.changedata2";
69 constexpr uid_t UID = 10;
70 constexpr uid_t UID2 = 11;
71 constexpr uint8_t STATE_INDEX1 = 1;
72 constexpr uint8_t STATE_INDEX2 = 2;
73 constexpr uint8_t STATE_INDEX3 = 3;
74 constexpr uint8_t PUBLISH_COUNT = 60;
75 constexpr uint8_t DUMP_SUBSCRIBER_COUNT_ONE = 1;
76 constexpr uint8_t DUMP_SUBSCRIBER_COUNT_TWO = 2;
77 constexpr uint8_t DUMP_STICKY_COUNT_ONE = 1;
78 constexpr uint8_t DUMP_STICKY_COUNT_TWO = 2;
79 constexpr uint8_t DUMP_PENDING_COUNT_ONE = 1;
80 constexpr uint8_t DUMP_HISTORY_COUNT_ONE = 1;
81 constexpr uint8_t DUMP_HISTORY_COUNT_TWO = 2;
82 constexpr uint8_t DUMP_HISTORY_COUNT_THREE = 3;
83 constexpr uint8_t DUMP_HISTORY_COUNT_MAX = 100;
84 
85 constexpr uint8_t PID = 0;
86 constexpr uint16_t SYSTEM_UID = 1000;
87 
88 static OHOS::sptr<OHOS::IRemoteObject> bundleObject = nullptr;
89 OHOS::sptr<OHOS::IRemoteObject> commonEventListener;
90 OHOS::sptr<OHOS::IRemoteObject> commonEventListener2;
91 OHOS::sptr<OHOS::IRemoteObject> commonEventListener3;
92 
93 class CommonEventDumpTest : public testing::Test {
94 public:
CommonEventDumpTest()95     CommonEventDumpTest()
96     {}
~CommonEventDumpTest()97     ~CommonEventDumpTest()
98     {}
99     static void SetUpTestCase(void);
100     static void TearDownTestCase(void);
101     void SetUp();
102     void TearDown();
103     bool SubscribeCommonEvent(const std::shared_ptr<CommonEventSubscriber> &subscriber, uid_t callingUid,
104         OHOS::sptr<OHOS::IRemoteObject> &commonEventListener);
105     bool PublishCommonEvent(const CommonEventData &data, const CommonEventPublishInfo &publishInfo,
106         const std::shared_ptr<CommonEventSubscriber> &subscriber, OHOS::sptr<OHOS::IRemoteObject> &commonEventListener);
107     static bool FinishReceiver(
108         const OHOS::sptr<OHOS::IRemoteObject> &proxy, const int &code, const std::string &data, const bool &abortEvent);
109     void AsyncProcess();
110     std::shared_ptr<InnerCommonEventManager> GetInnerCommonEventManager();
111     static void DumpInfoCount(const std::vector<std::string> &state, int desSubscribersCount, int desStickyCount,
112         int desOrderedCount, int desHistoryCount);
113     void SetPublishDataByOrdered(CommonEventData &data, CommonEventPublishInfo &publishInfo);
114     void SetPublishDataByOrdered2(CommonEventData &data, CommonEventPublishInfo &publishInfo);
115     void SetPublishDataByUnordered(CommonEventData &data, CommonEventPublishInfo &publishInfo);
116     void SubscribeDoubleEvent(
117         int priority, const std::string &permission, const std::string &deviceId, CommonEventListener *&listener);
118     void PublishUnorderedEvent(
119         const std::string &event, const std::string &type,
120         const int code, const std::string &data, const std::string &permission);
121     void PublishStickyEvent(
122         const std::string &event, const std::string &type,
123         const int code, const std::string &data, const std::string &permission);
124     void PublishStickyEvent(
125         const std::string &event, const std::string &type, const int flag, const std::string &permission);
126 
127 private:
128     std::shared_ptr<EventRunner> runner_;
129     static std::shared_ptr<EventHandler> handler_;
130     static std::shared_ptr<InnerCommonEventManager> innerCommonEventManager_;
131 };
132 
133 class SubscriberTest : public CommonEventSubscriber {
134 public:
SubscriberTest(const CommonEventSubscribeInfo & sp,const std::shared_ptr<InnerCommonEventManager> & innerCommonEventManager=nullptr)135     explicit SubscriberTest(const CommonEventSubscribeInfo &sp,
136         const std::shared_ptr<InnerCommonEventManager> &innerCommonEventManager = nullptr)
137         : CommonEventSubscriber(sp)
138     {
139         innerCommonEventManager_ = innerCommonEventManager;
140         handler_ = std::make_shared<EventHandler>(EventRunner::Create());
141     }
142 
~SubscriberTest()143     ~SubscriberTest()
144     {}
145 
OnReceiveEvent(const CommonEventData & data)146     virtual void OnReceiveEvent(const CommonEventData &data)
147     {
148         std::string action = data.GetWant().GetAction();
149         if (action == EVENTCASE1) {
150             ProcessSubscriberTestCase1(data);
151         } else if (action == EVENTCASE2) {
152             ProcessSubscriberTestCase2(data);
153         } else if (action == EVENTCASE3) {
154             EVENT_LOGI("SubscriberTest: ProcessSubscriberTestCase3:  start");
155         } else {
156         }
157     }
158 
159 private:
ProcessSubscriberTestCase1(CommonEventData data)160     void ProcessSubscriberTestCase1(CommonEventData data)
161     {
162         EVENT_LOGI("SubscriberTest: ProcessSubscriberTestCase1:  start");
163         std::shared_ptr<AsyncCommonEventResult> result = GoAsyncCommonEvent();
164         std::function<void()> asyncProcessFunc = std::bind(&SubscriberTest::AsyncProcess, this, commonEventListener);
165         handler_->PostTask(asyncProcessFunc);
166     }
ProcessSubscriberTestCase2(CommonEventData data)167     void ProcessSubscriberTestCase2(CommonEventData data)
168     {
169         EVENT_LOGI("SubscriberTest: ProcessSubscriberTest2Case2:  start");
170         std::shared_ptr<AsyncCommonEventResult> result = GoAsyncCommonEvent();
171         std::function<void()> asyncProcessFunc = std::bind(&SubscriberTest::AsyncProcess, this, commonEventListener);
172         handler_->PostTask(asyncProcessFunc);
173     }
174 
AsyncProcess(OHOS::sptr<OHOS::IRemoteObject> commonEventListener)175     void AsyncProcess(OHOS::sptr<OHOS::IRemoteObject> commonEventListener)
176     {
177         EXPECT_TRUE(CommonEventDumpTest::FinishReceiver(commonEventListener, CHANGECODE, CHANGEDATA, false));
178     }
179 
180 private:
181     std::shared_ptr<EventHandler> handler_;
182     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager_;
183 };
184 
185 class SubscriberTest2 : public CommonEventSubscriber {
186 public:
SubscriberTest2(const CommonEventSubscribeInfo & sp,const std::shared_ptr<InnerCommonEventManager> & innerCommonEventManager=nullptr)187     explicit SubscriberTest2(const CommonEventSubscribeInfo &sp,
188         const std::shared_ptr<InnerCommonEventManager> &innerCommonEventManager = nullptr)
189         : CommonEventSubscriber(sp)
190     {
191         innerCommonEventManager_ = innerCommonEventManager;
192         handler_ = std::make_shared<EventHandler>(EventRunner::Create());
193     }
194 
~SubscriberTest2()195     ~SubscriberTest2()
196     {}
197 
OnReceiveEvent(const CommonEventData & data)198     virtual void OnReceiveEvent(const CommonEventData &data)
199     {
200         std::string action = data.GetWant().GetAction();
201         if (action == EVENTCASE1) {
202             ProcessSubscriberTest2Case1(data);
203         } else if (action == EVENTCASE2) {
204             ProcessSubscriberTest2Case2(data);
205         } else if (action == EVENTCASE3) {
206             EVENT_LOGI("SubscriberTest2: ProcessSubscriberTest2Case3:  start");
207         } else {
208         }
209     }
210 
211 private:
ProcessSubscriberTest2Case1(CommonEventData data)212     void ProcessSubscriberTest2Case1(CommonEventData data)
213     {
214         EVENT_LOGI("SubscriberTest2: ProcessSubscriberTest2Case1:  start");
215         std::shared_ptr<AsyncCommonEventResult> result = GoAsyncCommonEvent();
216         if (innerCommonEventManager_) {
217             std::vector<std::string> state;
218             innerCommonEventManager_->DumpState(static_cast<int32_t>(DumpEventType::ALL), "", ALL_USER, state);
219             CommonEventDumpTest::DumpInfoCount(state,
220                 DUMP_SUBSCRIBER_COUNT_TWO, DUMP_STICKY_COUNT_TWO, DUMP_PENDING_COUNT_ONE, 0);
221         }
222         std::function<void()> asyncProcessFunc = std::bind(&SubscriberTest2::AsyncProcess, this, commonEventListener2);
223         handler_->PostTask(asyncProcessFunc);
224     }
ProcessSubscriberTest2Case2(CommonEventData data)225     void ProcessSubscriberTest2Case2(CommonEventData data)
226     {
227         EVENT_LOGI("SubscriberTest2: ProcessSubscriberTest2Case2:  start");
228         std::shared_ptr<AsyncCommonEventResult> result = GoAsyncCommonEvent();
229         std::function<void()> asyncProcessFunc = std::bind(&SubscriberTest2::AsyncProcess, this, commonEventListener2);
230         handler_->PostTask(asyncProcessFunc);
231         EVENT_LOGI("SubscriberTest2: ProcessSubscriberTest2Case2:  end");
232     }
233 
AsyncProcess(OHOS::sptr<OHOS::IRemoteObject> commonEventListener)234     void AsyncProcess(OHOS::sptr<OHOS::IRemoteObject> commonEventListener)
235     {
236         EXPECT_TRUE(CommonEventDumpTest::FinishReceiver(commonEventListener, CHANGECODE2, CHANGEDATA2, false));
237     }
238 
239 private:
240     std::shared_ptr<EventHandler> handler_;
241     std::shared_ptr<InnerCommonEventManager> innerCommonEventManager_;
242 };
243 
244 class SubscriberTestLast : public CommonEventSubscriber {
245 public:
SubscriberTestLast()246     SubscriberTestLast() : CommonEventSubscriber()
247     {
248         handler_ = std::make_shared<EventHandler>(EventRunner::Create());
249     }
250 
SubscriberTestLast(const CommonEventSubscribeInfo & sp)251     explicit SubscriberTestLast(const CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp)
252     {
253         handler_ = std::make_shared<EventHandler>(EventRunner::Create());
254     }
255 
~SubscriberTestLast()256     ~SubscriberTestLast()
257     {}
258 
OnReceiveEvent(const CommonEventData & data)259     virtual void OnReceiveEvent(const CommonEventData &data)
260     {
261         std::string action = data.GetWant().GetAction();
262         if (action == EVENTCASE1) {
263             ProcessSubscriberTestLastCase1(data);
264         } else if (action == EVENTCASE2) {
265             ProcessSubscriberTestLastCase2(data);
266         } else {
267         }
268     }
269 
270 private:
ProcessSubscriberTestLastCase1(CommonEventData data)271     void ProcessSubscriberTestLastCase1(CommonEventData data)
272     {
273         EVENT_LOGI("SubscriberTestLast: ProcessSubscriberTestLastCase1:  start");
274         std::shared_ptr<AsyncCommonEventResult> result = GoAsyncCommonEvent();
275         std::function<void()> asyncProcessFunc =
276             std::bind(&SubscriberTestLast::AsyncProcess, this, commonEventListener3);
277         handler_->PostTask(asyncProcessFunc);
278     }
ProcessSubscriberTestLastCase2(CommonEventData data)279     void ProcessSubscriberTestLastCase2(CommonEventData data)
280     {
281         EVENT_LOGI("SubscriberTestLast: ProcessSubscriberTest2Case2:  start");
282     }
283 
AsyncProcess(OHOS::sptr<OHOS::IRemoteObject> commonEventListener)284     void AsyncProcess(OHOS::sptr<OHOS::IRemoteObject> commonEventListener)
285     {
286         EXPECT_TRUE(CommonEventDumpTest::FinishReceiver(commonEventListener, CHANGECODE2, CHANGEDATA2, false));
287     }
288 
289 private:
290     std::shared_ptr<EventHandler> handler_;
291 };
292 
293 std::shared_ptr<EventHandler> CommonEventDumpTest::handler_ = nullptr;
294 std::shared_ptr<InnerCommonEventManager> CommonEventDumpTest::innerCommonEventManager_ = nullptr;
295 
SetUpTestCase(void)296 void CommonEventDumpTest::SetUpTestCase(void)
297 {
298     bundleObject = new MockBundleMgrService();
299     OHOS::DelayedSingleton<BundleManagerHelper>::GetInstance()->sptrBundleMgr_ =
300         OHOS::iface_cast<OHOS::AppExecFwk::IBundleMgr>(bundleObject);
301 }
302 
TearDownTestCase(void)303 void CommonEventDumpTest::TearDownTestCase(void)
304 {}
305 
SetUp(void)306 void CommonEventDumpTest::SetUp(void)
307 {
308     runner_ = EventRunner::Create(true);
309     if (!runner_) {
310         return;
311     }
312     handler_ = std::make_shared<EventHandler>(runner_);
313     innerCommonEventManager_ = std::make_shared<InnerCommonEventManager>();
314 }
315 
TearDown(void)316 void CommonEventDumpTest::TearDown(void)
317 {
318     if (innerCommonEventManager_ != nullptr) {
319         if (innerCommonEventManager_->controlPtr_ != nullptr) {
320             innerCommonEventManager_->controlPtr_.reset();
321         }
322         if (innerCommonEventManager_->staticSubscriberManager_ != nullptr) {
323             innerCommonEventManager_->staticSubscriberManager_.reset();
324         }
325     }
326 }
327 
SubscribeCommonEvent(const std::shared_ptr<CommonEventSubscriber> & subscriber,uid_t callingUid,OHOS::sptr<OHOS::IRemoteObject> & commonEventListener)328 bool CommonEventDumpTest::SubscribeCommonEvent(const std::shared_ptr<CommonEventSubscriber> &subscriber,
329     uid_t callingUid, OHOS::sptr<OHOS::IRemoteObject> &commonEventListener)
330 {
331     OHOS::sptr<IEventReceive> listener = new CommonEventListener(subscriber);
332     if (!listener) {
333         return false;
334     }
335     commonEventListener = listener->AsObject();
336     struct tm recordTime = {0};
337     if (!OHOS::GetSystemCurrentTime(&recordTime)) {
338         return false;
339     }
340     pid_t callingPid = 10;
341     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
342 
343     std::string bundleName = "";
344     std::function<void()> SubscribeCommonEventFunc = std::bind(&InnerCommonEventManager::SubscribeCommonEvent,
345         innerCommonEventManager_,
346         subscriber->GetSubscribeInfo(),
347         commonEventListener,
348         recordTime,
349         callingPid,
350         callingUid,
351         tokenID,
352         bundleName,
353         0,
354         0);
355     return handler_->PostTask(SubscribeCommonEventFunc);
356 }
357 
PublishCommonEvent(const CommonEventData & data,const CommonEventPublishInfo & publishInfo,const std::shared_ptr<CommonEventSubscriber> & subscriber,OHOS::sptr<OHOS::IRemoteObject> & commonEventListener)358 bool CommonEventDumpTest::PublishCommonEvent(const CommonEventData &data, const CommonEventPublishInfo &publishInfo,
359     const std::shared_ptr<CommonEventSubscriber> &subscriber, OHOS::sptr<OHOS::IRemoteObject> &commonEventListener)
360 {
361     if (commonEventListener == nullptr && publishInfo.IsOrdered()) {
362         OHOS::sptr<IEventReceive> listener = new CommonEventListener(subscriber);
363         if (!listener) {
364             return false;
365         }
366         commonEventListener = listener->AsObject();
367     } else if (!publishInfo.IsOrdered()) {
368         commonEventListener = nullptr;
369     }
370 
371     struct tm recordTime = {0};
372     if (!OHOS::GetSystemCurrentTime(&recordTime)) {
373         return false;
374     }
375     pid_t callingPid = 20;
376     uid_t callingUid = 21;
377     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
378     int32_t userId = UNDEFINED_USER;
379     std::string bundleName = "";
380 
381     std::function<void()> PublishCommonEventFunc = std::bind(&InnerCommonEventManager::PublishCommonEvent,
382         innerCommonEventManager_,
383         data,
384         publishInfo,
385         commonEventListener,
386         recordTime,
387         callingPid,
388         callingUid,
389         tokenID,
390         userId,
391         bundleName,
392         nullptr);
393     return handler_->PostTask(PublishCommonEventFunc);
394 }
395 
FinishReceiver(const OHOS::sptr<OHOS::IRemoteObject> & proxy,const int & code,const std::string & data,const bool & abortEvent)396 bool CommonEventDumpTest::FinishReceiver(
397     const OHOS::sptr<OHOS::IRemoteObject> &proxy, const int &code, const std::string &data, const bool &abortEvent)
398 {
399     std::function<void()> FinishReceiverFunc =
400         std::bind(&InnerCommonEventManager::FinishReceiver, innerCommonEventManager_, proxy, code, data, abortEvent);
401     return handler_->PostTask(FinishReceiverFunc);
402 }
403 
GetInnerCommonEventManager()404 std::shared_ptr<InnerCommonEventManager> CommonEventDumpTest::GetInnerCommonEventManager()
405 {
406     return innerCommonEventManager_;
407 }
408 
DumpInfoCount(const std::vector<std::string> & state,int desSubscribersCount,int desStickyCount,int desPendingCount,int desHistoryCount)409 void CommonEventDumpTest::DumpInfoCount(const std::vector<std::string> &state, int desSubscribersCount,
410     int desStickyCount, int desPendingCount, int desHistoryCount)
411 {
412     int subscribersNum = 0;
413     int stickyNum = 0;
414     int pendingCount = 0;
415     int historyCount = 0;
416     bool isSubscribers = false;
417     bool isSticky = false;
418     bool isPending = false;
419     bool isHistory = false;
420     for (auto vec : state) {
421         EVENT_LOGI("DumpInfoCount:  %{public}s", vec.c_str());
422         auto pos = vec.find("No information");
423         if (pos != string::npos) {
424             auto pos2 = vec.find("\tSubscribers:\tNo information");
425             if (pos2 != string::npos) {
426             } else {
427                 continue;
428             }
429         }
430         if (!isPending && !isHistory) {
431             auto pos = vec.find("Subscribers:");
432             if (pos != string::npos) {
433                 isSubscribers = true;
434             }
435         }
436         pos = vec.find("Sticky Events:");
437         if (pos != string::npos) {
438             isSubscribers = false;
439             isSticky = true;
440         }
441         pos = vec.find("Pending Events:");
442         if (pos != string::npos) {
443             isSubscribers = false;
444             isSticky = false;
445             isPending = true;
446         }
447         pos = vec.find("History Events:");
448         if (pos != string::npos) {
449             isSubscribers = false;
450             isSticky = false;
451             isPending = false;
452             isHistory = true;
453         }
454         if (isSubscribers) {
455             subscribersNum++;
456         } else if (isSticky) {
457             stickyNum++;
458         } else if (isPending) {
459             pendingCount++;
460         } else if (isHistory) {
461             historyCount++;
462         }
463     }
464 
465     EXPECT_EQ(subscribersNum, desSubscribersCount);
466     EXPECT_EQ(stickyNum, desStickyCount);
467     EXPECT_EQ(pendingCount, desPendingCount);
468     EXPECT_EQ(historyCount, desHistoryCount);
469 }
470 
SetPublishDataByOrdered(CommonEventData & data,CommonEventPublishInfo & publishInfo)471 void CommonEventDumpTest::SetPublishDataByOrdered(CommonEventData &data, CommonEventPublishInfo &publishInfo)
472 {
473     // make a want
474     Want want;
475     want.SetAction(EVENTCASE1);
476     want.AddEntity(ENTITY);
477     want.AddEntity(ENTITY2);
478     want.SetType(TYPE);
479     want.SetFlags(FLAG);
480 
481     OHOS::AppExecFwk::ElementName element;
482     element.SetBundleName(BUNDLE);
483     element.SetAbilityName(ABILITY);
484     element.SetDeviceID(DEVICEDID);
485     want.SetElement(element);
486 
487     // make common event data
488     data.SetWant(want);
489     data.SetData(INNITDATA);
490     data.SetCode(INNITCODE);
491 
492     publishInfo.SetOrdered(true);
493 }
494 
SetPublishDataByOrdered2(CommonEventData & data,CommonEventPublishInfo & publishInfo)495 void CommonEventDumpTest::SetPublishDataByOrdered2(CommonEventData &data, CommonEventPublishInfo &publishInfo)
496 {
497     // make a want
498     Want want;
499     want.SetAction(EVENTCASE2);
500     want.AddEntity(ENTITY);
501     want.AddEntity(ENTITY2);
502     want.SetType(TYPE);
503     want.SetFlags(FLAG);
504 
505     OHOS::AppExecFwk::ElementName element;
506     element.SetBundleName(BUNDLE);
507     element.SetAbilityName(ABILITY);
508     element.SetDeviceID(DEVICEDID);
509     want.SetElement(element);
510 
511     // make common event data
512     data.SetWant(want);
513     data.SetData(INNITDATA);
514     data.SetCode(INNITCODE);
515 
516     publishInfo.SetOrdered(true);
517 }
518 
SetPublishDataByUnordered(CommonEventData & data,CommonEventPublishInfo & publishInfo)519 void CommonEventDumpTest::SetPublishDataByUnordered(CommonEventData &data, CommonEventPublishInfo &publishInfo)
520 {
521     // make a want
522     Want want;
523     want.SetAction(EVENTCASE3);
524     want.AddEntity(ENTITY);
525     want.AddEntity(ENTITY2);
526     want.SetType(TYPE);
527     want.SetFlags(FLAG);
528 
529     OHOS::AppExecFwk::ElementName element;
530     element.SetBundleName(BUNDLE);
531     element.SetAbilityName(ABILITY);
532     element.SetDeviceID(DEVICEDID);
533     want.SetElement(element);
534 
535     // make common event data
536     data.SetWant(want);
537     data.SetData(INNITDATA);
538     data.SetCode(INNITCODE);
539 
540     publishInfo.SetOrdered(false);
541 }
542 
SubscribeDoubleEvent(int priority,const std::string & permission,const std::string & deviceId,CommonEventListener * & listener)543 void CommonEventDumpTest::SubscribeDoubleEvent(
544     int priority, const std::string &permission, const std::string &deviceId, CommonEventListener *&listener)
545 {
546     MatchingSkills matchingSkills;
547     matchingSkills.AddEvent(EVENT);
548     matchingSkills.AddEvent(EVENT2);
549     matchingSkills.AddEntity(ENTITY);
550     matchingSkills.AddEntity(ENTITY2);
551 
552     CommonEventSubscribeInfo subscribeInfo(matchingSkills);
553     subscribeInfo.SetPriority(priority);
554     subscribeInfo.SetPermission(permission);
555     subscribeInfo.SetDeviceId(deviceId);
556 
557     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
558     listener = new (std::nothrow) CommonEventListener(subscriber);
559 
560     struct tm curTime {0};
561     OHOS::Security::AccessToken::AccessTokenID tokenID = 1;
562     innerCommonEventManager_->SubscribeCommonEvent(
563         subscribeInfo, listener->AsObject(), curTime, PID, SYSTEM_UID, tokenID, "hello");
564 }
565 
PublishUnorderedEvent(const std::string & event,const std::string & type,const int code,const std::string & data,const std::string & permission)566 void CommonEventDumpTest::PublishUnorderedEvent(
567     const std::string &event, const std::string &type,
568     const int code, const std::string &data, const std::string &permission)
569 {
570     Want want;
571     want.SetAction(event);
572     want.AddEntity(ENTITY);
573     want.AddEntity(ENTITY2);
574     want.SetType(type);
575 
576     OHOS::AppExecFwk::ElementName element;
577     element.SetBundleName(BUNDLE);
578     element.SetAbilityName(ABILITY);
579     element.SetDeviceID(DEVICEDID);
580     want.SetElement(element);
581 
582     // make common event data
583     CommonEventData eventData;
584     eventData.SetWant(want);
585     eventData.SetCode(code);
586     eventData.SetData(data);
587 
588     // make publish info
589     CommonEventPublishInfo publishInfo;
590     publishInfo.SetSticky(false);
591     std::vector<std::string> permissions;
592     permissions.emplace_back(permission);
593     publishInfo.SetSubscriberPermissions(permissions);
594 
595     struct tm curTime {0};
596     OHOS::Security::AccessToken::AccessTokenID tokenID = 1;
597     innerCommonEventManager_->PublishCommonEvent(
598         eventData, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "hello");
599 }
600 
PublishStickyEvent(const std::string & event,const std::string & type,const int code,const std::string & data,const std::string & permission)601 void CommonEventDumpTest::PublishStickyEvent(
602     const std::string &event, const std::string &type,
603     const int code, const std::string &data, const std::string &permission)
604 {
605     Want want;
606     want.SetAction(event);
607     want.AddEntity(ENTITY);
608     want.AddEntity(ENTITY2);
609     want.SetType(type);
610 
611     OHOS::AppExecFwk::ElementName element;
612     element.SetBundleName(BUNDLE);
613     element.SetAbilityName(ABILITY);
614     element.SetDeviceID(DEVICEDID);
615     want.SetElement(element);
616 
617     // make common event data
618     CommonEventData eventData;
619     eventData.SetWant(want);
620     eventData.SetCode(code);
621     eventData.SetData(data);
622 
623     // make publish info
624     CommonEventPublishInfo publishInfo;
625     publishInfo.SetSticky(true);
626     std::vector<std::string> permissions;
627     permissions.emplace_back(permission);
628     publishInfo.SetSubscriberPermissions(permissions);
629 
630     struct tm curTime {0};
631     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
632     innerCommonEventManager_->PublishCommonEvent(
633         eventData, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "hello");
634 }
635 
PublishStickyEvent(const std::string & event,const std::string & type,const int flag,const std::string & permission)636 void CommonEventDumpTest::PublishStickyEvent(
637     const std::string &event, const std::string &type, const int flag, const std::string &permission)
638 {
639     Want want;
640     want.SetAction(event);
641     want.AddEntity(ENTITY);
642     want.AddEntity(ENTITY2);
643     want.SetType(type);
644     want.SetFlags(flag);
645 
646     OHOS::AppExecFwk::ElementName element;
647     element.SetBundleName(BUNDLE);
648     element.SetAbilityName(ABILITY);
649     element.SetDeviceID(DEVICEDID);
650     want.SetElement(element);
651 
652     // make common event data
653     CommonEventData eventData;
654     eventData.SetWant(want);
655 
656     // make publish info
657     CommonEventPublishInfo publishInfo;
658     publishInfo.SetSticky(true);
659     std::vector<std::string> permissions;
660     permissions.emplace_back(permission);
661     publishInfo.SetSubscriberPermissions(permissions);
662 
663     struct tm curTime {0};
664     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
665     innerCommonEventManager_->PublishCommonEvent(
666         eventData, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "hello");
667 }
668 
669 /*
670  * @tc.number: CommonEventDumpTest_0100
671  * @tc.name: test dump
672  * @tc.desc: Verify dump information after publishing unordered events
673  */
674 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_0100, Function | MediumTest | Level1)
675 {
676     /* Subscribe */
677     CommonEventListener *listener = nullptr;
678     CommonEventListener *listener2 = nullptr;
679     SubscribeDoubleEvent(PRIORITY, PERMISSION, DEVICEDID, listener);
680     SubscribeDoubleEvent(PRIORITY2, PERMISSION2, DEVICEDID2, listener2);
681     EXPECT_NE(nullptr, listener);
682     EXPECT_NE(nullptr, listener2);
683 
684     /* Publish */
685     PublishUnorderedEvent(EVENT, TYPE, CODE, DATA, PERMISSION);
686     PublishUnorderedEvent(EVENT2, TYPE2, CODE2, DATA2, PERMISSION2);
687 
688     usleep(50000);
689 
690     std::vector<std::string> state;
691     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), "", ALL_USER, state);
692     GTEST_LOG_(INFO) << "get state size:" << state.size();
693     ASSERT_NE(state.size(), 0);
694     DumpInfoCount(state, DUMP_SUBSCRIBER_COUNT_TWO, 0, 0, DUMP_HISTORY_COUNT_TWO);
695     EXPECT_EQ("Sticky Events:\tNo information", state[STATE_INDEX2]);
696 
697     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener->AsObject());
698     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener2->AsObject());
699 }
700 
701 /*
702  * @tc.number: CommonEventDumpTest_0200
703  * @tc.name: test dump
704  * @tc.desc: Verify dump information after publishing sticky events
705  */
706 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_0200, Function | MediumTest | Level1)
707 {
708     /* Subscribe */
709     CommonEventListener *listener = nullptr;
710     CommonEventListener *listener2 = nullptr;
711     SubscribeDoubleEvent(PRIORITY, PERMISSION, DEVICEDID, listener);
712     SubscribeDoubleEvent(PRIORITY2, PERMISSION2, DEVICEDID2, listener2);
713     EXPECT_NE(nullptr, listener);
714     EXPECT_NE(nullptr, listener2);
715 
716     /* Publish */
717     PublishStickyEvent(EVENT, TYPE, CODE, DATA, PERMISSION);
718     PublishStickyEvent(EVENT2, TYPE2, CODE2, DATA2, PERMISSION2);
719 
720     usleep(50000);
721 
722     std::vector<std::string> state;
723     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), "", ALL_USER, state);
724     GTEST_LOG_(INFO) << "get state size:" << state.size();
725     DumpInfoCount(state, DUMP_SUBSCRIBER_COUNT_TWO, DUMP_STICKY_COUNT_TWO, 0, DUMP_HISTORY_COUNT_TWO);
726 
727     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener->AsObject());
728     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener2->AsObject());
729 }
730 
731 /*
732  * @tc.number: CommonEventDumpTest_0300
733  * @tc.name: test dump
734  * @tc.desc: Verify dump information after updating sticky events
735  */
736 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_0300, Function | MediumTest | Level1)
737 {
738     /* Publish */
739     PublishStickyEvent(EVENT, TYPE, FLAG, PERMISSION);
740     PublishStickyEvent(EVENT2, TYPE2, FLAG2, PERMISSION2);
741 
742     usleep(50000);
743 
744     std::vector<std::string> state;
745     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), "", ALL_USER, state);
746     GTEST_LOG_(INFO) << "get state size:" << state.size();
747     ASSERT_NE(state.size(), 0);
748     DumpInfoCount(state, 0, DUMP_STICKY_COUNT_TWO, 0, DUMP_HISTORY_COUNT_TWO);
749     EXPECT_EQ("Subscribers:\tNo information", state[0]);
750 }
751 
752 /*
753  * @tc.number: CommonEventDumpTest_0400
754  * @tc.name: test dump
755  * @tc.desc: Verify dump information after subscribing
756  */
757 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_0400, Function | MediumTest | Level1)
758 {
759     /* Subscribe */
760     MatchingSkills matchingSkills;
761     matchingSkills.AddEvent(EVENT);
762     matchingSkills.AddScheme(SCHEME);
763 
764     CommonEventSubscribeInfo subscribeInfo(matchingSkills);
765     subscribeInfo.SetPriority(PRIORITY);
766     subscribeInfo.SetPermission(PERMISSION);
767     subscribeInfo.SetDeviceId(DEVICEDID);
768 
769     struct tm curTime {0};
770     OHOS::Security::AccessToken::AccessTokenID tokenID = 1;
771 
772     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
773     CommonEventListener *listener = new CommonEventListener(subscriber);
774     GetInnerCommonEventManager()->SubscribeCommonEvent(
775         subscribeInfo, listener->AsObject(), curTime, PID, SYSTEM_UID, tokenID, "hello");
776 
777     usleep(50000);
778 
779     std::vector<std::string> state;
780     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), "", ALL_USER, state);
781     GTEST_LOG_(INFO) << "get state size:" << state.size();
782     DumpInfoCount(state, DUMP_SUBSCRIBER_COUNT_ONE, DUMP_STICKY_COUNT_TWO, 0, DUMP_HISTORY_COUNT_ONE);
783 
784     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener->AsObject());
785 }
786 
787 /*
788  * @tc.number: CommonEventDumpTest_0500
789  * @tc.name: test dump
790  * @tc.desc: Verify dump information after subscribing
791  */
792 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_0500, Function | MediumTest | Level1)
793 {
794     /* Subscribe */
795     MatchingSkills matchingSkills;
796     matchingSkills.AddEvent(EVENT);
797 
798     CommonEventSubscribeInfo subscribeInfo(matchingSkills);
799     subscribeInfo.SetPriority(PRIORITY);
800     subscribeInfo.SetPermission(PERMISSION);
801     subscribeInfo.SetDeviceId(DEVICEDID);
802 
803     struct tm curTime {0};
804     OHOS::Security::AccessToken::AccessTokenID tokenID = 1;
805 
806     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
807     CommonEventListener *listener = new CommonEventListener(subscriber);
808     GetInnerCommonEventManager()->SubscribeCommonEvent(
809         subscribeInfo, listener->AsObject(), curTime, PID, SYSTEM_UID, tokenID, "hello");
810 
811     usleep(50000);
812 
813     std::vector<std::string> state;
814     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), "", ALL_USER, state);
815     GTEST_LOG_(INFO) << "get state size:" << state.size();
816     DumpInfoCount(state, DUMP_SUBSCRIBER_COUNT_ONE, DUMP_STICKY_COUNT_TWO, 0, DUMP_HISTORY_COUNT_ONE);
817 
818     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener->AsObject());
819 }
820 
821 /*
822  * @tc.number: CommonEventDumpTest_0600
823  * @tc.name: test dump
824  * @tc.desc: Verify dump information after subscribing
825  */
826 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_0600, Function | MediumTest | Level1)
827 {
828     /* Subscribe */
829     MatchingSkills matchingSkills;
830     matchingSkills.AddEvent(EVENT);
831 
832     CommonEventSubscribeInfo subscribeInfo(matchingSkills);
833     subscribeInfo.SetPermission(PERMISSION);
834     subscribeInfo.SetDeviceId(DEVICEDID);
835 
836     struct tm curTime {0};
837     OHOS::Security::AccessToken::AccessTokenID tokenID = 1;
838 
839     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
840     CommonEventListener *listener = new CommonEventListener(subscriber);
841     GetInnerCommonEventManager()->SubscribeCommonEvent(
842         subscribeInfo, listener->AsObject(), curTime, PID, SYSTEM_UID, tokenID, "hello");
843 
844     usleep(50000);
845 
846     std::vector<std::string> state;
847     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), "", ALL_USER, state);
848     GTEST_LOG_(INFO) << "get state size:" << state.size();
849     DumpInfoCount(state, DUMP_SUBSCRIBER_COUNT_ONE, DUMP_STICKY_COUNT_TWO, 0, DUMP_HISTORY_COUNT_ONE);
850 
851     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener->AsObject());
852 }
853 
854 /*
855  * @tc.number: CommonEventDumpTest_0700
856  * @tc.name: test dump
857  * @tc.desc: Verify dump information after subscribing
858  */
859 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_0700, Function | MediumTest | Level1)
860 {
861     /* Subscribe */
862     MatchingSkills matchingSkills;
863     matchingSkills.AddEvent(EVENT);
864 
865     CommonEventSubscribeInfo subscribeInfo(matchingSkills);
866     subscribeInfo.SetDeviceId(DEVICEDID);
867 
868     struct tm curTime {0};
869     OHOS::Security::AccessToken::AccessTokenID tokenID = 1;
870 
871     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
872     CommonEventListener *listener = new CommonEventListener(subscriber);
873     GetInnerCommonEventManager()->SubscribeCommonEvent(
874         subscribeInfo, listener->AsObject(), curTime, PID, SYSTEM_UID, tokenID, "hello");
875 
876     usleep(50000);
877 
878     std::vector<std::string> state;
879     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), "", ALL_USER, state);
880     GTEST_LOG_(INFO) << "get state size:" << state.size();
881     DumpInfoCount(state, DUMP_SUBSCRIBER_COUNT_ONE, DUMP_STICKY_COUNT_TWO, 0, DUMP_HISTORY_COUNT_ONE);
882 
883     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener->AsObject());
884 }
885 
886 /*
887  * @tc.number: CommonEventDumpTest_0800
888  * @tc.name: test dump
889  * @tc.desc: Verify dump information after subscribing
890  */
891 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_0800, Function | MediumTest | Level1)
892 {
893     /* Subscribe */
894     MatchingSkills matchingSkills;
895     matchingSkills.AddEvent(EVENT);
896 
897     CommonEventSubscribeInfo subscribeInfo(matchingSkills);
898 
899     struct tm curTime {0};
900     OHOS::Security::AccessToken::AccessTokenID tokenID = 1;
901 
902     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
903     CommonEventListener *listener = new CommonEventListener(subscriber);
904     GetInnerCommonEventManager()->SubscribeCommonEvent(
905         subscribeInfo, listener->AsObject(), curTime, PID, SYSTEM_UID, tokenID, "hello");
906 
907     usleep(50000);
908 
909     std::vector<std::string> state;
910     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), "", ALL_USER, state);
911     GTEST_LOG_(INFO) << "get state size:" << state.size();
912     DumpInfoCount(state, DUMP_SUBSCRIBER_COUNT_ONE, DUMP_STICKY_COUNT_TWO, 0, DUMP_HISTORY_COUNT_ONE);
913 
914     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener->AsObject());
915 }
916 
917 /*
918  * @tc.number: CommonEventDumpTest_0900
919  * @tc.name: test dump
920  * @tc.desc: Verify dump information for unpublished event
921  */
922 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_0900, Function | MediumTest | Level1)
923 {
924     /* Subscribe */
925     MatchingSkills matchingSkills;
926     matchingSkills.AddEvent(EVENT);
927 
928     CommonEventSubscribeInfo subscribeInfo(matchingSkills);
929 
930     struct tm curTime {0};
931     OHOS::Security::AccessToken::AccessTokenID tokenID = 1;
932 
933     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
934     CommonEventListener *listener = new CommonEventListener(subscriber);
935     GetInnerCommonEventManager()->SubscribeCommonEvent(
936         subscribeInfo, listener->AsObject(), curTime, PID, SYSTEM_UID, tokenID, "hello");
937 
938     usleep(50000);
939 
940     std::vector<std::string> state;
941     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), EVENT3, ALL_USER, state);
942     GTEST_LOG_(INFO) << "get state size:" << state.size();
943     ASSERT_NE(state.size(), 0);
944     DumpInfoCount(state, 0, 0, 0, 0);
945     EXPECT_EQ("Subscribers:\tNo information", state[0]);
946     EXPECT_EQ("Sticky Events:\tNo information", state[STATE_INDEX1]);
947 
948     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener->AsObject());
949 }
950 
951 /*
952  * @tc.number: CommonEventDumpTest_1000
953  * @tc.name: test dump
954  * @tc.desc: Verify dump information for specified event
955  */
956 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_1000, TestSize.Level1)
957 {
958     /* Subscribe */
959     CommonEventListener *listener = nullptr;
960     CommonEventListener *listener2 = nullptr;
961     SubscribeDoubleEvent(PRIORITY, PERMISSION, DEVICEDID, listener);
962     SubscribeDoubleEvent(PRIORITY2, PERMISSION2, DEVICEDID2, listener2);
963     EXPECT_NE(nullptr, listener);
964     EXPECT_NE(nullptr, listener2);
965 
966     /* Publish */
967     PublishStickyEvent(EVENT, TYPE, FLAG, PERMISSION);
968     PublishStickyEvent(EVENT2, TYPE2, FLAG2, PERMISSION2);
969 
970     usleep(50000);
971 
972     std::vector<std::string> state;
973     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), EVENT2, ALL_USER, state);
974     GTEST_LOG_(INFO) << "get state size:" << state.size();
975     DumpInfoCount(state, DUMP_SUBSCRIBER_COUNT_TWO, DUMP_STICKY_COUNT_ONE, 0, DUMP_HISTORY_COUNT_THREE);
976 
977     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener->AsObject());
978     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener2->AsObject());
979 }
980 
981 /*
982  * @tc.number: CommonEventDumpTest_1100
983  * @tc.name: test dump
984  * @tc.desc: Verify dump information for sticky event
985  */
986 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_1100, Function | MediumTest | Level1)
987 {
988     /* Publish */
989     PublishStickyEvent(EVENT, TYPE, FLAG, PERMISSION);
990 
991     usleep(50000);
992 
993     std::vector<std::string> state;
994     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), "", ALL_USER, state);
995     GTEST_LOG_(INFO) << "get state size:" << state.size();
996     DumpInfoCount(state, 0, DUMP_STICKY_COUNT_TWO, 0, DUMP_HISTORY_COUNT_ONE);
997 }
998 
999 /*
1000  * @tc.number: CommonEventDumpTest_1200
1001  * @tc.name: test dump
1002  * @tc.desc: Verify dump information for sticky event
1003  */
1004 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_1200, Function | MediumTest | Level1)
1005 {
1006     /* Publish */
1007     PublishStickyEvent(EVENT, "", FLAG, PERMISSION);
1008 
1009     usleep(50000);
1010 
1011     std::vector<std::string> state;
1012     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), "", ALL_USER, state);
1013     GTEST_LOG_(INFO) << "get state size:" << state.size();
1014     DumpInfoCount(state, 0, DUMP_STICKY_COUNT_TWO, 0, DUMP_HISTORY_COUNT_ONE);
1015 }
1016 
1017 /*
1018  * @tc.number: CommonEventDumpTest_1300
1019  * @tc.name: test dump
1020  * @tc.desc: Verify dump information for sticky event
1021  */
1022 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_1300, Function | MediumTest | Level1)
1023 {
1024     /* Publish */
1025     PublishStickyEvent(EVENT, "", 0, PERMISSION);
1026 
1027     usleep(50000);
1028 
1029     std::vector<std::string> state;
1030     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), "", ALL_USER, state);
1031     GTEST_LOG_(INFO) << "get state size:" << state.size();
1032     DumpInfoCount(state, 0, DUMP_STICKY_COUNT_TWO, 0, DUMP_HISTORY_COUNT_ONE);
1033 }
1034 
1035 /*
1036  * @tc.number: CommonEventDumpTest_1400
1037  * @tc.name: test dump
1038  * @tc.desc: Verify dump information for sticky event
1039  */
1040 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_1400, Function | MediumTest | Level1)
1041 {
1042     /* Publish */
1043     PublishStickyEvent(EVENT, "", 0, PERMISSION);
1044 
1045     usleep(50000);
1046 
1047     std::vector<std::string> state;
1048     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), "", ALL_USER, state);
1049     GTEST_LOG_(INFO) << "get state size:" << state.size();
1050     DumpInfoCount(state, 0, DUMP_STICKY_COUNT_TWO, 0, DUMP_HISTORY_COUNT_ONE);
1051 }
1052 
1053 /*
1054  * @tc.number: CommonEventDumpTest_1500
1055  * @tc.name: test dump
1056  * @tc.desc: Verify dump information for sticky event
1057  */
1058 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_1500, Function | MediumTest | Level1)
1059 {
1060     /* Publish */
1061     PublishStickyEvent(EVENT, "", 0, PERMISSION);
1062 
1063     usleep(50000);
1064 
1065     std::vector<std::string> state;
1066     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), "", ALL_USER, state);
1067     GTEST_LOG_(INFO) << "get state size:" << state.size();
1068     DumpInfoCount(state, 0, DUMP_STICKY_COUNT_TWO, 0, DUMP_HISTORY_COUNT_ONE);
1069 }
1070 
1071 /*
1072  * @tc.number: CommonEventDumpTest_1600
1073  * @tc.name: test dump
1074  * @tc.desc: Verify dump information for sticky event
1075  */
1076 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_1600, Function | MediumTest | Level1)
1077 {
1078     /* Publish */
1079     // make a want
1080     Want want;
1081     want.SetAction(EVENT);
1082     // make common event data
1083     CommonEventData data;
1084     data.SetWant(want);
1085 
1086     // make publish info
1087     CommonEventPublishInfo publishInfo;
1088     publishInfo.SetSticky(true);
1089 
1090     std::vector<std::string> permissions;
1091     permissions.emplace_back(PERMISSION);
1092     publishInfo.SetSubscriberPermissions(permissions);
1093 
1094     struct tm curTime {0};
1095     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1096 
1097     GetInnerCommonEventManager()->PublishCommonEvent(
1098         data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "hello");
1099 
1100     usleep(50000);
1101 
1102     std::vector<std::string> state;
1103     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), "", ALL_USER, state);
1104     GTEST_LOG_(INFO) << "get state size:" << state.size();
1105     DumpInfoCount(state, 0, DUMP_STICKY_COUNT_TWO, 0, DUMP_HISTORY_COUNT_ONE);
1106 }
1107 
1108 /*
1109  * @tc.number: CommonEventDumpTest_1700
1110  * @tc.name: test dump
1111  * @tc.desc: Verify dump information for sticky event
1112  */
1113 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_1700, Function | MediumTest | Level1)
1114 {
1115     /* Publish */
1116     // make a want
1117     Want want;
1118     want.SetAction(EVENT);
1119     // make common event data
1120     CommonEventData data;
1121     data.SetWant(want);
1122 
1123     // make publish info
1124     CommonEventPublishInfo publishInfo;
1125     publishInfo.SetSticky(true);
1126 
1127     struct tm curTime {0};
1128     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1129 
1130     GetInnerCommonEventManager()->PublishCommonEvent(
1131         data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "hello");
1132 
1133     usleep(50000);
1134 
1135     std::vector<std::string> state;
1136     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), "", ALL_USER, state);
1137     GTEST_LOG_(INFO) << "get state size:" << state.size();
1138     DumpInfoCount(state, 0, DUMP_STICKY_COUNT_TWO, 0, DUMP_HISTORY_COUNT_ONE);
1139 }
1140 
1141 /*
1142  * @tc.number: CommonEventDumpTest_1800
1143  * @tc.name: test dump
1144  * @tc.desc: Verify dump information when the pending ordered event is empty
1145  */
1146 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_1800, TestSize.Level1)
1147 {
1148     std::vector<std::string> state;
1149     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), "", ALL_USER, state);
1150     ASSERT_NE(state.size(), 0);
1151     DumpInfoCount(state, 0, DUMP_STICKY_COUNT_TWO, 0, 0);
1152     EXPECT_EQ("Pending Events:\tNo information", state[STATE_INDEX3]);
1153 }
1154 
1155 /*
1156  * @tc.number: CommonEventDumpTest_1900
1157  * @tc.name: test dump
1158  * @tc.desc: Verify dump information for ordered event
1159  */
1160 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_1900, TestSize.Level1)
1161 {
1162     /* Subscribe */
1163     // make matching skills
1164     MatchingSkills matchingSkills;
1165     matchingSkills.AddEvent(EVENTCASE1);
1166     matchingSkills.AddEntity(ENTITY);
1167     matchingSkills.AddEntity(ENTITY2);
1168     // make subscriber info
1169     CommonEventSubscribeInfo subscribeInfo(matchingSkills);
1170     subscribeInfo.SetPriority(1);
1171     subscribeInfo.SetDeviceId(DEVICEDID);
1172     // make a subscriber object
1173     std::shared_ptr<SubscriberTest> subscriberTest =
1174         std::make_shared<SubscriberTest>(subscribeInfo, GetInnerCommonEventManager());
1175     // subscribe a common event
1176     EXPECT_TRUE(SubscribeCommonEvent(subscriberTest, UID, commonEventListener));
1177     usleep(50000);
1178 
1179     // make another subscriber info
1180     CommonEventSubscribeInfo subscribeInfo2(matchingSkills);
1181     subscribeInfo2.SetPriority(0);
1182     subscribeInfo2.SetDeviceId(DEVICEDID2);
1183     // make another subscriber object
1184     std::shared_ptr<SubscriberTest2> subscriberTest2 =
1185         std::make_shared<SubscriberTest2>(subscribeInfo2, GetInnerCommonEventManager());
1186     // subscribe another event
1187     EXPECT_TRUE(SubscribeCommonEvent(subscriberTest2, UID2, commonEventListener2));
1188     usleep(50000);
1189 
1190     std::shared_ptr<SubscriberTestLast> subscriber = std::make_shared<SubscriberTestLast>();
1191 
1192     /* Publish */
1193     CommonEventData data;
1194     CommonEventPublishInfo publishInfo;
1195     SetPublishDataByOrdered(data, publishInfo);
1196 
1197     // publish order event
1198     EXPECT_TRUE(PublishCommonEvent(data, publishInfo, subscriber, commonEventListener3));
1199 
1200     usleep(500000);
1201 
1202     std::vector<std::string> state;
1203     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), "", ALL_USER, state);
1204     DumpInfoCount(state, DUMP_SUBSCRIBER_COUNT_TWO, DUMP_STICKY_COUNT_TWO, 0, DUMP_HISTORY_COUNT_ONE);
1205 
1206     GetInnerCommonEventManager()->UnsubscribeCommonEvent(commonEventListener);
1207     GetInnerCommonEventManager()->UnsubscribeCommonEvent(commonEventListener2);
1208 }
1209 /*
1210  * @tc.number: CommonEventDumpTest_2000
1211  * @tc.name: test dump
1212  * @tc.desc: Verify dump information for maximum number of history events
1213  */
1214 HWTEST_F(CommonEventDumpTest, CommonEventDumpTest_2000, TestSize.Level1)
1215 {
1216     /* Subscribe */
1217     // make matching skills
1218     MatchingSkills matchingSkills;
1219     matchingSkills.AddEvent(EVENTCASE2);
1220     matchingSkills.AddEntity(ENTITY);
1221     matchingSkills.AddEntity(ENTITY2);
1222 
1223     // make subscriber info
1224     CommonEventSubscribeInfo subscribeInfo(matchingSkills);
1225     subscribeInfo.SetPriority(1);
1226     subscribeInfo.SetDeviceId(DEVICEDID);
1227     // make a subscriber object
1228     std::shared_ptr<SubscriberTest> subscriberTest =
1229         std::make_shared<SubscriberTest>(subscribeInfo, GetInnerCommonEventManager());
1230     // subscribe a common event
1231     EXPECT_TRUE(SubscribeCommonEvent(subscriberTest, UID, commonEventListener));
1232     usleep(50000);
1233 
1234     // make another subscriber info
1235     CommonEventSubscribeInfo subscribeInfo2(matchingSkills);
1236     subscribeInfo2.SetPriority(0);
1237     subscribeInfo2.SetDeviceId(DEVICEDID2);
1238     // make another subscriber object
1239     std::shared_ptr<SubscriberTest2> subscriberTest2 =
1240         std::make_shared<SubscriberTest2>(subscribeInfo2, GetInnerCommonEventManager());
1241     // subscribe another event
1242     EXPECT_TRUE(SubscribeCommonEvent(subscriberTest2, UID2, commonEventListener2));
1243     usleep(50000);
1244 
1245     std::shared_ptr<SubscriberTestLast> subscriber = std::make_shared<SubscriberTestLast>();
1246 
1247     /* Publish */
1248     CommonEventData data;
1249     CommonEventPublishInfo publishInfo;
1250 
1251     int count = 0;
1252     while (count < PUBLISH_COUNT) {
1253         // publish order event
1254         SetPublishDataByOrdered2(data, publishInfo);
1255         EXPECT_TRUE(PublishCommonEvent(data, publishInfo, subscriber, commonEventListener3));
1256         usleep(50000);
1257 
1258         // publish unorder event
1259         SetPublishDataByUnordered(data, publishInfo);
1260         EXPECT_TRUE(PublishCommonEvent(data, publishInfo, subscriber, commonEventListener3));
1261         usleep(50000);
1262         count++;
1263     }
1264     usleep(500000);
1265 
1266     std::vector<std::string> state;
1267     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::ALL), "", ALL_USER, state);
1268     DumpInfoCount(state, DUMP_STICKY_COUNT_TWO, DUMP_STICKY_COUNT_TWO, 0, DUMP_HISTORY_COUNT_MAX);
1269 
1270     GetInnerCommonEventManager()->UnsubscribeCommonEvent(commonEventListener);
1271     GetInnerCommonEventManager()->UnsubscribeCommonEvent(commonEventListener2);
1272 }
1273 
1274 /*
1275  * @tc.number: CommonEventDumpPartEventTest_0100
1276  * @tc.name: test dump
1277  * @tc.desc: Verify dump all subscriber
1278  * @tc.require: I582WG
1279  */
1280 HWTEST_F(CommonEventDumpTest, CommonEventDumpPartEventTest_0100, Function | MediumTest | Level1)
1281 {
1282     /* Subscribe */
1283     CommonEventListener *listener = nullptr;
1284     CommonEventListener *listener2 = nullptr;
1285     SubscribeDoubleEvent(PRIORITY, PERMISSION, DEVICEDID, listener);
1286     SubscribeDoubleEvent(PRIORITY2, PERMISSION2, DEVICEDID2, listener2);
1287     EXPECT_NE(nullptr, listener);
1288     EXPECT_NE(nullptr, listener2);
1289 
1290     usleep(50000);
1291 
1292     std::vector<std::string> state;
1293     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::SUBSCRIBER), "", ALL_USER, state);
1294     GTEST_LOG_(INFO) << "get state size:" << state.size();
1295     ASSERT_EQ(state.size(), DUMP_SUBSCRIBER_COUNT_TWO);
1296     auto pos = state[0].find("Subscribers:");
1297     ASSERT_NE(pos, string::npos);
1298 
1299     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener->AsObject());
1300     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener2->AsObject());
1301 }
1302 
1303 /*
1304  * @tc.number: CommonEventDumpPartEventTest_0200
1305  * @tc.name: test dump
1306  * @tc.desc: Verify dump information after publishing sticky events
1307  * @tc.require: I582WG
1308  */
1309 HWTEST_F(CommonEventDumpTest, CommonEventDumpPartEventTest_0200, Function | MediumTest | Level1)
1310 {
1311     /* Subscribe */
1312     CommonEventListener *listener = nullptr;
1313     CommonEventListener *listener2 = nullptr;
1314     SubscribeDoubleEvent(PRIORITY, PERMISSION, DEVICEDID, listener);
1315     SubscribeDoubleEvent(PRIORITY2, PERMISSION2, DEVICEDID2, listener2);
1316     EXPECT_NE(nullptr, listener);
1317     EXPECT_NE(nullptr, listener2);
1318 
1319     /* Publish */
1320     PublishStickyEvent(EVENT, TYPE, CODE, DATA, PERMISSION);
1321     PublishStickyEvent(EVENT2, TYPE2, CODE2, DATA2, PERMISSION2);
1322 
1323     usleep(50000);
1324 
1325     std::vector<std::string> state;
1326     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::STICKY), "", ALL_USER, state);
1327     GTEST_LOG_(INFO) << "get state size:" << state.size();
1328     ASSERT_EQ(state.size(), DUMP_STICKY_COUNT_TWO);
1329     auto pos = state[0].find("Sticky Events:");
1330     ASSERT_NE(pos, string::npos);
1331 
1332     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener->AsObject());
1333     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener2->AsObject());
1334 }
1335 
1336 /*
1337  * @tc.number: CommonEventDumpPartEventTest_0300
1338  * @tc.name: test dump
1339  * @tc.desc: Verify dump pending events
1340  * @tc.require: I582WG
1341  */
1342 HWTEST_F(CommonEventDumpTest, CommonEventDumpPartEventTest_0300, Function | MediumTest | Level1)
1343 {
1344     /* Subscribe */
1345     CommonEventListener *listener = nullptr;
1346     CommonEventListener *listener2 = nullptr;
1347     SubscribeDoubleEvent(PRIORITY, PERMISSION, DEVICEDID, listener);
1348     SubscribeDoubleEvent(PRIORITY2, PERMISSION2, DEVICEDID2, listener2);
1349     EXPECT_NE(nullptr, listener);
1350     EXPECT_NE(nullptr, listener2);
1351 
1352     /* Publish */
1353     PublishUnorderedEvent(EVENT, TYPE, CODE, DATA, PERMISSION);
1354     PublishUnorderedEvent(EVENT2, TYPE2, CODE2, DATA2, PERMISSION2);
1355 
1356     usleep(50000);
1357 
1358     std::vector<std::string> state;
1359     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::PENDING), "", ALL_USER, state);
1360     GTEST_LOG_(INFO) << "get state size:" << state.size();
1361     ASSERT_EQ(state.size(), 1);
1362     EXPECT_EQ("Pending Events:\tNo information", state[0]);
1363 
1364     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener->AsObject());
1365     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener2->AsObject());
1366 }
1367 
1368 /*
1369  * @tc.number: CommonEventDumpPartEventTest_0400
1370  * @tc.name: test dump
1371  * @tc.desc: Verify dump information after publishing unordered events
1372  * @tc.require: I582WG
1373  */
1374 HWTEST_F(CommonEventDumpTest, CommonEventDumpPartEventTest_0400, Function | MediumTest | Level1)
1375 {
1376     /* Subscribe */
1377     CommonEventListener *listener = nullptr;
1378     CommonEventListener *listener2 = nullptr;
1379     SubscribeDoubleEvent(PRIORITY, PERMISSION, DEVICEDID, listener);
1380     SubscribeDoubleEvent(PRIORITY2, PERMISSION2, DEVICEDID2, listener2);
1381     EXPECT_NE(nullptr, listener);
1382     EXPECT_NE(nullptr, listener2);
1383 
1384     /* Publish */
1385     PublishUnorderedEvent(EVENT, TYPE, CODE, DATA, PERMISSION);
1386     PublishUnorderedEvent(EVENT2, TYPE2, CODE2, DATA2, PERMISSION2);
1387 
1388     usleep(50000);
1389 
1390     std::vector<std::string> state;
1391     GetInnerCommonEventManager()->DumpState(static_cast<int32_t>(DumpEventType::HISTORY), "", ALL_USER, state);
1392     GTEST_LOG_(INFO) << "get state size:" << state.size();
1393     ASSERT_EQ(state.size(), DUMP_HISTORY_COUNT_TWO * 3);
1394     auto pos = state[0].find("History Events:");
1395     ASSERT_NE(pos, string::npos);
1396 
1397     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener->AsObject());
1398     GetInnerCommonEventManager()->UnsubscribeCommonEvent(listener2->AsObject());
1399 }
1400 }  // namespace
1401