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