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::SKIPPED, 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 }
427
428 /*
429 * @tc.number: CommonEventPublishPermissionEventUnitTest_0900
430 * @tc.name: test CommonEventControlManager permission
431 * @tc.desc: 1. subscriber permission is empty
432 * 2. publish permission is not empty
433 * 3. function CheckPermission return OrderedEventRecord::SKIPPED
434 */
435 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0900,
436 Function | MediumTest | Level1)
437 {
438 GTEST_LOG_(INFO)
439 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0900, TestSize.Level1";
440
441 CommonEventSubscribeInfo commonEventSubscribeInfo;
442 commonEventSubscribeInfo.SetPermission("");
443 std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
444 std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
445 EventSubscriberRecord eventSubRecord;
446 eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
447 eventSubRecord.eventRecordInfo.bundleName = "hello world";
448 eventSubRecord.eventRecordInfo.callerToken = 1;
449
450 CommonEventPublishInfo commonEventPublishInfo;
451 std::vector<std::string> vecstr;
452 vecstr.emplace_back("456");
453 commonEventPublishInfo.SetSubscriberPermissions(vecstr);
454 std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
455 std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
456 Want want;
457 want.SetAction("1234");
458 std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
459 spCommonEventData->SetWant(want);
460 CommonEventRecord commonEventRecord;
461 commonEventRecord.publishInfo = commonEventPublishInfoSptr;
462 commonEventRecord.commonEventData = spCommonEventData;
463
464 CommonEventControlManager commonEventControlManager;
465 int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
466 EXPECT_EQ(OrderedEventRecord::OrderedEventRecord::SKIPPED, ret);
467 }
468
469 /*
470 * @tc.number: CommonEventPublishPermissionEventUnitTest_1000
471 * @tc.name: test CommonEventControlManager permission
472 * @tc.desc: 1. subscriber permission is not empty
473 * 2. publish permission is not empty
474 * 3. function subscriber CheckPermission return OrderedEventRecord::DELIVERED
475 */
476 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1000,
477 Function | MediumTest | Level1)
478 {
479 GTEST_LOG_(INFO)
480 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1000, TestSize.Level1";
481
482 CommonEventSubscribeInfo commonEventSubscribeInfo;
483 commonEventSubscribeInfo.SetPermission("12345");
484 std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
485 std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
486 EventSubscriberRecord eventSubRecord;
487 eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
488
489 CommonEventPublishInfo commonEventPublishInfo;
490 std::vector<std::string> vecstr;
491 vecstr.emplace_back("456");
492 commonEventPublishInfo.SetSubscriberPermissions(vecstr);
493 std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
494 std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
495
496 Want want;
497 want.SetAction("1234");
498 std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
499 spCommonEventData->SetWant(want);
500 CommonEventRecord commonEventRecord;
501 commonEventRecord.publishInfo = commonEventPublishInfoSptr;
502 commonEventRecord.commonEventData = spCommonEventData;
503
504 CommonEventControlManager commonEventControlManager;
505 int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
506 EXPECT_EQ(OrderedEventRecord::DELIVERED, ret);
507 }
508
509 /*
510 * @tc.number: CommonEventPublishPermissionEventUnitTest_1100
511 * @tc.name: test CommonEventControlManager permission
512 * @tc.desc: 1. subscriber permission is not empty
513 * 2. publish permission is not empty
514 * 3. function subscriber CheckPermission return OrderedEventRecord::SKIPPED
515 */
516 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1100,
517 Function | MediumTest | Level1)
518 {
519 GTEST_LOG_(INFO)
520 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1100, TestSize.Level1";
521
522 CommonEventSubscribeInfo commonEventSubscribeInfo;
523 commonEventSubscribeInfo.SetPermission("12345");
524 std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
525 std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
526 EventSubscriberRecord eventSubRecord;
527 eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
528 eventSubRecord.eventRecordInfo.bundleName = "hello world";
529 eventSubRecord.eventRecordInfo.callerToken = 1;
530
531 CommonEventPublishInfo commonEventPublishInfo;
532 std::vector<std::string> vecstr;
533 vecstr.emplace_back("456");
534 commonEventPublishInfo.SetSubscriberPermissions(vecstr);
535 std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
536 std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
537
538 Want want;
539 want.SetAction("1234");
540 std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
541 spCommonEventData->SetWant(want);
542 CommonEventRecord commonEventRecord;
543 commonEventRecord.publishInfo = commonEventPublishInfoSptr;
544 commonEventRecord.eventRecordInfo.bundleName = "hello";
545 commonEventRecord.eventRecordInfo.callerToken = 1;
546 commonEventRecord.commonEventData = spCommonEventData;
547
548 CommonEventControlManager commonEventControlManager;
549 int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
550 EXPECT_EQ(OrderedEventRecord::OrderedEventRecord::SKIPPED, ret);
551 }
552
553 /*
554 * @tc.number: CommonEventPublishPermissionEventUnitTest_1200
555 * @tc.name: test CommonEventControlManager permission
556 * @tc.desc: 1. subscriber permission is not empty
557 * 2. publish permission is not empty
558 * 3. function subscriber CheckPermission return OrderedEventRecord::SKIPPED
559 */
560 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1200,
561 Function | MediumTest | Level1)
562 {
563 GTEST_LOG_(INFO)
564 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1200, TestSize.Level1";
565
566 CommonEventSubscribeInfo commonEventSubscribeInfo;
567 commonEventSubscribeInfo.SetPermission("12345");
568 std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
569 std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
570 EventSubscriberRecord eventSubRecord;
571 eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
572 eventSubRecord.eventRecordInfo.bundleName = "hello";
573 eventSubRecord.eventRecordInfo.callerToken = 1;
574
575 CommonEventPublishInfo commonEventPublishInfo;
576 std::vector<std::string> vecstr;
577 vecstr.emplace_back("456");
578 commonEventPublishInfo.SetSubscriberPermissions(vecstr);
579 std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
580 std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
581
582 Want want;
583 want.SetAction("1234");
584 std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
585 spCommonEventData->SetWant(want);
586 CommonEventRecord commonEventRecord;
587 commonEventRecord.publishInfo = commonEventPublishInfoSptr;
588 commonEventRecord.eventRecordInfo.bundleName = "hello world";
589 commonEventRecord.commonEventData = spCommonEventData;
590 commonEventRecord.eventRecordInfo.callerToken = 1;
591
592 CommonEventControlManager commonEventControlManager;
593 int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
594 EXPECT_EQ(OrderedEventRecord::OrderedEventRecord::SKIPPED, ret);
595 }
596
597 /*
598 * @tc.number: CommonEventPublishPermissionEventUnitTest_1300
599 * @tc.name: test CommonEventControlManager permission
600 * @tc.desc: 1. subscriber permission is not empty
601 * 2. publish permission is not empty
602 * 3. function subscriber CheckPermission return OrderedEventRecord::SKIPPED
603 */
604 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1300,
605 Function | MediumTest | Level1)
606 {
607 GTEST_LOG_(INFO)
608 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1300, TestSize.Level1";
609
610 CommonEventSubscribeInfo commonEventSubscribeInfo;
611 commonEventSubscribeInfo.SetPermission("12345");
612 std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
613 std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
614 EventSubscriberRecord eventSubRecord;
615 eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
616 eventSubRecord.eventRecordInfo.bundleName = "hello world";
617 eventSubRecord.eventRecordInfo.callerToken = 1;
618
619 CommonEventPublishInfo commonEventPublishInfo;
620 std::vector<std::string> vecstr;
621 vecstr.emplace_back("456");
622 commonEventPublishInfo.SetSubscriberPermissions(vecstr);
623 std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
624 std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
625
626 Want want;
627 want.SetAction("1234");
628 std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
629 spCommonEventData->SetWant(want);
630 CommonEventRecord commonEventRecord;
631 commonEventRecord.publishInfo = commonEventPublishInfoSptr;
632 commonEventRecord.eventRecordInfo.bundleName = "hello world";
633 commonEventRecord.commonEventData = spCommonEventData;
634 commonEventRecord.eventRecordInfo.callerToken = 1;
635
636 CommonEventControlManager commonEventControlManager;
637 int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
638 EXPECT_EQ(OrderedEventRecord::OrderedEventRecord::SKIPPED, ret);
639 }
640
641 /*
642 * @tc.number: CommonEventPublishPermissionEventUnitTest_1500
643 * @tc.name: test InnerCommonEventManager permission
644 * @tc.desc: function CheckPermission return false
645 */
646 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1500,
647 Function | MediumTest | Level1)
648 {
649 GTEST_LOG_(INFO)
650 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1500, TestSize.Level1";
651
652 InnerCommonEventManager inner;
653 struct tm curTime {0};
654 OHOS::Security::AccessToken::AccessTokenID tokenID = 1;
655
656 Want want;
657 want.SetAction("1234");
658 CommonEventData data;
659 data.SetWant(want);
660 CommonEventPublishInfo publishInfo;
661 publishInfo.SetOrdered(true);
662 publishInfo.SetSticky(true);
663 EXPECT_FALSE(inner.PublishCommonEvent(
664 data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "hello world"));
665 }
666
667 /*
668 * @tc.number: CommonEventPublishPermissionEventUnitTest_1600
669 * @tc.name: test InnerCommonEventManager permission
670 * @tc.desc: function CheckPermission return false
671 */
672 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1600,
673 Function | MediumTest | Level1)
674 {
675 GTEST_LOG_(INFO)
676 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1600, TestSize.Level1";
677
678 CommonEventSubscribeInfo commonEventSubscribeInfo;
679 commonEventSubscribeInfo.SetPermission("ohos.permission.GET_WIFI_INFO");
680 std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
681 std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
682 EventSubscriberRecord eventSubRecord;
683 eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
684 eventSubRecord.eventRecordInfo.callerToken = 1;
685
686 CommonEventPublishInfo commonEventPublishInfo;
687 std::vector<std::string> vecstr;
688 vecstr.emplace_back("456");
689 commonEventPublishInfo.SetSubscriberPermissions(vecstr);
690 std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
691 std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
692
693 Want want;
694 want.SetAction("COMMON_EVENT_WIFI_AP_STA_JOIN");
695 std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
696 spCommonEventData->SetWant(want);
697 CommonEventRecord commonEventRecord;
698 commonEventRecord.publishInfo = commonEventPublishInfoSptr;
699 commonEventRecord.eventRecordInfo.callerToken = 1;
700 commonEventRecord.commonEventData = spCommonEventData;
701
702 CommonEventControlManager commonEventControlManager;
703 int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
704 EXPECT_EQ(OrderedEventRecord::SKIPPED, ret);
705 }
706
707 /*
708 * @tc.number: CommonEventPublishPermissionEventUnitTest_1700
709 * @tc.name: test InnerCommonEventManager permission
710 * @tc.desc: function CheckPermission return false
711 */
712 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1700,
713 Function | MediumTest | Level1)
714 {
715 GTEST_LOG_(INFO)
716 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1700, TestSize.Level1";
717
718 CommonEventSubscribeInfo commonEventSubscribeInfo;
719 commonEventSubscribeInfo.SetPermission("1234");
720 std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
721 std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
722 EventSubscriberRecord eventSubRecord;
723 eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
724 eventSubRecord.eventRecordInfo.callerToken = 1;
725
726 CommonEventPublishInfo commonEventPublishInfo;
727 std::vector<std::string> vecstr;
728 vecstr.emplace_back("456");
729 commonEventPublishInfo.SetSubscriberPermissions(vecstr);
730 std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
731 std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
732
733 Want want;
734 want.SetAction("COMMON_EVENT_BLUETOOTH_REMOTEDEVICE_DISCOVERED");
735 std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
736 spCommonEventData->SetWant(want);
737 CommonEventRecord commonEventRecord;
738 commonEventRecord.publishInfo = commonEventPublishInfoSptr;
739 commonEventRecord.eventRecordInfo.callerToken = 1;
740 commonEventRecord.commonEventData = spCommonEventData;
741
742 CommonEventControlManager commonEventControlManager;
743 int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
744 EXPECT_EQ(OrderedEventRecord::SKIPPED, ret);
745 }
746
747 /*
748 * @tc.number: CommonEventPublishPermissionEventUnitTest_1800
749 * @tc.name: test InnerCommonEventManager permission
750 * @tc.desc: function CheckPermission return false
751 */
752 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1800,
753 Function | MediumTest | Level1)
754 {
755 GTEST_LOG_(INFO)
756 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1800, TestSize.Level1";
757
758 CommonEventSubscribeInfo commonEventSubscribeInfo;
759 commonEventSubscribeInfo.SetPermission("1234");
760 std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
761 std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
762 EventSubscriberRecord eventSubRecord;
763 eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
764 eventSubRecord.eventRecordInfo.callerToken = 1;
765
766 CommonEventPublishInfo commonEventPublishInfo;
767 std::vector<std::string> vecstr;
768 vecstr.emplace_back("456");
769 commonEventPublishInfo.SetSubscriberPermissions(vecstr);
770 std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
771 std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
772
773 Want want;
774 want.SetAction("COMMON_EVENT_DISK_REMOVED");
775 std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
776 spCommonEventData->SetWant(want);
777 CommonEventRecord commonEventRecord;
778 commonEventRecord.publishInfo = commonEventPublishInfoSptr;
779 commonEventRecord.eventRecordInfo.callerToken = 1;
780 commonEventRecord.commonEventData = spCommonEventData;
781
782 CommonEventControlManager commonEventControlManager;
783 int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
784 EXPECT_EQ(OrderedEventRecord::SKIPPED, ret);
785 }
786
787 /*
788 * @tc.number: CommonEventPublishPermissionEventUnitTest_1900
789 * @tc.name: test InnerCommonEventManager permission
790 * @tc.desc: function CheckPermission return false
791 */
792 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1900,
793 Function | MediumTest | Level1)
794 {
795 GTEST_LOG_(INFO)
796 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1900, TestSize.Level1";
797
798 CommonEventSubscribeInfo commonEventSubscribeInfo;
799 commonEventSubscribeInfo.SetPermission("1234");
800 std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
801 std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
802 EventSubscriberRecord eventSubRecord;
803 eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
804 eventSubRecord.eventRecordInfo.callerToken = 1;
805
806 CommonEventPublishInfo commonEventPublishInfo;
807 std::vector<std::string> vecstr;
808 vecstr.emplace_back("456");
809 commonEventPublishInfo.SetSubscriberPermissions(vecstr);
810 std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
811 std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
812
813 Want want;
814 want.SetAction("COMMON_EVENT_DISK_REMOVED");
815 std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
816 spCommonEventData->SetWant(want);
817 CommonEventRecord commonEventRecord;
818 commonEventRecord.publishInfo = commonEventPublishInfoSptr;
819 commonEventRecord.eventRecordInfo.callerToken = 1;
820 commonEventRecord.commonEventData = spCommonEventData;
821
822 CommonEventControlManager commonEventControlManager;
823 int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
824 EXPECT_EQ(OrderedEventRecord::SKIPPED, ret);
825 }
826
827 /*
828 * @tc.number: CommonEventPublishPermissionEventUnitTest_2000
829 * @tc.name: test InnerCommonEventManager permission
830 * @tc.desc: function CheckPermission return false null
831 */
832 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2000,
833 Function | MediumTest | Level1)
834 {
835 GTEST_LOG_(INFO)
836 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2000, TestSize.Level1";
837
838 CommonEventSubscribeInfo commonEventSubscribeInfo;
839 commonEventSubscribeInfo.SetPermission("1234");
840 std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
841 std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
842 EventSubscriberRecord eventSubRecord;
843 eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
844 eventSubRecord.eventRecordInfo.callerToken = 1;
845
846 CommonEventPublishInfo commonEventPublishInfo;
847 std::vector<std::string> vecstr;
848 vecstr.emplace_back("456");
849 commonEventPublishInfo.SetSubscriberPermissions(vecstr);
850 std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
851 std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
852
853 Want want;
854 want.SetAction("COMMON_EVENT_USB_DEVICE_ATTACHED");
855 std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
856 spCommonEventData->SetWant(want);
857 CommonEventRecord commonEventRecord;
858 commonEventRecord.publishInfo = commonEventPublishInfoSptr;
859 commonEventRecord.eventRecordInfo.callerToken = 1;
860 commonEventRecord.commonEventData = spCommonEventData;
861
862 CommonEventControlManager commonEventControlManager;
863 int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
864 EXPECT_EQ(OrderedEventRecord::SKIPPED, ret);
865 }
866
867 /*
868 * @tc.number: CommonEventPublishPermissionEventUnitTest_2100
869 * @tc.name: test InnerCommonEventManager permission
870 * @tc.desc: function CheckPermission return false not find
871 */
872 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2100,
873 Function | MediumTest | Level1)
874 {
875 GTEST_LOG_(INFO)
876 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2100, TestSize.Level1";
877
878 CommonEventSubscribeInfo commonEventSubscribeInfo;
879 commonEventSubscribeInfo.SetPermission("1234");
880 std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
881 std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
882 EventSubscriberRecord eventSubRecord;
883 eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
884 eventSubRecord.eventRecordInfo.callerToken = 1;
885
886 CommonEventPublishInfo commonEventPublishInfo;
887 std::vector<std::string> vecstr;
888 vecstr.emplace_back("456");
889 commonEventPublishInfo.SetSubscriberPermissions(vecstr);
890 std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
891 std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
892
893 Want want;
894 want.SetAction("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
895 std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
896 spCommonEventData->SetWant(want);
897 CommonEventRecord commonEventRecord;
898 commonEventRecord.publishInfo = commonEventPublishInfoSptr;
899 commonEventRecord.eventRecordInfo.callerToken = 1;
900 commonEventRecord.commonEventData = spCommonEventData;
901
902 CommonEventControlManager commonEventControlManager;
903 int ret = commonEventControlManager.CheckPermission(eventSubRecord, commonEventRecord);
904 EXPECT_EQ(OrderedEventRecord::SKIPPED, ret);
905 }
906
907 /*
908 * @tc.number: CommonEventPublishPermissionEventUnitTest_2200
909 * @tc.name: test CommonEventPermissionManager GetEventPermission
910 * @tc.desc: 1. subscriber permission is not empty and has one permission
911 * 2. function subscriber CheckPermission return name size
912 */
913 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2200,
914 Function | MediumTest | Level1)
915 {
916 GTEST_LOG_(INFO) << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2200, "
917 "TestSize.Level1";
918
919 std::string event = "usual.event.BOOT_COMPLETED";
920
921 int ret = DelayedSingleton<CommonEventPermissionManager>::GetInstance()->GetEventPermission(event).names.size();
922
923 EXPECT_TRUE(ret > 0);
924 }
925
926 /*
927 * @tc.number: CommonEventPublishPermissionEventUnitTest_2200
928 * @tc.name: test CommonEventPermissionManager GetEventPermission
929 * @tc.desc: 1. subscriber permission is not empty and has two permission and is Logic and
930 * 2. function subscriber CheckPermission return name size
931 */
932 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2300,
933 Function | MediumTest | Level1)
934 {
935 GTEST_LOG_(INFO) << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2300, "
936 "TestSize.Level1";
937
938 std::string event = "usual.event.wifi.p2p.CONN_STATE_CHANGE";
939
940 Permission per = DelayedSingleton<CommonEventPermissionManager>::GetInstance()->GetEventPermission(event);
941 int ret = per.names.size();
942 PermissionState state = per.state;
943
944 EXPECT_TRUE(ret > 0);
945 EXPECT_TRUE(state == PermissionState::AND);
946 }
947
948 /*
949 * @tc.number: CommonEventPublishPermissionEventUnitTest_2200
950 * @tc.name: test CommonEventPermissionManager GetEventPermission
951 * @tc.desc: 1. subscriber permission is not empty and has two permission and is Logic or
952 * 2. function subscriber CheckPermission return name size
953 */
954 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2400,
955 Function | MediumTest | Level1)
956 {
957 GTEST_LOG_(INFO) << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2400, "
958 "TestSize.Level1";
959
960 std::string event = "usual.event.data.DISK_REMOVED";
961
962 Permission per = DelayedSingleton<CommonEventPermissionManager>::GetInstance()->GetEventPermission(event);
963 int ret = per.names.size();
964 PermissionState state = per.state;
965
966 EXPECT_TRUE(ret > 0);
967 EXPECT_TRUE(state == PermissionState::DEFAULT);
968 }
969
970 /*
971 * @tc.number: CommonEventPublishPermissionEventUnitTest_2500
972 * @tc.name: test unordered event permission and system send is yes
973 * @tc.desc: 1. subscriber permission is empty
974 * 2. publish permission is not empty
975 * 3. event has one attribute
976 */
977 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2500,
978 Function | MediumTest | Level1)
979 {
980 GTEST_LOG_(INFO)
981 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2500, TestSize.Level1";
982 /* subscriber */
983 InnerCommonEventManager inner;
984 struct tm curTime {
985 0
986 };
987 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
988 MatchingSkills matchingSkillsObj;
989 matchingSkillsObj.AddEvent("usual.event.nfc.action.RF_FIELD_ON_DETECTED");
990 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
991 subscribeInfo.SetPermission("123");
992 subscribeInfo.SetPriority(1);
993 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
994 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
995 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case1");
996
997 /* Publish */
998 Want want;
999 want.SetAction("usual.event.nfc.action.RF_FIELD_ON_DETECTED");
1000 CommonEventData data;
1001 data.SetWant(want);
1002
1003 CommonEventPublishInfo publishInfo;
1004 std::vector<std::string> subscriberPermissions;
1005 publishInfo.SetOrdered(false);
1006 subscriberPermissions.emplace_back("456");
1007 publishInfo.SetSubscriberPermissions(subscriberPermissions);
1008 bool result = inner.PublishCommonEvent(
1009 data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case1");
1010 sleep(PUBLISH_SLEEP);
1011 EXPECT_TRUE(result);
1012 inner.UnsubscribeCommonEvent(listener);
1013 }
1014
1015 /*
1016 * @tc.number: CommonEventPublishPermissionEventUnitTest_2600
1017 * @tc.name: test unordered event permission and system send is no
1018 * @tc.desc: 1. subscriber permission is empty
1019 * 2. publish permission is not empty
1020 * 3. event has one attribute
1021 */
1022 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2600,
1023 Function | MediumTest | Level1)
1024 {
1025 GTEST_LOG_(INFO)
1026 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2600, TestSize.Level1";
1027 /* subscriber */
1028 InnerCommonEventManager inner;
1029 struct tm curTime {
1030 0
1031 };
1032 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1033 MatchingSkills matchingSkillsObj;
1034 matchingSkillsObj.AddEvent("usual.event.wifi.mplink.STATE_CHANGE");
1035 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
1036 subscribeInfo.SetPermission("");
1037 subscribeInfo.SetPriority(1);
1038 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
1039 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
1040 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case2");
1041
1042 /* Publish */
1043 Want want;
1044 want.SetAction("usual.event.wifi.mplink.STATE_CHANGE");
1045 CommonEventData data;
1046 data.SetWant(want);
1047
1048 CommonEventPublishInfo publishInfo;
1049 std::vector<std::string> subscriberPermissions;
1050 publishInfo.SetOrdered(false);
1051 subscriberPermissions.emplace_back("456");
1052 publishInfo.SetSubscriberPermissions(subscriberPermissions);
1053 bool result = inner.PublishCommonEvent(
1054 data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case2");
1055 sleep(PUBLISH_SLEEP);
1056 EXPECT_TRUE(result);
1057 inner.UnsubscribeCommonEvent(listener);
1058 }
1059
1060 /*
1061 * @tc.number: CommonEventPublishPermissionEventUnitTest_2700
1062 * @tc.name: test unordered event permission and system send is no
1063 * @tc.desc: 1. subscriber permission is empty
1064 * 2. publish permission is not empty
1065 * 3. event has two attribute and logic and
1066 */
1067 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2700,
1068 Function | MediumTest | Level1)
1069 {
1070 GTEST_LOG_(INFO)
1071 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2700, TestSize.Level1";
1072 /* subscriber */
1073 InnerCommonEventManager inner;
1074 struct tm curTime {
1075 0
1076 };
1077 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1078 MatchingSkills matchingSkillsObj;
1079 matchingSkillsObj.AddEvent("usual.event.bluetooth.remotedevice.DISCOVERED");
1080 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
1081 subscribeInfo.SetPermission("");
1082 subscribeInfo.SetPriority(1);
1083 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
1084 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
1085 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case3");
1086
1087 /* Publish */
1088 Want want;
1089 want.SetAction("usual.event.bluetooth.remotedevice.DISCOVERED");
1090 CommonEventData data;
1091 data.SetWant(want);
1092
1093 CommonEventPublishInfo publishInfo;
1094 std::vector<std::string> subscriberPermissions;
1095 publishInfo.SetOrdered(false);
1096 subscriberPermissions.emplace_back("456");
1097 publishInfo.SetSubscriberPermissions(subscriberPermissions);
1098 bool result = inner.PublishCommonEvent(
1099 data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case3");
1100 sleep(PUBLISH_SLEEP);
1101 EXPECT_TRUE(result);
1102 inner.UnsubscribeCommonEvent(listener);
1103 }
1104
1105 /*
1106 * @tc.number: CommonEventPublishPermissionEventUnitTest_2800
1107 * @tc.name: test unordered event permission and system send is yes
1108 * @tc.desc: 1. subscriber permission is empty
1109 * 2. publish permission is not empty
1110 * 3. event has two attribute and logic or
1111 */
1112 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2800,
1113 Function | MediumTest | Level1)
1114 {
1115 GTEST_LOG_(INFO)
1116 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2800, TestSize.Level1";
1117 /* subscriber */
1118 InnerCommonEventManager inner;
1119 struct tm curTime {
1120 0
1121 };
1122 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1123 MatchingSkills matchingSkillsObj;
1124 matchingSkillsObj.AddEvent("usual.event.data.DISK_MOUNTED");
1125 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
1126 subscribeInfo.SetPermission("");
1127 subscribeInfo.SetPriority(1);
1128 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
1129 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
1130 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case4");
1131
1132 /* Publish */
1133 Want want;
1134 want.SetAction("usual.event.data.DISK_MOUNTED");
1135 CommonEventData data;
1136 data.SetWant(want);
1137
1138 CommonEventPublishInfo publishInfo;
1139 std::vector<std::string> subscriberPermissions;
1140 publishInfo.SetOrdered(false);
1141 subscriberPermissions.emplace_back("456");
1142 publishInfo.SetSubscriberPermissions(subscriberPermissions);
1143 bool result = inner.PublishCommonEvent(
1144 data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case4");
1145 sleep(PUBLISH_SLEEP);
1146 EXPECT_TRUE(result);
1147 inner.UnsubscribeCommonEvent(listener);
1148 }
1149
1150 /*
1151 * @tc.number: CommonEventPublishPermissionEventUnitTest_2900
1152 * @tc.name: test unordered event permission and system send is yes
1153 * @tc.desc: 1. subscriber permission is empty
1154 * 2. publish permission is not empty
1155 * 3. event has no attribute
1156 */
1157 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2900,
1158 Function | MediumTest | Level1)
1159 {
1160 GTEST_LOG_(INFO)
1161 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2900, TestSize.Level1";
1162 /* subscriber */
1163 InnerCommonEventManager inner;
1164 struct tm curTime {
1165 0
1166 };
1167 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1168 MatchingSkills matchingSkillsObj;
1169 matchingSkillsObj.AddEvent("common.event.IVI_TEMPERATURE_RECOVERY");
1170 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
1171 subscribeInfo.SetPermission("");
1172 subscribeInfo.SetPriority(1);
1173 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
1174 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
1175 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case6");
1176
1177 /* Publish */
1178 Want want;
1179 want.SetAction("common.event.IVI_TEMPERATURE_RECOVERY");
1180 CommonEventData data;
1181 data.SetWant(want);
1182
1183 CommonEventPublishInfo publishInfo;
1184 std::vector<std::string> subscriberPermissions;
1185 publishInfo.SetOrdered(false);
1186 subscriberPermissions.emplace_back("456");
1187 publishInfo.SetSubscriberPermissions(subscriberPermissions);
1188 bool result = inner.PublishCommonEvent(
1189 data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case6");
1190 sleep(PUBLISH_SLEEP);
1191 EXPECT_TRUE(result);
1192 inner.UnsubscribeCommonEvent(listener);
1193 }
1194
1195 /*
1196 * @tc.number: CommonEventPublishPermissionEventUnitTest_3000
1197 * @tc.name: test ordered event permission and system send is yes
1198 * @tc.desc: 1. subscriber permission is empty
1199 * 2. publish permission is not empty
1200 * 3. event has one attribute
1201 */
1202 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3000,
1203 Function | MediumTest | Level1)
1204 {
1205 GTEST_LOG_(INFO)
1206 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3000, TestSize.Level1";
1207 /* subscriber */
1208 InnerCommonEventManager inner;
1209 struct tm curTime {
1210 0
1211 };
1212 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1213 MatchingSkills matchingSkillsObj;
1214 matchingSkillsObj.AddEvent("usual.event.BOOT_COMPLETED");
1215 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
1216 subscribeInfo.SetPermission("123");
1217 subscribeInfo.SetPriority(1);
1218 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
1219 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
1220 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case1");
1221
1222 /* Publish */
1223 Want want;
1224 want.SetAction("usual.event.BOOT_COMPLETED");
1225 CommonEventData data;
1226 data.SetWant(want);
1227
1228 CommonEventPublishInfo publishInfo;
1229 std::vector<std::string> subscriberPermissions;
1230 publishInfo.SetOrdered(true);
1231 subscriberPermissions.emplace_back("456");
1232 publishInfo.SetSubscriberPermissions(subscriberPermissions);
1233 bool result = inner.PublishCommonEvent(
1234 data, publishInfo, listener, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case1");
1235 sleep(PUBLISH_SLEEP);
1236 EXPECT_TRUE(result);
1237 inner.UnsubscribeCommonEvent(listener);
1238 }
1239
1240 /*
1241 * @tc.number: CommonEventPublishPermissionEventUnitTest_3100
1242 * @tc.name: test unordered event permission and system send is no
1243 * @tc.desc: 1. subscriber permission is empty
1244 * 2. publish permission is not empty
1245 * 3. event has one attribute
1246 */
1247 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3100,
1248 Function | MediumTest | Level1)
1249 {
1250 GTEST_LOG_(INFO)
1251 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3100, TestSize.Level1";
1252 /* subscriber */
1253 InnerCommonEventManager inner;
1254 struct tm curTime {
1255 0
1256 };
1257 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1258 MatchingSkills matchingSkillsObj;
1259 matchingSkillsObj.AddEvent("usual.event.USER_SWITCHED");
1260 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
1261 subscribeInfo.SetPermission("");
1262 subscribeInfo.SetPriority(1);
1263 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
1264 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
1265 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case2");
1266
1267 /* Publish */
1268 Want want;
1269 want.SetAction("usual.event.USER_SWITCHED");
1270 CommonEventData data;
1271 data.SetWant(want);
1272
1273 CommonEventPublishInfo publishInfo;
1274 std::vector<std::string> subscriberPermissions;
1275 publishInfo.SetOrdered(true);
1276 subscriberPermissions.emplace_back("456");
1277 publishInfo.SetSubscriberPermissions(subscriberPermissions);
1278 bool result = inner.PublishCommonEvent(
1279 data, publishInfo, listener, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case2");
1280 sleep(PUBLISH_SLEEP);
1281 EXPECT_TRUE(result);
1282 inner.UnsubscribeCommonEvent(listener);
1283 }
1284
1285 /*
1286 * @tc.number: CommonEventPublishPermissionEventUnitTest_3200
1287 * @tc.name: test unordered event permission and system send is no
1288 * @tc.desc: 1. subscriber permission is empty
1289 * 2. publish permission is not empty
1290 * 3. event has two attribute and logic and
1291 */
1292 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3200,
1293 Function | MediumTest | Level1)
1294 {
1295 GTEST_LOG_(INFO)
1296 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3200, TestSize.Level1";
1297 /* subscriber */
1298 InnerCommonEventManager inner;
1299 struct tm curTime {
1300 0
1301 };
1302 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1303 MatchingSkills matchingSkillsObj;
1304 matchingSkillsObj.AddEvent("usual.event.wifi.p2p.CONN_STATE_CHANGE");
1305 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
1306 subscribeInfo.SetPermission("");
1307 subscribeInfo.SetPriority(1);
1308 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
1309 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
1310 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case3");
1311
1312 /* Publish */
1313 Want want;
1314 want.SetAction("usual.event.wifi.p2p.CONN_STATE_CHANGE");
1315 CommonEventData data;
1316 data.SetWant(want);
1317
1318 CommonEventPublishInfo publishInfo;
1319 std::vector<std::string> subscriberPermissions;
1320 publishInfo.SetOrdered(true);
1321 subscriberPermissions.emplace_back("456");
1322 publishInfo.SetSubscriberPermissions(subscriberPermissions);
1323 bool result = inner.PublishCommonEvent(
1324 data, publishInfo, listener, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case3");
1325 sleep(PUBLISH_SLEEP);
1326 EXPECT_TRUE(result);
1327 inner.UnsubscribeCommonEvent(listener);
1328 }
1329
1330 /*
1331 * @tc.number: CommonEventPublishPermissionEventUnitTest_3300
1332 * @tc.name: test unordered event permission and system send is yes
1333 * @tc.desc: 1. subscriber permission is empty
1334 * 2. publish permission is not empty
1335 * 3. event has two attribute and logic or
1336 */
1337 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3300,
1338 Function | MediumTest | Level1)
1339 {
1340 GTEST_LOG_(INFO)
1341 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3300, TestSize.Level1";
1342 /* subscriber */
1343 InnerCommonEventManager inner;
1344 struct tm curTime {
1345 0
1346 };
1347 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1348 MatchingSkills matchingSkillsObj;
1349 matchingSkillsObj.AddEvent("usual.event.data.DISK_REMOVED");
1350 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
1351 subscribeInfo.SetPermission("");
1352 subscribeInfo.SetPriority(1);
1353 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
1354 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
1355 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case4");
1356
1357 /* Publish */
1358 Want want;
1359 want.SetAction("usual.event.data.DISK_REMOVED");
1360 CommonEventData data;
1361 data.SetWant(want);
1362
1363 CommonEventPublishInfo publishInfo;
1364 std::vector<std::string> subscriberPermissions;
1365 publishInfo.SetOrdered(true);
1366 subscriberPermissions.emplace_back("456");
1367 publishInfo.SetSubscriberPermissions(subscriberPermissions);
1368 bool result = inner.PublishCommonEvent(
1369 data, publishInfo, listener, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case4");
1370 sleep(PUBLISH_SLEEP);
1371 EXPECT_TRUE(result);
1372 inner.UnsubscribeCommonEvent(listener);
1373 }
1374
1375 /*
1376 * @tc.number: CommonEventPublishPermissionEventUnitTest_3400
1377 * @tc.name: test unordered event permission and system send is yes
1378 * @tc.desc: 1. subscriber permission is empty
1379 * 2. publish permission is not empty
1380 * 3. event has no attribute
1381 */
1382 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3400,
1383 Function | MediumTest | Level1)
1384 {
1385 GTEST_LOG_(INFO)
1386 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3400, TestSize.Level1";
1387 /* subscriber */
1388 InnerCommonEventManager inner;
1389 struct tm curTime {
1390 0
1391 };
1392 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
1393 MatchingSkills matchingSkillsObj;
1394 matchingSkillsObj.AddEvent("common.event.IVI_TEMPERATURE_RECOVERY");
1395 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
1396 subscribeInfo.SetPermission("");
1397 subscribeInfo.SetPriority(1);
1398 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
1399 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
1400 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case6");
1401
1402 /* Publish */
1403 Want want;
1404 want.SetAction("common.event.IVI_TEMPERATURE_RECOVERY");
1405 CommonEventData data;
1406 data.SetWant(want);
1407
1408 CommonEventPublishInfo publishInfo;
1409 std::vector<std::string> subscriberPermissions;
1410 publishInfo.SetOrdered(true);
1411 subscriberPermissions.emplace_back("456");
1412 publishInfo.SetSubscriberPermissions(subscriberPermissions);
1413 bool result = inner.PublishCommonEvent(
1414 data, publishInfo, listener, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case6");
1415 sleep(PUBLISH_SLEEP);
1416 EXPECT_TRUE(result);
1417 inner.UnsubscribeCommonEvent(listener);
1418 }
1419