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 | Level0)
107 {
108 GTEST_LOG_(INFO)
109 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0100, TestSize.Level0";
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 | Level0)
148 {
149 GTEST_LOG_(INFO)
150 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0200, TestSize.Level0";
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 | Level0)
191 {
192 GTEST_LOG_(INFO)
193 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0300, TestSize.Level0";
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 | Level0)
234 {
235 GTEST_LOG_(INFO)
236 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0400, TestSize.Level0";
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_0800
271 * @tc.name: test CommonEventControlManager permission
272 * @tc.desc: 1. subscriber permission is empty
273 * 2. publish permission is not empty
274 * 3. function CheckPermission return OrderedEventRecord::DELIVERED
275 */
276 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0800,
277 Function | MediumTest | Level0)
278 {
279 GTEST_LOG_(INFO)
280 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0800, TestSize.Level0";
281
282 CommonEventSubscribeInfo commonEventSubscribeInfo;
283 commonEventSubscribeInfo.SetPermission("");
284 std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
285 std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
286 EventSubscriberRecord eventSubRecord;
287 eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
288
289 CommonEventPublishInfo commonEventPublishInfo;
290 std::vector<std::string> vecstr;
291 vecstr.emplace_back("456");
292 commonEventPublishInfo.SetSubscriberPermissions(vecstr);
293 std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
294 std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
295 Want want;
296 want.SetAction("1234");
297 std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
298 spCommonEventData->SetWant(want);
299 CommonEventRecord commonEventRecord;
300 commonEventRecord.publishInfo = commonEventPublishInfoSptr;
301 commonEventRecord.commonEventData = spCommonEventData;
302
303 CommonEventControlManager commonEventControlManager;
304 bool result = commonEventControlManager.NotifyFreezeEvents(eventSubRecord, commonEventRecord);
305 EXPECT_EQ(false, result);
306 }
307
308 /*
309 * @tc.number: CommonEventPublishPermissionEventUnitTest_0900
310 * @tc.name: test CommonEventControlManager permission
311 * @tc.desc: 1. subscriber permission is empty
312 * 2. publish permission is not empty
313 * 3. function CheckPermission return OrderedEventRecord::SKIPPED
314 */
315 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0900,
316 Function | MediumTest | Level0)
317 {
318 GTEST_LOG_(INFO)
319 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_0900, TestSize.Level0";
320
321 CommonEventSubscribeInfo commonEventSubscribeInfo;
322 commonEventSubscribeInfo.SetPermission("");
323 std::shared_ptr<CommonEventSubscribeInfo> commonEventSubscribeInfoSptr =
324 std::make_shared<CommonEventSubscribeInfo>(commonEventSubscribeInfo);
325 EventSubscriberRecord eventSubRecord;
326 eventSubRecord.eventSubscribeInfo = commonEventSubscribeInfoSptr;
327 eventSubRecord.eventRecordInfo.bundleName = "hello world";
328 eventSubRecord.eventRecordInfo.callerToken = 1;
329
330 CommonEventPublishInfo commonEventPublishInfo;
331 std::vector<std::string> vecstr;
332 vecstr.emplace_back("456");
333 commonEventPublishInfo.SetSubscriberPermissions(vecstr);
334 std::shared_ptr<CommonEventPublishInfo> commonEventPublishInfoSptr =
335 std::make_shared<CommonEventPublishInfo>(commonEventPublishInfo);
336 Want want;
337 want.SetAction("1234");
338 std::shared_ptr<CommonEventData> spCommonEventData = std::make_shared<CommonEventData>();
339 spCommonEventData->SetWant(want);
340 CommonEventRecord commonEventRecord;
341 commonEventRecord.publishInfo = commonEventPublishInfoSptr;
342 commonEventRecord.commonEventData = spCommonEventData;
343
344 CommonEventControlManager commonEventControlManager;
345
346 bool result = commonEventControlManager.NotifyFreezeEvents(eventSubRecord, commonEventRecord);
347 EXPECT_EQ(false, result);
348 }
349
350 /*
351 * @tc.number: CommonEventPublishPermissionEventUnitTest_1500
352 * @tc.name: test InnerCommonEventManager permission
353 * @tc.desc: function CheckPermission return false
354 */
355 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1500,
356 Function | MediumTest | Level0)
357 {
358 GTEST_LOG_(INFO)
359 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_1500, TestSize.Level0";
360
361 InnerCommonEventManager inner;
362 struct tm curTime {0};
363 OHOS::Security::AccessToken::AccessTokenID tokenID = 1;
364
365 Want want;
366 want.SetAction("1234");
367 CommonEventData data;
368 data.SetWant(want);
369 CommonEventPublishInfo publishInfo;
370 publishInfo.SetOrdered(true);
371 publishInfo.SetSticky(true);
372 EXPECT_FALSE(inner.PublishCommonEvent(
373 data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "hello world"));
374 }
375
376 /*
377 * @tc.number: CommonEventPublishPermissionEventUnitTest_2200
378 * @tc.name: test CommonEventPermissionManager GetEventPermission
379 * @tc.desc: 1. subscriber permission is not empty and has one permission
380 * 2. function subscriber CheckPermission return name size
381 */
382 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2200,
383 Function | MediumTest | Level0)
384 {
385 GTEST_LOG_(INFO) << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2200, "
386 "TestSize.Level0";
387
388 std::string event = "usual.event.BOOT_COMPLETED";
389
390 int ret = DelayedSingleton<CommonEventPermissionManager>::GetInstance()->GetEventPermission(event).names.size();
391
392 EXPECT_TRUE(ret > 0);
393 }
394
395 /*
396 * @tc.number: CommonEventPublishPermissionEventUnitTest_2200
397 * @tc.name: test CommonEventPermissionManager GetEventPermission
398 * @tc.desc: 1. subscriber permission is not empty and has two permission and is Logic and
399 * 2. function subscriber CheckPermission return name size
400 */
401 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2300,
402 Function | MediumTest | Level0)
403 {
404 GTEST_LOG_(INFO) << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2300, "
405 "TestSize.Level0";
406
407 std::string event = "usual.event.wifi.p2p.CONN_STATE_CHANGE";
408
409 Permission per = DelayedSingleton<CommonEventPermissionManager>::GetInstance()->GetEventPermission(event);
410 int ret = per.names.size();
411 PermissionState state = per.state;
412
413 EXPECT_TRUE(ret > 0);
414 EXPECT_TRUE(state == PermissionState::AND);
415 }
416
417 /*
418 * @tc.number: CommonEventPublishPermissionEventUnitTest_2200
419 * @tc.name: test CommonEventPermissionManager GetEventPermission
420 * @tc.desc: 1. subscriber permission is not empty and has two permission and is Logic or
421 * 2. function subscriber CheckPermission return name size
422 */
423 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2400,
424 Function | MediumTest | Level0)
425 {
426 GTEST_LOG_(INFO) << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2400, "
427 "TestSize.Level0";
428
429 std::string event = "usual.event.data.DISK_REMOVED";
430
431 Permission per = DelayedSingleton<CommonEventPermissionManager>::GetInstance()->GetEventPermission(event);
432 int ret = per.names.size();
433 PermissionState state = per.state;
434
435 EXPECT_TRUE(ret > 0);
436 EXPECT_TRUE(state == PermissionState::DEFAULT);
437 }
438
439 /*
440 * @tc.number: CommonEventPublishPermissionEventUnitTest_2500
441 * @tc.name: test unordered event permission and system send is yes
442 * @tc.desc: 1. subscriber permission is empty
443 * 2. publish permission is not empty
444 * 3. event has one attribute
445 */
446 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2500,
447 Function | MediumTest | Level0)
448 {
449 GTEST_LOG_(INFO)
450 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2500, TestSize.Level0";
451 /* subscriber */
452 InnerCommonEventManager inner;
453 struct tm curTime {
454 0
455 };
456 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
457 MatchingSkills matchingSkillsObj;
458 matchingSkillsObj.AddEvent("usual.event.nfc.action.RF_FIELD_ON_DETECTED");
459 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
460 subscribeInfo.SetPermission("123");
461 subscribeInfo.SetPriority(1);
462 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
463 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
464 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case1");
465
466 /* Publish */
467 Want want;
468 want.SetAction("usual.event.nfc.action.RF_FIELD_ON_DETECTED");
469 CommonEventData data;
470 data.SetWant(want);
471
472 CommonEventPublishInfo publishInfo;
473 std::vector<std::string> subscriberPermissions;
474 publishInfo.SetOrdered(false);
475 subscriberPermissions.emplace_back("456");
476 publishInfo.SetSubscriberPermissions(subscriberPermissions);
477 bool result = inner.PublishCommonEvent(
478 data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case1");
479 sleep(PUBLISH_SLEEP);
480 EXPECT_TRUE(result);
481 inner.UnsubscribeCommonEvent(listener);
482 }
483
484 /*
485 * @tc.number: CommonEventPublishPermissionEventUnitTest_2600
486 * @tc.name: test unordered event permission and system send is no
487 * @tc.desc: 1. subscriber permission is empty
488 * 2. publish permission is not empty
489 * 3. event has one attribute
490 */
491 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2600,
492 Function | MediumTest | Level0)
493 {
494 GTEST_LOG_(INFO)
495 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2600, TestSize.Level0";
496 /* subscriber */
497 InnerCommonEventManager inner;
498 struct tm curTime {
499 0
500 };
501 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
502 MatchingSkills matchingSkillsObj;
503 matchingSkillsObj.AddEvent("usual.event.wifi.mplink.STATE_CHANGE");
504 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
505 subscribeInfo.SetPermission("");
506 subscribeInfo.SetPriority(1);
507 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
508 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
509 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case2");
510
511 /* Publish */
512 Want want;
513 want.SetAction("usual.event.wifi.mplink.STATE_CHANGE");
514 CommonEventData data;
515 data.SetWant(want);
516
517 CommonEventPublishInfo publishInfo;
518 std::vector<std::string> subscriberPermissions;
519 publishInfo.SetOrdered(false);
520 subscriberPermissions.emplace_back("456");
521 publishInfo.SetSubscriberPermissions(subscriberPermissions);
522 bool result = inner.PublishCommonEvent(
523 data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case2");
524 sleep(PUBLISH_SLEEP);
525 EXPECT_TRUE(result);
526 inner.UnsubscribeCommonEvent(listener);
527 }
528
529 /*
530 * @tc.number: CommonEventPublishPermissionEventUnitTest_2700
531 * @tc.name: test unordered event permission and system send is no
532 * @tc.desc: 1. subscriber permission is empty
533 * 2. publish permission is not empty
534 * 3. event has two attribute and logic and
535 */
536 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2700,
537 Function | MediumTest | Level0)
538 {
539 GTEST_LOG_(INFO)
540 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2700, TestSize.Level0";
541 /* subscriber */
542 InnerCommonEventManager inner;
543 struct tm curTime {
544 0
545 };
546 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
547 MatchingSkills matchingSkillsObj;
548 matchingSkillsObj.AddEvent("usual.event.bluetooth.remotedevice.DISCOVERED");
549 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
550 subscribeInfo.SetPermission("");
551 subscribeInfo.SetPriority(1);
552 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
553 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
554 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case3");
555
556 /* Publish */
557 Want want;
558 want.SetAction("usual.event.bluetooth.remotedevice.DISCOVERED");
559 CommonEventData data;
560 data.SetWant(want);
561
562 CommonEventPublishInfo publishInfo;
563 std::vector<std::string> subscriberPermissions;
564 publishInfo.SetOrdered(false);
565 subscriberPermissions.emplace_back("456");
566 publishInfo.SetSubscriberPermissions(subscriberPermissions);
567 bool result = inner.PublishCommonEvent(
568 data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case3");
569 sleep(PUBLISH_SLEEP);
570 EXPECT_TRUE(result);
571 inner.UnsubscribeCommonEvent(listener);
572 }
573
574 /*
575 * @tc.number: CommonEventPublishPermissionEventUnitTest_2800
576 * @tc.name: test unordered event permission and system send is yes
577 * @tc.desc: 1. subscriber permission is empty
578 * 2. publish permission is not empty
579 * 3. event has two attribute and logic or
580 */
581 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2800,
582 Function | MediumTest | Level0)
583 {
584 GTEST_LOG_(INFO)
585 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2800, TestSize.Level0";
586 /* subscriber */
587 InnerCommonEventManager inner;
588 struct tm curTime {
589 0
590 };
591 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
592 MatchingSkills matchingSkillsObj;
593 matchingSkillsObj.AddEvent("usual.event.data.DISK_MOUNTED");
594 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
595 subscribeInfo.SetPermission("");
596 subscribeInfo.SetPriority(1);
597 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
598 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
599 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case4");
600
601 /* Publish */
602 Want want;
603 want.SetAction("usual.event.data.DISK_MOUNTED");
604 CommonEventData data;
605 data.SetWant(want);
606
607 CommonEventPublishInfo publishInfo;
608 std::vector<std::string> subscriberPermissions;
609 publishInfo.SetOrdered(false);
610 subscriberPermissions.emplace_back("456");
611 publishInfo.SetSubscriberPermissions(subscriberPermissions);
612 bool result = inner.PublishCommonEvent(
613 data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case4");
614 sleep(PUBLISH_SLEEP);
615 EXPECT_TRUE(result);
616 inner.UnsubscribeCommonEvent(listener);
617 }
618
619 /*
620 * @tc.number: CommonEventPublishPermissionEventUnitTest_2900
621 * @tc.name: test unordered event permission and system send is yes
622 * @tc.desc: 1. subscriber permission is empty
623 * 2. publish permission is not empty
624 * 3. event has no attribute
625 */
626 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2900,
627 Function | MediumTest | Level0)
628 {
629 GTEST_LOG_(INFO)
630 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_2900, TestSize.Level0";
631 /* subscriber */
632 InnerCommonEventManager inner;
633 struct tm curTime {
634 0
635 };
636 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
637 MatchingSkills matchingSkillsObj;
638 matchingSkillsObj.AddEvent("common.event.IVI_TEMPERATURE_RECOVERY");
639 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
640 subscribeInfo.SetPermission("");
641 subscribeInfo.SetPriority(1);
642 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
643 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
644 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case6");
645
646 /* Publish */
647 Want want;
648 want.SetAction("common.event.IVI_TEMPERATURE_RECOVERY");
649 CommonEventData data;
650 data.SetWant(want);
651
652 CommonEventPublishInfo publishInfo;
653 std::vector<std::string> subscriberPermissions;
654 publishInfo.SetOrdered(false);
655 subscriberPermissions.emplace_back("456");
656 publishInfo.SetSubscriberPermissions(subscriberPermissions);
657 bool result = inner.PublishCommonEvent(
658 data, publishInfo, nullptr, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case6");
659 sleep(PUBLISH_SLEEP);
660 EXPECT_TRUE(result);
661 inner.UnsubscribeCommonEvent(listener);
662 }
663
664 /*
665 * @tc.number: CommonEventPublishPermissionEventUnitTest_3000
666 * @tc.name: test ordered event permission and system send is yes
667 * @tc.desc: 1. subscriber permission is empty
668 * 2. publish permission is not empty
669 * 3. event has one attribute
670 */
671 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3000,
672 Function | MediumTest | Level0)
673 {
674 GTEST_LOG_(INFO)
675 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3000, TestSize.Level0";
676 /* subscriber */
677 InnerCommonEventManager inner;
678 struct tm curTime {
679 0
680 };
681 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
682 MatchingSkills matchingSkillsObj;
683 matchingSkillsObj.AddEvent("usual.event.BOOT_COMPLETED_TEST");
684 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
685 subscribeInfo.SetPermission("123");
686 subscribeInfo.SetPriority(1);
687 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
688 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
689 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case1");
690
691 /* Publish */
692 Want want;
693 want.SetAction("usual.event.BOOT_COMPLETED_TEST");
694 CommonEventData data;
695 data.SetWant(want);
696
697 CommonEventPublishInfo publishInfo;
698 std::vector<std::string> subscriberPermissions;
699 publishInfo.SetOrdered(true);
700 subscriberPermissions.emplace_back("456");
701 publishInfo.SetSubscriberPermissions(subscriberPermissions);
702 bool result = inner.PublishCommonEvent(
703 data, publishInfo, listener, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case1");
704 sleep(PUBLISH_SLEEP);
705 EXPECT_TRUE(result);
706 inner.UnsubscribeCommonEvent(listener);
707 }
708
709 /*
710 * @tc.number: CommonEventPublishPermissionEventUnitTest_3100
711 * @tc.name: test unordered event permission and system send is no
712 * @tc.desc: 1. subscriber permission is empty
713 * 2. publish permission is not empty
714 * 3. event has one attribute
715 */
716 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3100,
717 Function | MediumTest | Level0)
718 {
719 GTEST_LOG_(INFO)
720 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3100, TestSize.Level0";
721 /* subscriber */
722 InnerCommonEventManager inner;
723 struct tm curTime {
724 0
725 };
726 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
727 MatchingSkills matchingSkillsObj;
728 matchingSkillsObj.AddEvent("usual.event.USER_SWITCHED_TEST");
729 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
730 subscribeInfo.SetPermission("");
731 subscribeInfo.SetPriority(1);
732 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
733 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
734 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case2");
735
736 /* Publish */
737 Want want;
738 want.SetAction("usual.event.USER_SWITCHED_TEST");
739 CommonEventData data;
740 data.SetWant(want);
741
742 CommonEventPublishInfo publishInfo;
743 std::vector<std::string> subscriberPermissions;
744 publishInfo.SetOrdered(true);
745 subscriberPermissions.emplace_back("456");
746 publishInfo.SetSubscriberPermissions(subscriberPermissions);
747 bool result = inner.PublishCommonEvent(
748 data, publishInfo, listener, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case2");
749 sleep(PUBLISH_SLEEP);
750 EXPECT_TRUE(result);
751 inner.UnsubscribeCommonEvent(listener);
752 }
753
754 /*
755 * @tc.number: CommonEventPublishPermissionEventUnitTest_3200
756 * @tc.name: test unordered event permission and system send is no
757 * @tc.desc: 1. subscriber permission is empty
758 * 2. publish permission is not empty
759 * 3. event has two attribute and logic and
760 */
761 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3200,
762 Function | MediumTest | Level0)
763 {
764 GTEST_LOG_(INFO)
765 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3200, TestSize.Level0";
766 /* subscriber */
767 InnerCommonEventManager inner;
768 struct tm curTime {
769 0
770 };
771 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
772 MatchingSkills matchingSkillsObj;
773 matchingSkillsObj.AddEvent("usual.event.wifi.p2p.CONN_STATE_CHANGE");
774 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
775 subscribeInfo.SetPermission("");
776 subscribeInfo.SetPriority(1);
777 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
778 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
779 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case3");
780
781 /* Publish */
782 Want want;
783 want.SetAction("usual.event.wifi.p2p.CONN_STATE_CHANGE");
784 CommonEventData data;
785 data.SetWant(want);
786
787 CommonEventPublishInfo publishInfo;
788 std::vector<std::string> subscriberPermissions;
789 publishInfo.SetOrdered(true);
790 subscriberPermissions.emplace_back("456");
791 publishInfo.SetSubscriberPermissions(subscriberPermissions);
792 bool result = inner.PublishCommonEvent(
793 data, publishInfo, listener, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case3");
794 sleep(PUBLISH_SLEEP);
795 EXPECT_TRUE(result);
796 inner.UnsubscribeCommonEvent(listener);
797 }
798
799 /*
800 * @tc.number: CommonEventPublishPermissionEventUnitTest_3300
801 * @tc.name: test unordered event permission and system send is yes
802 * @tc.desc: 1. subscriber permission is empty
803 * 2. publish permission is not empty
804 * 3. event has two attribute and logic or
805 */
806 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3300,
807 Function | MediumTest | Level0)
808 {
809 GTEST_LOG_(INFO)
810 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3300, TestSize.Level0";
811 /* subscriber */
812 InnerCommonEventManager inner;
813 struct tm curTime {
814 0
815 };
816 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
817 MatchingSkills matchingSkillsObj;
818 matchingSkillsObj.AddEvent("usual.event.data.DISK_REMOVED");
819 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
820 subscribeInfo.SetPermission("");
821 subscribeInfo.SetPriority(1);
822 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
823 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
824 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case4");
825
826 /* Publish */
827 Want want;
828 want.SetAction("usual.event.data.DISK_REMOVED");
829 CommonEventData data;
830 data.SetWant(want);
831
832 CommonEventPublishInfo publishInfo;
833 std::vector<std::string> subscriberPermissions;
834 publishInfo.SetOrdered(true);
835 subscriberPermissions.emplace_back("456");
836 publishInfo.SetSubscriberPermissions(subscriberPermissions);
837 bool result = inner.PublishCommonEvent(
838 data, publishInfo, listener, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case4");
839 sleep(PUBLISH_SLEEP);
840 EXPECT_TRUE(result);
841 inner.UnsubscribeCommonEvent(listener);
842 }
843
844 /*
845 * @tc.number: CommonEventPublishPermissionEventUnitTest_3400
846 * @tc.name: test unordered event permission and system send is yes
847 * @tc.desc: 1. subscriber permission is empty
848 * 2. publish permission is not empty
849 * 3. event has no attribute
850 */
851 HWTEST_F(CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3400,
852 Function | MediumTest | Level0)
853 {
854 GTEST_LOG_(INFO)
855 << "CommonEventPublishPermissionEventUnitTest, CommonEventPublishPermissionEventUnitTest_3400, TestSize.Level0";
856 /* subscriber */
857 InnerCommonEventManager inner;
858 struct tm curTime {
859 0
860 };
861 OHOS::Security::AccessToken::AccessTokenID tokenID = 0;
862 MatchingSkills matchingSkillsObj;
863 matchingSkillsObj.AddEvent("common.event.IVI_TEMPERATURE_RECOVERY");
864 CommonEventSubscribeInfo subscribeInfo(matchingSkillsObj);
865 subscribeInfo.SetPermission("");
866 subscribeInfo.SetPriority(1);
867 std::shared_ptr<SubscriberTest> subscriber = std::make_shared<SubscriberTest>(subscribeInfo);
868 auto listener = sptr<IRemoteObject>(new CommonEventListener(subscriber));
869 inner.SubscribeCommonEvent(subscribeInfo, listener, curTime, PID, SYSTEM_UID, tokenID, "case6");
870
871 /* Publish */
872 Want want;
873 want.SetAction("common.event.IVI_TEMPERATURE_RECOVERY");
874 CommonEventData data;
875 data.SetWant(want);
876
877 CommonEventPublishInfo publishInfo;
878 std::vector<std::string> subscriberPermissions;
879 publishInfo.SetOrdered(true);
880 subscriberPermissions.emplace_back("456");
881 publishInfo.SetSubscriberPermissions(subscriberPermissions);
882 bool result = inner.PublishCommonEvent(
883 data, publishInfo, listener, curTime, PID, SYSTEM_UID, tokenID, UNDEFINED_USER, "case6");
884 sleep(PUBLISH_SLEEP);
885 EXPECT_TRUE(result);
886 inner.UnsubscribeCommonEvent(listener);
887 }
888