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 // redefine private and protected since testcase need to invoke and test private function
19 #define private public
20 #define protected public
21 #include "bundle_manager_helper.h"
22 #include "common_event_control_manager.h"
23 #undef private
24 #undef protected
25 
26 #include "common_event_listener.h"
27 #include "common_event_permission_manager.h"
28 #include "common_event_record.h"
29 #include "inner_common_event_manager.h"
30 #include "mock_bundle_manager.h"
31 
32 using namespace testing::ext;
33 using namespace OHOS;
34 using namespace OHOS::EventFwk;
35 using namespace OHOS::AppExecFwk;
36 
37 namespace {
38 const std::string EVENT = "com.ces.test.event";
39 const std::string ENTITY = "com.ces.test.entity";
40 constexpr uint8_t PUBLISH_SLEEP = 1;
41 constexpr uint8_t PID = 0;
42 constexpr uint16_t SYSTEM_UID = 1000;
43 }  // namespace
44 
45 static OHOS::sptr<OHOS::IRemoteObject> bundleObject = nullptr;
46 
47 class CommonEventPublishPermissionEventUnitTest : public testing::Test {
48 public:
CommonEventPublishPermissionEventUnitTest()49     CommonEventPublishPermissionEventUnitTest()
50     {}
~CommonEventPublishPermissionEventUnitTest()51     ~CommonEventPublishPermissionEventUnitTest()
52     {}
53     static void SetUpTestCase(void);
54     static void TearDownTestCase(void);
55     void SetUp();
56     void TearDown();
57 };
58 
59 class SubscriberTest : public CommonEventSubscriber {
60 public:
SubscriberTest(const CommonEventSubscribeInfo & sp)61     explicit SubscriberTest(const CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp)
62     {}
63 
~SubscriberTest()64     ~SubscriberTest()
65     {}
66 
OnReceiveEvent(const CommonEventData & data)67     virtual void OnReceiveEvent(const CommonEventData &data)
68     {}
69 };
70 
71 class SubscriberTest1 : public CommonEventSubscriber {
72 public:
SubscriberTest1(const CommonEventSubscribeInfo & sp)73     explicit SubscriberTest1(const CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp)
74     {}
75 
~SubscriberTest1()76     ~SubscriberTest1()
77     {}
78 
OnReceiveEvent(const CommonEventData & data)79     virtual void OnReceiveEvent(const CommonEventData &data)
80     {}
81 };
82 
SetUpTestCase(void)83 void CommonEventPublishPermissionEventUnitTest::SetUpTestCase(void)
84 {
85     bundleObject = new MockBundleMgrService();
86     OHOS::DelayedSingleton<BundleManagerHelper>::GetInstance()->sptrBundleMgr_ =
87         OHOS::iface_cast<OHOS::AppExecFwk::IBundleMgr>(bundleObject);
88 }
89 
TearDownTestCase(void)90 void CommonEventPublishPermissionEventUnitTest::TearDownTestCase(void)
91 {}
92 
SetUp(void)93 void CommonEventPublishPermissionEventUnitTest::SetUp(void)
94 {}
95 
TearDown(void)96 void CommonEventPublishPermissionEventUnitTest::TearDown(void)
97 {}
98 
99 /*
100  * @tc.number: CommonEventPublishPermissionEventUnitTest_0100
101  * @tc.name: test unordered event permission
102  * @tc.desc: 1. subscriber permission is not empty
103  *           2. publish permission is not empty
104  */
105 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0100,
106     Function | MediumTest | Level1)
107 {
108     GTEST_LOG_(INFO)
109         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0100, TestSize.Level1";
110     InnerCommonEventManager inner;
111     struct tm curTime {0};
112     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
113 
114     /* subscriber */
115     MatchingSkills matchingSkillsObj;
116     matchingSkillsObj.AddEvent("1234");
117     CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
118     subscribeInfo.SetPermission("123");
119     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
120     auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
121     inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "hello");
122 
123     /* Publish */
124     Want want;
125     want.SetAction("1234");
126     CommonEventData data;
127     data.SetWant(want);
128     std::vector<std::string> subscriberPermissions;
129     subscriberPermissions.emplace_back("456");
130     CommonEventPublishInfo publishInfo;
131     publishInfo.SetOrdered(false);
132     publishInfo.SetSubscriberPermissions(subscriberPermissions);
133     bool result = inner.PublishCommonEvent(
134         data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "hello");
135     sleep(PUBLISH_SLEEP);
136     EXPECT_TRUE(result);
137     inner.UnsubscribeCommonEvent(listener);
138 }
139 
140 /*
141  * @tc.number: CommonEventPublishPermissionEventUnitTest_0200
142  * @tc.name: test ordered event permission
143  * @tc.desc: 1. subscriber permission is not empty
144  *           2. publish permission is not empty
145  */
146 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0200,
147     Function | MediumTest | Level1)
148 {
149     GTEST_LOG_(INFO)
150         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0200, TestSize.Level1";
151     /* subscriber */
152     InnerCommonEventManager inner;
153     struct tm curTime {0};
154     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
155 
156     MatchingSkills matchingSkillsObj;
157     matchingSkillsObj.AddEvent("1234");
158     CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
159     subscribeInfo.SetPermission("123");
160     subscribeInfo.SetPriority(1);
161     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
162     auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
163     inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "hello");
164 
165     /* Publish */
166     Want want;
167     want.SetAction("1234");
168     CommonEventData data;
169     data.SetWant(want);
170 
171     CommonEventPublishInfo publishInfo;
172     std::vector<std::string> subscriberPermissions;
173     publishInfo.SetOrdered(true);
174     subscriberPermissions.emplace_back("456");
175     publishInfo.SetSubscriberPermissions(subscriberPermissions);
176     bool result = inner.PublishCommonEvent(
177         data, publishInfo, listener, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "hello");
178     sleep(PUBLISH_SLEEP);
179     EXPECT_TRUE(result);
180     inner.UnsubscribeCommonEvent(listener);
181 }
182 
183 /*
184  * @tc.number: CommonEventPublishPermissionEventUnitTest_0300
185  * @tc.name: test unordered event permission
186  * @tc.desc: 1. subscriber permission is empty
187  *           2. publish permission is not empty
188  */
189 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0300,
190     Function | MediumTest | Level1)
191 {
192     GTEST_LOG_(INFO)
193         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0300, TestSize.Level1";
194     /* subscriber */
195     InnerCommonEventManager inner;
196     struct tm curTime {0};
197     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
198 
199     MatchingSkills matchingSkillsObj;
200     matchingSkillsObj.AddEvent("1234");
201     CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
202     subscribeInfo.SetPermission("");
203     subscribeInfo.SetPriority(1);
204     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
205     auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
206     inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "hello");
207 
208     /* Publish */
209     Want want;
210     want.SetAction("1234");
211     CommonEventData data;
212     data.SetWant(want);
213 
214     CommonEventPublishInfo publishInfo;
215     std::vector<std::string> subscriberPermissions;
216     publishInfo.SetOrdered(false);
217     subscriberPermissions.emplace_back("456");
218     publishInfo.SetSubscriberPermissions(subscriberPermissions);
219     bool result = inner.PublishCommonEvent(
220         data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "hello");
221     sleep(PUBLISH_SLEEP);
222     EXPECT_TRUE(result);
223     inner.UnsubscribeCommonEvent(listener);
224 }
225 
226 /*
227  * @tc.number: CommonEventPublishPermissionEventUnitTest_0400
228  * @tc.name: test ordered event permission
229  * @tc.desc: 1. subscriber permission is empty
230  *           2. publish permission is not empty
231  */
232 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0400,
233     Function | MediumTest | Level1)
234 {
235     GTEST_LOG_(INFO)
236         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0400, TestSize.Level1";
237     /* subscriber */
238     InnerCommonEventManager inner;
239     struct tm curTime {0};
240     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
241 
242     MatchingSkills matchingSkillsObj;
243     matchingSkillsObj.AddEvent("1234");
244     CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
245     subscribeInfo.SetPermission("");
246     subscribeInfo.SetPriority(1);
247     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
248     auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
249     inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "hello");
250 
251     /* Publish */
252     Want want;
253     want.SetAction("1234");
254     CommonEventData data;
255     data.SetWant(want);
256 
257     CommonEventPublishInfo publishInfo;
258     std::vector<std::string> subscriberPermissions;
259     publishInfo.SetOrdered(true);
260     subscriberPermissions.emplace_back("456");
261     publishInfo.SetSubscriberPermissions(subscriberPermissions);
262     bool result = inner.PublishCommonEvent(
263         data, publishInfo, listener, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "hello");
264     sleep(PUBLISH_SLEEP);
265     EXPECT_TRUE(result);
266     inner.UnsubscribeCommonEvent(listener);
267 }
268 
269 /*
270  * @tc.number: CommonEventPublishPermissionEventUnitTest_0500
271  * @tc.name: test  CommonEventControlManager permission
272  * @tc.desc: 1. subscriber permission is empty
273  *           2. publish permission is empty
274  */
275 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0500,
276     Function | MediumTest | Level1)
277 {
278     GTEST_LOG_(INFO)
279         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0500, TestSize.Level1";
280 
281     CommonEventSubscribeInfo commonEventSubscribeInfo;
282     commonEventSubscribeInfo.SetPermission("");
283     std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
284         std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
285     EventSubscriberRecord eventSubRecord;
286     eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
287     eventSubRecord.eventRecordInfo.bundleName = "hello";
288 
289     CommonEventPublishInfo commonEventPublishInfo;
290     commonEventPublishInfo.SetSubscriberPermissions(std::vector<std::string>());
291     std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
292         std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
293 
294     Want want;
295     want.SetAction("1234");
296     std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
297     spCommonEventData->SetWant(want);
298 
299     CommonEventRecord commonEventRecord;
300     commonEventRecord.publishInfo = commonEventPublishInfoSptr;
301     commonEventRecord.eventRecordInfo.bundleName = "hello";
302     commonEventRecord.commonEventData = spCommonEventData;
303 
304     CommonEventControlManager commonEventControlManager;
305     int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
306     EXPECT_EQ(OrderedEventRecord::DELIVERED, ret);
307 }
308 
309 /*
310  * @tc.number: CommonEventPublishPermissionEventUnitTest_0600
311  * @tc.name: test  CommonEventControlManager permission
312  * @tc.desc: 1. subscriber permission is not empty
313  *           2. publish permission is empty
314  *           3. function CheckPermission return OrderedEventRecord::SKIPPED
315  */
316 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0600,
317     Function | MediumTest | Level1)
318 {
319     GTEST_LOG_(INFO)
320         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0600, TestSize.Level1";
321 
322     CommonEventSubscribeInfo commonEventSubscribeInfo;
323     commonEventSubscribeInfo.SetPermission("12345");
324     std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
325         std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
326     EventSubscriberRecord eventSubRecord;
327     eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
328     eventSubRecord.eventRecordInfo.bundleName = "hello";
329 
330     CommonEventPublishInfo commonEventPublishInfo;
331     commonEventPublishInfo.SetSubscriberPermissions(std::vector<std::string>());
332     std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
333         std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
334 
335     Want want;
336     want.SetAction("1234");
337     std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
338     spCommonEventData->SetWant(want);
339 
340     CommonEventRecord commonEventRecord;
341     commonEventRecord.publishInfo = commonEventPublishInfoSptr;
342     commonEventRecord.eventRecordInfo.bundleName = "hello world";
343     commonEventRecord.eventRecordInfo.callerToken = 1;
344     commonEventRecord.commonEventData = spCommonEventData;
345 
346     CommonEventControlManager commonEventControlManager;
347     int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
348     EXPECT_EQ(OrderedEventRecord::OrderedEventRecord::DELIVERED, ret);
349 }
350 
351 /*
352  * @tc.number: CommonEventPublishPermissionEventUnitTest_0700
353  * @tc.name: test  CommonEventControlManager permission
354  * @tc.desc: 1. subscriber permission is not empty
355  *           2. publish permission is empty
356  *           3. function CheckPermission return OrderedEventRecord::DELIVERED
357  */
358 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0700,
359     Function | MediumTest | Level1)
360 {
361     GTEST_LOG_(INFO)
362         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0700, TestSize.Level1";
363 
364     CommonEventSubscribeInfo commonEventSubscribeInfo;
365     commonEventSubscribeInfo.SetPermission("12345");
366     std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
367         std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
368     EventSubscriberRecord eventSubRecord;
369     eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
370 
371     CommonEventPublishInfo commonEventPublishInfo;
372     commonEventPublishInfo.SetSubscriberPermissions(std::vector<std::string>());
373     std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
374         std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
375 
376     Want want;
377     want.SetAction("1234");
378     std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
379     spCommonEventData->SetWant(want);
380     CommonEventRecord commonEventRecord;
381     commonEventRecord.publishInfo = commonEventPublishInfoSptr;
382     commonEventRecord.commonEventData = spCommonEventData;
383 
384     CommonEventControlManager commonEventControlManager;
385     int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
386     EXPECT_EQ(OrderedEventRecord::DELIVERED, ret);
387 }
388 
389 /*
390  * @tc.number: CommonEventPublishPermissionEventUnitTest_0800
391  * @tc.name: test  CommonEventControlManager permission
392  * @tc.desc: 1. subscriber permission is empty
393  *           2. publish permission is not empty
394  *           3. function CheckPermission return OrderedEventRecord::DELIVERED
395  */
396 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0800,
397     Function | MediumTest | Level1)
398 {
399     GTEST_LOG_(INFO)
400         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0800, TestSize.Level1";
401 
402     CommonEventSubscribeInfo commonEventSubscribeInfo;
403     commonEventSubscribeInfo.SetPermission("");
404     std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
405         std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
406     EventSubscriberRecord eventSubRecord;
407     eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
408 
409     CommonEventPublishInfo commonEventPublishInfo;
410     std::vector<std::string> vecstr;
411     vecstr.emplace_back("456");
412     commonEventPublishInfo.SetSubscriberPermissions(vecstr);
413     std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
414         std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
415     Want want;
416     want.SetAction("1234");
417     std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
418     spCommonEventData->SetWant(want);
419     CommonEventRecord commonEventRecord;
420     commonEventRecord.publishInfo = commonEventPublishInfoSptr;
421     commonEventRecord.commonEventData = spCommonEventData;
422 
423     CommonEventControlManager commonEventControlManager;
424     int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
425     EXPECT_EQ(OrderedEventRecord::DELIVERED, ret);
426     bool result = commonEventControlManager.NotifyFreezeEvents(eventSubRecord, commonEventRecord);
427     EXPECT_EQ(false, result);
428 }
429 
430 /*
431  * @tc.number: CommonEventPublishPermissionEventUnitTest_0900
432  * @tc.name: test  CommonEventControlManager permission
433  * @tc.desc: 1. subscriber permission is empty
434  *           2. publish permission is not empty
435  *           3. function CheckPermission return OrderedEventRecord::SKIPPED
436  */
437 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0900,
438     Function | MediumTest | Level1)
439 {
440     GTEST_LOG_(INFO)
441         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0900, TestSize.Level1";
442 
443     CommonEventSubscribeInfo commonEventSubscribeInfo;
444     commonEventSubscribeInfo.SetPermission("");
445     std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
446         std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
447     EventSubscriberRecord eventSubRecord;
448     eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
449     eventSubRecord.eventRecordInfo.bundleName = "hello world";
450     eventSubRecord.eventRecordInfo.callerToken = 1;
451 
452     CommonEventPublishInfo commonEventPublishInfo;
453     std::vector<std::string> vecstr;
454     vecstr.emplace_back("456");
455     commonEventPublishInfo.SetSubscriberPermissions(vecstr);
456     std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
457         std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
458     Want want;
459     want.SetAction("1234");
460     std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
461     spCommonEventData->SetWant(want);
462     CommonEventRecord commonEventRecord;
463     commonEventRecord.publishInfo = commonEventPublishInfoSptr;
464     commonEventRecord.commonEventData = spCommonEventData;
465 
466     CommonEventControlManager commonEventControlManager;
467     int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
468     EXPECT_EQ(OrderedEventRecord::OrderedEventRecord::DELIVERED, ret);
469 
470     bool result = commonEventControlManager.NotifyFreezeEvents(eventSubRecord, commonEventRecord);
471     EXPECT_EQ(false, result);
472 }
473 
474 /*
475  * @tc.number: CommonEventPublishPermissionEventUnitTest_1000
476  * @tc.name: test  CommonEventControlManager permission
477  * @tc.desc: 1. subscriber permission is not empty
478  *           2. publish permission is not empty
479  *           3. function subscriber CheckPermission return OrderedEventRecord::DELIVERED
480  */
481 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1000,
482     Function | MediumTest | Level1)
483 {
484     GTEST_LOG_(INFO)
485         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1000, TestSize.Level1";
486 
487     CommonEventSubscribeInfo commonEventSubscribeInfo;
488     commonEventSubscribeInfo.SetPermission("12345");
489     std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
490         std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
491     EventSubscriberRecord eventSubRecord;
492     eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
493 
494     CommonEventPublishInfo commonEventPublishInfo;
495     std::vector<std::string> vecstr;
496     vecstr.emplace_back("456");
497     commonEventPublishInfo.SetSubscriberPermissions(vecstr);
498     std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
499         std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
500 
501     Want want;
502     want.SetAction("1234");
503     std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
504     spCommonEventData->SetWant(want);
505     CommonEventRecord commonEventRecord;
506     commonEventRecord.publishInfo = commonEventPublishInfoSptr;
507     commonEventRecord.commonEventData = spCommonEventData;
508 
509     CommonEventControlManager commonEventControlManager;
510     int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
511     EXPECT_EQ(OrderedEventRecord::DELIVERED, ret);
512 }
513 
514 /*
515  * @tc.number: CommonEventPublishPermissionEventUnitTest_1100
516  * @tc.name: test  CommonEventControlManager permission
517  * @tc.desc: 1. subscriber permission is not empty
518  *           2. publish permission is not empty
519  *           3. function subscriber CheckPermission return OrderedEventRecord::SKIPPED
520  */
521 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1100,
522     Function | MediumTest | Level1)
523 {
524     GTEST_LOG_(INFO)
525         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1100, TestSize.Level1";
526 
527     CommonEventSubscribeInfo commonEventSubscribeInfo;
528     commonEventSubscribeInfo.SetPermission("12345");
529     std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
530         std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
531     EventSubscriberRecord eventSubRecord;
532     eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
533     eventSubRecord.eventRecordInfo.bundleName = "hello world";
534     eventSubRecord.eventRecordInfo.callerToken = 1;
535 
536     CommonEventPublishInfo commonEventPublishInfo;
537     std::vector<std::string> vecstr;
538     vecstr.emplace_back("456");
539     commonEventPublishInfo.SetSubscriberPermissions(vecstr);
540     std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
541         std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
542 
543     Want want;
544     want.SetAction("1234");
545     std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
546     spCommonEventData->SetWant(want);
547     CommonEventRecord commonEventRecord;
548     commonEventRecord.publishInfo = commonEventPublishInfoSptr;
549     commonEventRecord.eventRecordInfo.bundleName = "hello";
550     commonEventRecord.eventRecordInfo.callerToken = 1;
551     commonEventRecord.commonEventData = spCommonEventData;
552 
553     CommonEventControlManager commonEventControlManager;
554     int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
555     EXPECT_EQ(OrderedEventRecord::OrderedEventRecord::DELIVERED, ret);
556 }
557 
558 /*
559  * @tc.number: CommonEventPublishPermissionEventUnitTest_1200
560  * @tc.name: test  CommonEventControlManager permission
561  * @tc.desc: 1. subscriber permission is not empty
562  *           2. publish permission is not empty
563  *           3. function subscriber CheckPermission return OrderedEventRecord::SKIPPED
564  */
565 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1200,
566     Function | MediumTest | Level1)
567 {
568     GTEST_LOG_(INFO)
569         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1200, TestSize.Level1";
570 
571     CommonEventSubscribeInfo commonEventSubscribeInfo;
572     commonEventSubscribeInfo.SetPermission("12345");
573     std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
574         std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
575     EventSubscriberRecord eventSubRecord;
576     eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
577     eventSubRecord.eventRecordInfo.bundleName = "hello";
578     eventSubRecord.eventRecordInfo.callerToken = 1;
579 
580     CommonEventPublishInfo commonEventPublishInfo;
581     std::vector<std::string> vecstr;
582     vecstr.emplace_back("456");
583     commonEventPublishInfo.SetSubscriberPermissions(vecstr);
584     std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
585         std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
586 
587     Want want;
588     want.SetAction("1234");
589     std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
590     spCommonEventData->SetWant(want);
591     CommonEventRecord commonEventRecord;
592     commonEventRecord.publishInfo = commonEventPublishInfoSptr;
593     commonEventRecord.eventRecordInfo.bundleName = "hello world";
594     commonEventRecord.commonEventData = spCommonEventData;
595     commonEventRecord.eventRecordInfo.callerToken = 1;
596 
597     CommonEventControlManager commonEventControlManager;
598     int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
599     EXPECT_EQ(OrderedEventRecord::OrderedEventRecord::DELIVERED, ret);
600 }
601 
602 /*
603  * @tc.number: CommonEventPublishPermissionEventUnitTest_1300
604  * @tc.name: test  CommonEventControlManager permission
605  * @tc.desc: 1. subscriber permission is not empty
606  *           2. publish permission is not empty
607  *           3. function subscriber CheckPermission return OrderedEventRecord::SKIPPED
608  */
609 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1300,
610     Function | MediumTest | Level1)
611 {
612     GTEST_LOG_(INFO)
613         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1300, TestSize.Level1";
614 
615     CommonEventSubscribeInfo commonEventSubscribeInfo;
616     commonEventSubscribeInfo.SetPermission("12345");
617     std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
618         std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
619     EventSubscriberRecord eventSubRecord;
620     eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
621     eventSubRecord.eventRecordInfo.bundleName = "hello world";
622     eventSubRecord.eventRecordInfo.callerToken = 1;
623 
624     CommonEventPublishInfo commonEventPublishInfo;
625     std::vector<std::string> vecstr;
626     vecstr.emplace_back("456");
627     commonEventPublishInfo.SetSubscriberPermissions(vecstr);
628     std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
629         std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
630 
631     Want want;
632     want.SetAction("1234");
633     std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
634     spCommonEventData->SetWant(want);
635     CommonEventRecord commonEventRecord;
636     commonEventRecord.publishInfo = commonEventPublishInfoSptr;
637     commonEventRecord.eventRecordInfo.bundleName = "hello world";
638     commonEventRecord.commonEventData = spCommonEventData;
639     commonEventRecord.eventRecordInfo.callerToken = 1;
640 
641     CommonEventControlManager commonEventControlManager;
642     int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
643     EXPECT_EQ(OrderedEventRecord::OrderedEventRecord::DELIVERED, ret);
644 }
645 
646 /*
647  * @tc.number: CommonEventPublishPermissionEventUnitTest_1500
648  * @tc.name: test  InnerCommonEventManager permission
649  * @tc.desc: function CheckPermission return false
650  */
651 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1500,
652     Function | MediumTest | Level1)
653 {
654     GTEST_LOG_(INFO)
655         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1500, TestSize.Level1";
656 
657     InnerCommonEventManager inner;
658     struct tm curTime {0};
659     OHOS::Security::AccessToken::AccessTokenID tokenID = 1;
660 
661     Want want;
662     want.SetAction("1234");
663     CommonEventData data;
664     data.SetWant(want);
665     CommonEventPublishInfo publishInfo;
666     publishInfo.SetOrdered(true);
667     publishInfo.SetSticky(true);
668     EXPECT_FALSE(inner.PublishCommonEvent(
669         data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "hello world"));
670 }
671 
672 /*
673  * @tc.number: CommonEventPublishPermissionEventUnitTest_1600
674  * @tc.name: test  InnerCommonEventManager permission
675  * @tc.desc: function CheckPermission return false
676  */
677 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1600,
678     Function | MediumTest | Level1)
679 {
680     GTEST_LOG_(INFO)
681         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1600, TestSize.Level1";
682 
683     CommonEventSubscribeInfo commonEventSubscribeInfo;
684     commonEventSubscribeInfo.SetPermission("ohos.permission.GET_WIFI_INFO");
685     std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
686         std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
687     EventSubscriberRecord eventSubRecord;
688     eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
689     eventSubRecord.eventRecordInfo.callerToken = 1;
690 
691     CommonEventPublishInfo commonEventPublishInfo;
692     std::vector<std::string> vecstr;
693     vecstr.emplace_back("456");
694     commonEventPublishInfo.SetSubscriberPermissions(vecstr);
695     std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
696         std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
697 
698     Want want;
699     want.SetAction("COMMON_EVENT_WIFI_AP_STA_JOIN");
700     std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
701     spCommonEventData->SetWant(want);
702     CommonEventRecord commonEventRecord;
703     commonEventRecord.publishInfo = commonEventPublishInfoSptr;
704     commonEventRecord.eventRecordInfo.callerToken = 1;
705     commonEventRecord.commonEventData = spCommonEventData;
706 
707     CommonEventControlManager commonEventControlManager;
708     int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
709     EXPECT_EQ(OrderedEventRecord::DELIVERED, ret);
710 }
711 
712 /*
713  * @tc.number: CommonEventPublishPermissionEventUnitTest_1700
714  * @tc.name: test  InnerCommonEventManager permission
715  * @tc.desc: function CheckPermission return false
716  */
717 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1700,
718     Function | MediumTest | Level1)
719 {
720     GTEST_LOG_(INFO)
721         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1700, TestSize.Level1";
722 
723     CommonEventSubscribeInfo commonEventSubscribeInfo;
724     commonEventSubscribeInfo.SetPermission("1234");
725     std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
726         std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
727     EventSubscriberRecord eventSubRecord;
728     eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
729     eventSubRecord.eventRecordInfo.callerToken = 1;
730 
731     CommonEventPublishInfo commonEventPublishInfo;
732     std::vector<std::string> vecstr;
733     vecstr.emplace_back("456");
734     commonEventPublishInfo.SetSubscriberPermissions(vecstr);
735     std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
736         std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
737 
738     Want want;
739     want.SetAction("COMMON_EVENT_BLUETOOTH_REMOTEDEVICE_DISCOVERED");
740     std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
741     spCommonEventData->SetWant(want);
742     CommonEventRecord commonEventRecord;
743     commonEventRecord.publishInfo = commonEventPublishInfoSptr;
744     commonEventRecord.eventRecordInfo.callerToken = 1;
745     commonEventRecord.commonEventData = spCommonEventData;
746 
747     CommonEventControlManager commonEventControlManager;
748     int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
749     EXPECT_EQ(OrderedEventRecord::DELIVERED, ret);
750 }
751 
752 /*
753  * @tc.number: CommonEventPublishPermissionEventUnitTest_1800
754  * @tc.name: test  InnerCommonEventManager permission
755  * @tc.desc: function CheckPermission return false
756  */
757 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1800,
758     Function | MediumTest | Level1)
759 {
760     GTEST_LOG_(INFO)
761         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1800, TestSize.Level1";
762 
763     CommonEventSubscribeInfo commonEventSubscribeInfo;
764     commonEventSubscribeInfo.SetPermission("1234");
765     std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
766         std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
767     EventSubscriberRecord eventSubRecord;
768     eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
769     eventSubRecord.eventRecordInfo.callerToken = 1;
770 
771     CommonEventPublishInfo commonEventPublishInfo;
772     std::vector<std::string> vecstr;
773     vecstr.emplace_back("456");
774     commonEventPublishInfo.SetSubscriberPermissions(vecstr);
775     std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
776         std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
777 
778     Want want;
779     want.SetAction("COMMON_EVENT_DISK_REMOVED");
780     std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
781     spCommonEventData->SetWant(want);
782     CommonEventRecord commonEventRecord;
783     commonEventRecord.publishInfo = commonEventPublishInfoSptr;
784     commonEventRecord.eventRecordInfo.callerToken = 1;
785     commonEventRecord.commonEventData = spCommonEventData;
786 
787     CommonEventControlManager commonEventControlManager;
788     int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
789     EXPECT_EQ(OrderedEventRecord::DELIVERED, ret);
790 }
791 
792 /*
793  * @tc.number: CommonEventPublishPermissionEventUnitTest_1900
794  * @tc.name: test  InnerCommonEventManager permission
795  * @tc.desc: function CheckPermission return false
796  */
797 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1900,
798     Function | MediumTest | Level1)
799 {
800     GTEST_LOG_(INFO)
801         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1900, TestSize.Level1";
802 
803     CommonEventSubscribeInfo commonEventSubscribeInfo;
804     commonEventSubscribeInfo.SetPermission("1234");
805     std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
806         std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
807     EventSubscriberRecord eventSubRecord;
808     eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
809     eventSubRecord.eventRecordInfo.callerToken = 1;
810 
811     CommonEventPublishInfo commonEventPublishInfo;
812     std::vector<std::string> vecstr;
813     vecstr.emplace_back("456");
814     commonEventPublishInfo.SetSubscriberPermissions(vecstr);
815     std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
816         std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
817 
818     Want want;
819     want.SetAction("COMMON_EVENT_DISK_REMOVED");
820     std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
821     spCommonEventData->SetWant(want);
822     CommonEventRecord commonEventRecord;
823     commonEventRecord.publishInfo = commonEventPublishInfoSptr;
824     commonEventRecord.eventRecordInfo.callerToken = 1;
825     commonEventRecord.commonEventData = spCommonEventData;
826 
827     CommonEventControlManager commonEventControlManager;
828     int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
829     EXPECT_EQ(OrderedEventRecord::DELIVERED, ret);
830 }
831 
832 /*
833  * @tc.number: CommonEventPublishPermissionEventUnitTest_2000
834  * @tc.name: test  InnerCommonEventManager permission
835  * @tc.desc: function CheckPermission return false   null
836  */
837 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2000,
838     Function | MediumTest | Level1)
839 {
840     GTEST_LOG_(INFO)
841         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2000, TestSize.Level1";
842 
843     CommonEventSubscribeInfo commonEventSubscribeInfo;
844     commonEventSubscribeInfo.SetPermission("1234");
845     std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
846         std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
847     EventSubscriberRecord eventSubRecord;
848     eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
849     eventSubRecord.eventRecordInfo.callerToken = 1;
850 
851     CommonEventPublishInfo commonEventPublishInfo;
852     std::vector<std::string> vecstr;
853     vecstr.emplace_back("456");
854     commonEventPublishInfo.SetSubscriberPermissions(vecstr);
855     std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
856         std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
857 
858     Want want;
859     want.SetAction("COMMON_EVENT_USB_DEVICE_ATTACHED");
860     std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
861     spCommonEventData->SetWant(want);
862     CommonEventRecord commonEventRecord;
863     commonEventRecord.publishInfo = commonEventPublishInfoSptr;
864     commonEventRecord.eventRecordInfo.callerToken = 1;
865     commonEventRecord.commonEventData = spCommonEventData;
866 
867     CommonEventControlManager commonEventControlManager;
868     int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
869     EXPECT_EQ(OrderedEventRecord::DELIVERED, ret);
870 }
871 
872 /*
873  * @tc.number: CommonEventPublishPermissionEventUnitTest_2100
874  * @tc.name: test  InnerCommonEventManager permission
875  * @tc.desc: function CheckPermission return false   not find
876  */
877 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2100,
878     Function | MediumTest | Level1)
879 {
880     GTEST_LOG_(INFO)
881         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2100, TestSize.Level1";
882 
883     CommonEventSubscribeInfo commonEventSubscribeInfo;
884     commonEventSubscribeInfo.SetPermission("1234");
885     std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
886         std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
887     EventSubscriberRecord eventSubRecord;
888     eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
889     eventSubRecord.eventRecordInfo.callerToken = 1;
890 
891     CommonEventPublishInfo commonEventPublishInfo;
892     std::vector<std::string> vecstr;
893     vecstr.emplace_back("456");
894     commonEventPublishInfo.SetSubscriberPermissions(vecstr);
895     std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
896         std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
897 
898     Want want;
899     want.SetAction("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
900     std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
901     spCommonEventData->SetWant(want);
902     CommonEventRecord commonEventRecord;
903     commonEventRecord.publishInfo = commonEventPublishInfoSptr;
904     commonEventRecord.eventRecordInfo.callerToken = 1;
905     commonEventRecord.commonEventData = spCommonEventData;
906 
907     CommonEventControlManager commonEventControlManager;
908     int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
909     EXPECT_EQ(OrderedEventRecord::DELIVERED, ret);
910 }
911 
912 /*
913  * @tc.number: CommonEventPublishPermissionEventUnitTest_2200
914  * @tc.name: test  CommonEventPermissionManager GetEventPermission
915  * @tc.desc: 1. subscriber permission is not empty and has one permission
916  *           2. function subscriber CheckPermission return name size
917  */
918 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2200,
919     Function | MediumTest | Level1)
920 {
921     GTEST_LOG_(INFO) << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2200, "
922                         "TestSize.Level1";
923 
924     std::string event = "usual.event.BOOT_COMPLETED";
925 
926     int ret = DelayedSingleton<CommonEventPermissionManager>::GetInstance()->GetEventPermission(event).names.size();
927 
928     EXPECT_TRUE(ret > 0);
929 }
930 
931 /*
932  * @tc.number: CommonEventPublishPermissionEventUnitTest_2200
933  * @tc.name: test  CommonEventPermissionManager GetEventPermission
934  * @tc.desc: 1. subscriber permission is not empty and has two permission and is Logic and
935  *           2. function subscriber CheckPermission return name size
936  */
937 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2300,
938     Function | MediumTest | Level1)
939 {
940     GTEST_LOG_(INFO) << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2300, "
941                         "TestSize.Level1";
942 
943     std::string event = "usual.event.wifi.p2p.CONN_STATE_CHANGE";
944 
945     Permission per = DelayedSingleton<CommonEventPermissionManager>::GetInstance()->GetEventPermission(event);
946     int ret = per.names.size();
947     PermissionState state = per.state;
948 
949     EXPECT_TRUE(ret > 0);
950     EXPECT_TRUE(state == PermissionState::AND);
951 }
952 
953 /*
954  * @tc.number: CommonEventPublishPermissionEventUnitTest_2200
955  * @tc.name: test  CommonEventPermissionManager GetEventPermission
956  * @tc.desc: 1. subscriber permission is not empty and has two permission and is Logic or
957  *           2. function subscriber CheckPermission return name size
958  */
959 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2400,
960     Function | MediumTest | Level1)
961 {
962     GTEST_LOG_(INFO) << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2400, "
963                         "TestSize.Level1";
964 
965     std::string event = "usual.event.data.DISK_REMOVED";
966 
967     Permission per = DelayedSingleton<CommonEventPermissionManager>::GetInstance()->GetEventPermission(event);
968     int ret = per.names.size();
969     PermissionState state = per.state;
970 
971     EXPECT_TRUE(ret > 0);
972     EXPECT_TRUE(state == PermissionState::DEFAULT);
973 }
974 
975 /*
976  * @tc.number: CommonEventPublishPermissionEventUnitTest_2500
977  * @tc.name: test unordered event permission and system send is yes
978  * @tc.desc: 1. subscriber permission is empty
979  *           2. publish permission is not empty
980  *           3. event has one attribute
981  */
982 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2500,
983     Function | MediumTest | Level1)
984 {
985     GTEST_LOG_(INFO)
986         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2500, TestSize.Level1";
987     /* subscriber */
988     InnerCommonEventManager inner;
989     struct tm curTime {
990         0
991     };
992     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
993     MatchingSkills matchingSkillsObj;
994     matchingSkillsObj.AddEvent("usual.event.nfc.action.RF_FIELD_ON_DETECTED");
995     CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
996     subscribeInfo.SetPermission("123");
997     subscribeInfo.SetPriority(1);
998     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
999     auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
1000     inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case1");
1001 
1002     /* Publish */
1003     Want want;
1004     want.SetAction("usual.event.nfc.action.RF_FIELD_ON_DETECTED");
1005     CommonEventData data;
1006     data.SetWant(want);
1007 
1008     CommonEventPublishInfo publishInfo;
1009     std::vector<std::string> subscriberPermissions;
1010     publishInfo.SetOrdered(false);
1011     subscriberPermissions.emplace_back("456");
1012     publishInfo.SetSubscriberPermissions(subscriberPermissions);
1013     bool result = inner.PublishCommonEvent(
1014         data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case1");
1015     sleep(PUBLISH_SLEEP);
1016     EXPECT_TRUE(result);
1017     inner.UnsubscribeCommonEvent(listener);
1018 }
1019 
1020 /*
1021  * @tc.number: CommonEventPublishPermissionEventUnitTest_2600
1022  * @tc.name: test unordered event permission and system send is no
1023  * @tc.desc: 1. subscriber permission is empty
1024  *           2. publish permission is not empty
1025  *           3. event has one attribute
1026  */
1027 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2600,
1028     Function | MediumTest | Level1)
1029 {
1030     GTEST_LOG_(INFO)
1031         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2600, TestSize.Level1";
1032     /* subscriber */
1033     InnerCommonEventManager inner;
1034     struct tm curTime {
1035         0
1036     };
1037     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1038     MatchingSkills matchingSkillsObj;
1039     matchingSkillsObj.AddEvent("usual.event.wifi.mplink.STATE_CHANGE");
1040     CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
1041     subscribeInfo.SetPermission("");
1042     subscribeInfo.SetPriority(1);
1043     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
1044     auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
1045     inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case2");
1046 
1047     /* Publish */
1048     Want want;
1049     want.SetAction("usual.event.wifi.mplink.STATE_CHANGE");
1050     CommonEventData data;
1051     data.SetWant(want);
1052 
1053     CommonEventPublishInfo publishInfo;
1054     std::vector<std::string> subscriberPermissions;
1055     publishInfo.SetOrdered(false);
1056     subscriberPermissions.emplace_back("456");
1057     publishInfo.SetSubscriberPermissions(subscriberPermissions);
1058     bool result = inner.PublishCommonEvent(
1059         data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case2");
1060     sleep(PUBLISH_SLEEP);
1061     EXPECT_TRUE(result);
1062     inner.UnsubscribeCommonEvent(listener);
1063 }
1064 
1065 /*
1066  * @tc.number: CommonEventPublishPermissionEventUnitTest_2700
1067  * @tc.name: test unordered event permission and system send is no
1068  * @tc.desc: 1. subscriber permission is empty
1069  *           2. publish permission is not empty
1070  *           3. event has two attribute and logic and
1071  */
1072 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2700,
1073     Function | MediumTest | Level1)
1074 {
1075     GTEST_LOG_(INFO)
1076         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2700, TestSize.Level1";
1077     /* subscriber */
1078     InnerCommonEventManager inner;
1079     struct tm curTime {
1080         0
1081     };
1082     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1083     MatchingSkills matchingSkillsObj;
1084     matchingSkillsObj.AddEvent("usual.event.bluetooth.remotedevice.DISCOVERED");
1085     CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
1086     subscribeInfo.SetPermission("");
1087     subscribeInfo.SetPriority(1);
1088     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
1089     auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
1090     inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case3");
1091 
1092     /* Publish */
1093     Want want;
1094     want.SetAction("usual.event.bluetooth.remotedevice.DISCOVERED");
1095     CommonEventData data;
1096     data.SetWant(want);
1097 
1098     CommonEventPublishInfo publishInfo;
1099     std::vector<std::string> subscriberPermissions;
1100     publishInfo.SetOrdered(false);
1101     subscriberPermissions.emplace_back("456");
1102     publishInfo.SetSubscriberPermissions(subscriberPermissions);
1103     bool result = inner.PublishCommonEvent(
1104         data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case3");
1105     sleep(PUBLISH_SLEEP);
1106     EXPECT_TRUE(result);
1107     inner.UnsubscribeCommonEvent(listener);
1108 }
1109 
1110 /*
1111  * @tc.number: CommonEventPublishPermissionEventUnitTest_2800
1112  * @tc.name: test unordered event permission and system send is yes
1113  * @tc.desc: 1. subscriber permission is empty
1114  *           2. publish permission is not empty
1115  *           3. event has two attribute and logic or
1116  */
1117 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2800,
1118     Function | MediumTest | Level1)
1119 {
1120     GTEST_LOG_(INFO)
1121         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2800, TestSize.Level1";
1122     /* subscriber */
1123     InnerCommonEventManager inner;
1124     struct tm curTime {
1125         0
1126     };
1127     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1128     MatchingSkills matchingSkillsObj;
1129     matchingSkillsObj.AddEvent("usual.event.data.DISK_MOUNTED");
1130     CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
1131     subscribeInfo.SetPermission("");
1132     subscribeInfo.SetPriority(1);
1133     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
1134     auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
1135     inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case4");
1136 
1137     /* Publish */
1138     Want want;
1139     want.SetAction("usual.event.data.DISK_MOUNTED");
1140     CommonEventData data;
1141     data.SetWant(want);
1142 
1143     CommonEventPublishInfo publishInfo;
1144     std::vector<std::string> subscriberPermissions;
1145     publishInfo.SetOrdered(false);
1146     subscriberPermissions.emplace_back("456");
1147     publishInfo.SetSubscriberPermissions(subscriberPermissions);
1148     bool result = inner.PublishCommonEvent(
1149         data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case4");
1150     sleep(PUBLISH_SLEEP);
1151     EXPECT_TRUE(result);
1152     inner.UnsubscribeCommonEvent(listener);
1153 }
1154 
1155 /*
1156  * @tc.number: CommonEventPublishPermissionEventUnitTest_2900
1157  * @tc.name: test unordered event permission and system send is yes
1158  * @tc.desc: 1. subscriber permission is empty
1159  *           2. publish permission is not empty
1160  *           3. event has no attribute
1161  */
1162 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2900,
1163     Function | MediumTest | Level1)
1164 {
1165     GTEST_LOG_(INFO)
1166         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2900, TestSize.Level1";
1167     /* subscriber */
1168     InnerCommonEventManager inner;
1169     struct tm curTime {
1170         0
1171     };
1172     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1173     MatchingSkills matchingSkillsObj;
1174     matchingSkillsObj.AddEvent("common.event.IVI_TEMPERATURE_RECOVERY");
1175     CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
1176     subscribeInfo.SetPermission("");
1177     subscribeInfo.SetPriority(1);
1178     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
1179     auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
1180     inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case6");
1181 
1182     /* Publish */
1183     Want want;
1184     want.SetAction("common.event.IVI_TEMPERATURE_RECOVERY");
1185     CommonEventData data;
1186     data.SetWant(want);
1187 
1188     CommonEventPublishInfo publishInfo;
1189     std::vector<std::string> subscriberPermissions;
1190     publishInfo.SetOrdered(false);
1191     subscriberPermissions.emplace_back("456");
1192     publishInfo.SetSubscriberPermissions(subscriberPermissions);
1193     bool result = inner.PublishCommonEvent(
1194         data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case6");
1195     sleep(PUBLISH_SLEEP);
1196     EXPECT_TRUE(result);
1197     inner.UnsubscribeCommonEvent(listener);
1198 }
1199 
1200 /*
1201  * @tc.number: CommonEventPublishPermissionEventUnitTest_3000
1202  * @tc.name: test ordered event permission and system send is yes
1203  * @tc.desc: 1. subscriber permission is empty
1204  *           2. publish permission is not empty
1205  *           3. event has one attribute
1206  */
1207 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3000,
1208     Function | MediumTest | Level1)
1209 {
1210     GTEST_LOG_(INFO)
1211         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3000, TestSize.Level1";
1212     /* subscriber */
1213     InnerCommonEventManager inner;
1214     struct tm curTime {
1215         0
1216     };
1217     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1218     MatchingSkills matchingSkillsObj;
1219     matchingSkillsObj.AddEvent("usual.event.BOOT_COMPLETED");
1220     CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
1221     subscribeInfo.SetPermission("123");
1222     subscribeInfo.SetPriority(1);
1223     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
1224     auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
1225     inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case1");
1226 
1227     /* Publish */
1228     Want want;
1229     want.SetAction("usual.event.BOOT_COMPLETED");
1230     CommonEventData data;
1231     data.SetWant(want);
1232 
1233     CommonEventPublishInfo publishInfo;
1234     std::vector<std::string> subscriberPermissions;
1235     publishInfo.SetOrdered(true);
1236     subscriberPermissions.emplace_back("456");
1237     publishInfo.SetSubscriberPermissions(subscriberPermissions);
1238     bool result = inner.PublishCommonEvent(
1239         data, publishInfo, listener, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case1");
1240     sleep(PUBLISH_SLEEP);
1241     EXPECT_TRUE(result);
1242     inner.UnsubscribeCommonEvent(listener);
1243 }
1244 
1245 /*
1246  * @tc.number: CommonEventPublishPermissionEventUnitTest_3100
1247  * @tc.name: test unordered event permission and system send is no
1248  * @tc.desc: 1. subscriber permission is empty
1249  *           2. publish permission is not empty
1250  *           3. event has one attribute
1251  */
1252 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3100,
1253     Function | MediumTest | Level1)
1254 {
1255     GTEST_LOG_(INFO)
1256         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3100, TestSize.Level1";
1257     /* subscriber */
1258     InnerCommonEventManager inner;
1259     struct tm curTime {
1260         0
1261     };
1262     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1263     MatchingSkills matchingSkillsObj;
1264     matchingSkillsObj.AddEvent("usual.event.USER_SWITCHED");
1265     CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
1266     subscribeInfo.SetPermission("");
1267     subscribeInfo.SetPriority(1);
1268     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
1269     auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
1270     inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case2");
1271 
1272     /* Publish */
1273     Want want;
1274     want.SetAction("usual.event.USER_SWITCHED");
1275     CommonEventData data;
1276     data.SetWant(want);
1277 
1278     CommonEventPublishInfo publishInfo;
1279     std::vector<std::string> subscriberPermissions;
1280     publishInfo.SetOrdered(true);
1281     subscriberPermissions.emplace_back("456");
1282     publishInfo.SetSubscriberPermissions(subscriberPermissions);
1283     bool result = inner.PublishCommonEvent(
1284         data, publishInfo, listener, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case2");
1285     sleep(PUBLISH_SLEEP);
1286     EXPECT_TRUE(result);
1287     inner.UnsubscribeCommonEvent(listener);
1288 }
1289 
1290 /*
1291  * @tc.number: CommonEventPublishPermissionEventUnitTest_3200
1292  * @tc.name: test unordered event permission and system send is no
1293  * @tc.desc: 1. subscriber permission is empty
1294  *           2. publish permission is not empty
1295  *           3. event has two attribute and logic and
1296  */
1297 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3200,
1298     Function | MediumTest | Level1)
1299 {
1300     GTEST_LOG_(INFO)
1301         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3200, TestSize.Level1";
1302     /* subscriber */
1303     InnerCommonEventManager inner;
1304     struct tm curTime {
1305         0
1306     };
1307     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1308     MatchingSkills matchingSkillsObj;
1309     matchingSkillsObj.AddEvent("usual.event.wifi.p2p.CONN_STATE_CHANGE");
1310     CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
1311     subscribeInfo.SetPermission("");
1312     subscribeInfo.SetPriority(1);
1313     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
1314     auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
1315     inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case3");
1316 
1317     /* Publish */
1318     Want want;
1319     want.SetAction("usual.event.wifi.p2p.CONN_STATE_CHANGE");
1320     CommonEventData data;
1321     data.SetWant(want);
1322 
1323     CommonEventPublishInfo publishInfo;
1324     std::vector<std::string> subscriberPermissions;
1325     publishInfo.SetOrdered(true);
1326     subscriberPermissions.emplace_back("456");
1327     publishInfo.SetSubscriberPermissions(subscriberPermissions);
1328     bool result = inner.PublishCommonEvent(
1329         data, publishInfo, listener, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case3");
1330     sleep(PUBLISH_SLEEP);
1331     EXPECT_TRUE(result);
1332     inner.UnsubscribeCommonEvent(listener);
1333 }
1334 
1335 /*
1336  * @tc.number: CommonEventPublishPermissionEventUnitTest_3300
1337  * @tc.name: test unordered event permission and system send is yes
1338  * @tc.desc: 1. subscriber permission is empty
1339  *           2. publish permission is not empty
1340  *           3. event has two attribute and logic or
1341  */
1342 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3300,
1343     Function | MediumTest | Level1)
1344 {
1345     GTEST_LOG_(INFO)
1346         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3300, TestSize.Level1";
1347     /* subscriber */
1348     InnerCommonEventManager inner;
1349     struct tm curTime {
1350         0
1351     };
1352     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1353     MatchingSkills matchingSkillsObj;
1354     matchingSkillsObj.AddEvent("usual.event.data.DISK_REMOVED");
1355     CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
1356     subscribeInfo.SetPermission("");
1357     subscribeInfo.SetPriority(1);
1358     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
1359     auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
1360     inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case4");
1361 
1362     /* Publish */
1363     Want want;
1364     want.SetAction("usual.event.data.DISK_REMOVED");
1365     CommonEventData data;
1366     data.SetWant(want);
1367 
1368     CommonEventPublishInfo publishInfo;
1369     std::vector<std::string> subscriberPermissions;
1370     publishInfo.SetOrdered(true);
1371     subscriberPermissions.emplace_back("456");
1372     publishInfo.SetSubscriberPermissions(subscriberPermissions);
1373     bool result = inner.PublishCommonEvent(
1374         data, publishInfo, listener, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case4");
1375     sleep(PUBLISH_SLEEP);
1376     EXPECT_TRUE(result);
1377     inner.UnsubscribeCommonEvent(listener);
1378 }
1379 
1380 /*
1381  * @tc.number: CommonEventPublishPermissionEventUnitTest_3400
1382  * @tc.name: test unordered event permission and system send is yes
1383  * @tc.desc: 1. subscriber permission is empty
1384  *           2. publish permission is not empty
1385  *           3. event has no attribute
1386  */
1387 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3400,
1388     Function | MediumTest | Level1)
1389 {
1390     GTEST_LOG_(INFO)
1391         << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3400, TestSize.Level1";
1392     /* subscriber */
1393     InnerCommonEventManager inner;
1394     struct tm curTime {
1395         0
1396     };
1397     OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1398     MatchingSkills matchingSkillsObj;
1399     matchingSkillsObj.AddEvent("common.event.IVI_TEMPERATURE_RECOVERY");
1400     CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
1401     subscribeInfo.SetPermission("");
1402     subscribeInfo.SetPriority(1);
1403     std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
1404     auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
1405     inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case6");
1406 
1407     /* Publish */
1408     Want want;
1409     want.SetAction("common.event.IVI_TEMPERATURE_RECOVERY");
1410     CommonEventData data;
1411     data.SetWant(want);
1412 
1413     CommonEventPublishInfo publishInfo;
1414     std::vector<std::string> subscriberPermissions;
1415     publishInfo.SetOrdered(true);
1416     subscriberPermissions.emplace_back("456");
1417     publishInfo.SetSubscriberPermissions(subscriberPermissions);
1418     bool result = inner.PublishCommonEvent(
1419         data, publishInfo, listener, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case6");
1420     sleep(PUBLISH_SLEEP);
1421     EXPECT_TRUE(result);
1422     inner.UnsubscribeCommonEvent(listener);
1423 }
1424