1 /*
2 * Copyright (c) 2021-2025 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 #include <iostream>
18 #include <thread>
19
20 #define private public
21 #include "notification_subscriber.h"
22 #include "notification_subscriber_manager.h"
23 #include "mock_ans_subscriber.h"
24 #include "ans_const_define.h"
25 #include "notification_preferences.h"
26
27 #include "ans_inner_errors.h"
28 #include "ans_subscriber_listener.h"
29 #include "mock_i_remote_object.h"
30
31 extern void MockGetOsAccountLocalIdFromUid(bool mockRet, uint8_t mockCase = 0);
32
33 using namespace testing::ext;
34 using namespace testing;
35
36 namespace OHOS {
37 namespace Notification {
38 class MockAnsSubscriberTest : public MockAnsSubscriber {
39 public:
AsObject()40 sptr<IRemoteObject> AsObject() override
41 {
42 return new MockIRemoteObject();
43 }
44
OnConsumed(const sptr<Notification> & notification,const sptr<NotificationSortingMap> & notificationMap)45 ErrCode OnConsumed(const sptr<Notification> ¬ification,
46 const sptr<NotificationSortingMap> ¬ificationMap) override
47 {
48 isCalled_ = true;
49 return ERR_OK;
50 }
51
OnConsumed(const sptr<Notification> & notification)52 ErrCode OnConsumed(const sptr<Notification> ¬ification) override
53 {
54 isCalled_ = true;
55 return ERR_OK;
56 };
57
OnConsumedWithMaxCapacity(const sptr<Notification> & notification,const sptr<NotificationSortingMap> & notificationMap)58 ErrCode OnConsumedWithMaxCapacity(
59 const sptr<Notification> ¬ification,
60 const sptr<NotificationSortingMap> ¬ificationMap) override
61 {
62 isCalled_ = true;
63 return ERR_OK;
64 };
65
OnConsumedWithMaxCapacity(const sptr<Notification> & notification)66 ErrCode OnConsumedWithMaxCapacity(const sptr<Notification> ¬ification) override
67 {
68 isCalled_ = true;
69 return ERR_OK;
70 };
71
IsCalled()72 bool IsCalled()
73 {
74 return isCalled_;
75 }
76
77 private:
78 bool isCalled_{false};
79 };
80
81 class NotificationSubscriberManagerTest : public testing::Test {
82 public:
83 static void SetUpTestCase();
84 static void TearDownTestCase();
85 void SetUp();
86 void TearDown();
87
88 private:
89 class TestAnsSubscriber : public NotificationSubscriber {
90 public:
OnConnected()91 void OnConnected() override
92 {}
OnDisconnected()93 void OnDisconnected() override
94 {}
OnDied()95 void OnDied() override
96 {}
OnEnabledNotificationChanged(const std::shared_ptr<EnabledNotificationCallbackData> & callbackData)97 void OnEnabledNotificationChanged(
98 const std::shared_ptr<EnabledNotificationCallbackData> &callbackData) override
99 {
100 isCallback_ = true;
101 }
OnCanceled(const std::shared_ptr<Notification> & request,const std::shared_ptr<NotificationSortingMap> & sortingMap,int deleteReason)102 void OnCanceled(const std::shared_ptr<Notification> &request,
103 const std::shared_ptr<NotificationSortingMap> &sortingMap, int deleteReason) override
104 {
105 isCallback_ = true;
106 }
OnConsumed(const std::shared_ptr<Notification> & request,const std::shared_ptr<NotificationSortingMap> & sortingMap)107 void OnConsumed(const std::shared_ptr<Notification> &request,
108 const std::shared_ptr<NotificationSortingMap> &sortingMap) override
109 {
110 isCallback_ = true;
111 }
OnUpdate(const std::shared_ptr<NotificationSortingMap> & sortingMap)112 void OnUpdate(const std::shared_ptr<NotificationSortingMap> &sortingMap) override
113 {
114 isCallback_ = true;
115 }
OnDoNotDisturbDateChange(const std::shared_ptr<NotificationDoNotDisturbDate> & date)116 void OnDoNotDisturbDateChange(const std::shared_ptr<NotificationDoNotDisturbDate> &date) override
117 {
118 isCallback_ = true;
119 }
OnBadgeChanged(const std::shared_ptr<BadgeNumberCallbackData> & badgeData)120 void OnBadgeChanged(const std::shared_ptr<BadgeNumberCallbackData> &badgeData) override
121 {
122 isCallback_ = true;
123 }
OnBadgeEnabledChanged(const sptr<EnabledNotificationCallbackData> & callbackData)124 void OnBadgeEnabledChanged(const sptr<EnabledNotificationCallbackData> &callbackData) override
125 {
126 isCallback_ = true;
127 }
OnBatchCanceled(const std::vector<std::shared_ptr<Notification>> & requestList,const std::shared_ptr<NotificationSortingMap> & sortingMap,int32_t deleteReason)128 void OnBatchCanceled(const std::vector<std::shared_ptr<Notification>> &requestList,
129 const std::shared_ptr<NotificationSortingMap> &sortingMap, int32_t deleteReason) override
130 {
131 isCallback_ = true;
132 }
OnApplicationInfoNeedChanged(const std::string & bundleName)133 void OnApplicationInfoNeedChanged(const std::string& bundleName) override
134 {
135 isCallback_ = true;
136 }
137
OnOperationResponse(const std::shared_ptr<NotificationOperationInfo> & operationInfo)138 ErrCode OnOperationResponse(const std::shared_ptr<NotificationOperationInfo> &operationInfo)
139 {
140 isCallback_ = true;
141 return ERR_OK;
142 }
143
GetCallBack()144 bool GetCallBack()
145 {
146 return isCallback_;
147 }
148
SetCallBack(bool isCallback)149 void SetCallBack(bool isCallback)
150 {
151 isCallback_ = isCallback;
152 }
153
154 private:
155 bool isCallback_;
156 };
157
158 static std::shared_ptr<NotificationSubscriberManager> notificationSubscriberManager_;
159 static TestAnsSubscriber testAnsSubscriber_;
160 static sptr<IAnsSubscriber> subscriber_;
161 };
162
163 std::shared_ptr<NotificationSubscriberManager> NotificationSubscriberManagerTest::notificationSubscriberManager_ =
164 nullptr;
165 sptr<IAnsSubscriber> NotificationSubscriberManagerTest::subscriber_ = nullptr;
166
SetUpTestCase()167 void NotificationSubscriberManagerTest::SetUpTestCase()
168 {
169 notificationSubscriberManager_ = NotificationSubscriberManager::GetInstance();
170 std::shared_ptr<NotificationSubscriber> testAnsSubscriber = std::make_shared<TestAnsSubscriber>();
171 subscriber_ = new (std::nothrow) SubscriberListener(testAnsSubscriber);
172 }
173
TearDownTestCase()174 void NotificationSubscriberManagerTest::TearDownTestCase()
175 {
176 subscriber_ = nullptr;
177 if (notificationSubscriberManager_ != nullptr) {
178 notificationSubscriberManager_->ResetFfrtQueue();
179 notificationSubscriberManager_ = nullptr;
180 }
181 }
182
SetUp()183 void NotificationSubscriberManagerTest::SetUp()
184 {
185 MockGetOsAccountLocalIdFromUid(true, 0);
186 notificationSubscriberManager_->AddSubscriber(subscriber_, nullptr);
187 }
188
TearDown()189 void NotificationSubscriberManagerTest::TearDown()
190 {
191 notificationSubscriberManager_->RemoveSubscriber(subscriber_, nullptr);
192 }
193
194 /**
195 * @tc.number : NotificationSubscriberManagerTest_001
196 * @tc.name : ANS_AddSubscriber_0100
197 * @tc.desc : Test AddSubscriber function, return is ERR_OK.
198 */
199 HWTEST_F(NotificationSubscriberManagerTest, NotificationSubscriberManagerTest_001, Function | SmallTest | Level1)
200 {
201 // Test NotifyUpdated function.
202 const std::vector<NotificationSorting> sortingList;
203 sptr<NotificationSortingMap> map = new NotificationSortingMap(sortingList);
204 notificationSubscriberManager_->NotifyUpdated(map);
205
206 // Test AddSubscriber function.
207 sptr<NotificationSubscribeInfo> info = new NotificationSubscribeInfo();
208 info->AddAppName("test_bundle");
209 ASSERT_EQ(notificationSubscriberManager_->AddSubscriber(subscriber_, info), (int)ERR_OK);
210 ASSERT_EQ(notificationSubscriberManager_->AddSubscriber(subscriber_, nullptr), (int)ERR_OK);
211 }
212
213 /**
214 * @tc.number : NotificationSubscriberManagerTest_002
215 * @tc.name : ANS_AddSubscriber_0100
216 * @tc.desc : Test AddSubscriber function when subscriber is nullptr, return is ERR_ANS_INVALID_PARAM.
217 */
218 HWTEST_F(NotificationSubscriberManagerTest, NotificationSubscriberManagerTest_002, Function | SmallTest | Level1)
219 {
220 // Test NotifyDisturbModeChanged function.
221 sptr<NotificationDoNotDisturbDate> date =
222 new NotificationDoNotDisturbDate(NotificationConstant::DoNotDisturbType::NONE, 0, 0);
223 std::string bundle = "com.example.test";
224 notificationSubscriberManager_->NotifyDoNotDisturbDateChanged(0, date, bundle);
225
226 // Test AddSubscriber function.
227 sptr<NotificationSubscribeInfo> info = new NotificationSubscribeInfo();
228 ASSERT_EQ(notificationSubscriberManager_->AddSubscriber(nullptr, info), (int)ERR_ANS_INVALID_PARAM);
229 }
230
231 /**
232 * @tc.number : NotificationSubscriberManagerTest_003
233 * @tc.name : ANS_RemoveSubscriber_0100
234 * @tc.desc : Test RemoveSubscriber function, return is ERR_OK.
235 */
236 HWTEST_F(NotificationSubscriberManagerTest, NotificationSubscriberManagerTest_003, Function | SmallTest | Level1)
237 {
238 // Test NotifyConsumed function.
239 std::vector<NotificationSorting> sortingList;
240 sptr<NotificationRequest> request = new NotificationRequest();
241 sptr<Notification> notification = new Notification(request);
242 sptr<NotificationSortingMap> notificationMap = new NotificationSortingMap(sortingList);
243 notificationSubscriberManager_->NotifyConsumed(notification, notificationMap);
244
245 // Test RemoveSubscriber function.
246 sptr<NotificationSubscribeInfo> info = new NotificationSubscribeInfo();
247 info->AddAppName("test_bundle");
248 ASSERT_EQ(notificationSubscriberManager_->RemoveSubscriber(subscriber_, info), (int)ERR_OK);
249 }
250
251 /**
252 * @tc.number : NotificationSubscriberManagerTest_004
253 * @tc.name : ANS_AddSubscriber_0100
254 * @tc.desc : Test RemoveSubscriber function when subscriber is nullptr, return is ERR_ANS_INVALID_PARAM.
255 */
256 HWTEST_F(NotificationSubscriberManagerTest, NotificationSubscriberManagerTest_004, Function | SmallTest | Level1)
257 {
258 // Test NotifyCanceled function.
259 std::vector<NotificationSorting> sortingList;
260 sptr<NotificationRequest> request = new NotificationRequest();
261 sptr<Notification> notification = new Notification(request);
262 sptr<NotificationSortingMap> notificationMap = new NotificationSortingMap(sortingList);
263 int deleteReason = 0;
264 notificationSubscriberManager_->NotifyCanceled(notification, notificationMap, deleteReason);
265
266 // Test RemoveSubscriber function.
267 sptr<NotificationSubscribeInfo> info = new NotificationSubscribeInfo();
268 ASSERT_EQ(notificationSubscriberManager_->RemoveSubscriber(nullptr, info), (int)ERR_ANS_INVALID_PARAM);
269 }
270
271 /**
272 * @tc.number : RegisterOnSubscriberAddCallbackTest_001
273 * @tc.name : RegisterOnSubscriberAddCallback and callback is not nullptr
274 * @tc.desc : Test RegisterOnSubscriberAddCallback .
275 */
OnSubscriberAddFake(const std::shared_ptr<NotificationSubscriberManager::SubscriberRecord> & recode)276 void OnSubscriberAddFake(const std::shared_ptr<NotificationSubscriberManager::SubscriberRecord> &recode) {}
277 HWTEST_F(NotificationSubscriberManagerTest, RegisterOnSubscriberAddCallbackTest_001, Function | SmallTest | Level1)
278 {
279 std::function<void(const std::shared_ptr<NotificationSubscriberManager::SubscriberRecord> &)> callback =
280 std::bind(OnSubscriberAddFake, std::placeholders::_1);
281
282 notificationSubscriberManager_->RegisterOnSubscriberAddCallback(callback);
283 EXPECT_NE(notificationSubscriberManager_->onSubscriberAddCallback_, nullptr);
284 }
285
286 /**
287 * @tc.number : RegisterOnSubscriberAddCallbackTest_002
288 * @tc.name : RegisterOnSubscriberAddCallback and callback is nullptr
289 * @tc.desc : Test RegisterOnSubscriberAddCallback .
290 */
291 HWTEST_F(NotificationSubscriberManagerTest, RegisterOnSubscriberAddCallbackTest_002, Function | SmallTest | Level1)
292 {
293 std::function<void(const std::shared_ptr<NotificationSubscriberManager::SubscriberRecord> &)> callback =
294 std::bind(OnSubscriberAddFake, std::placeholders::_1);
295 notificationSubscriberManager_->RegisterOnSubscriberAddCallback(callback);
296 EXPECT_NE(notificationSubscriberManager_->onSubscriberAddCallback_, nullptr);
297
298 // if callback exist, re-register a nullptr func will fail.
299 notificationSubscriberManager_->RegisterOnSubscriberAddCallback(nullptr);
300 EXPECT_NE(notificationSubscriberManager_->onSubscriberAddCallback_, nullptr);
301 }
302
303 /**
304 * @tc.number : UnRegisterOnSubscriberAddCallbackTest_001
305 * @tc.name : UnRegisterOnSubscriberAddCallback
306 * @tc.desc : Test UnRegisterOnSubscriberAddCallback .
307 */
308 HWTEST_F(NotificationSubscriberManagerTest, UnRegisterOnSubscriberAddCallbackTest_001, Function | SmallTest | Level1)
309 {
310 std::function<void(const std::shared_ptr<NotificationSubscriberManager::SubscriberRecord> &)> callback =
311 std::bind(OnSubscriberAddFake, std::placeholders::_1);
312 notificationSubscriberManager_->RegisterOnSubscriberAddCallback(callback);
313 EXPECT_NE(notificationSubscriberManager_->onSubscriberAddCallback_, nullptr);
314
315 notificationSubscriberManager_->UnRegisterOnSubscriberAddCallback();
316 ASSERT_EQ(notificationSubscriberManager_->onSubscriberAddCallback_, nullptr);
317 }
318
319 /**
320 * @tc.number : BatchNotifyConsumedInner_001
321 * @tc.name : BatchNotifyConsumedInner
322 * @tc.desc : Test BatchNotifyConsumedInner .
323 */
324 HWTEST_F(NotificationSubscriberManagerTest, BatchNotifyConsumedInner_001, Function | SmallTest | Level1)
325 {
326 sptr<MockAnsSubscriber> mockSubscriber = new MockAnsSubscriber();
327 EXPECT_CALL(*mockSubscriber, OnConsumedList(_, _)).Times(1);
328
329 sptr<NotificationRequest> request = new NotificationRequest();
330 request->SetOwnerBundleName("test");
331 sptr<Notification> notification = new Notification(request);
332
333 std::vector<sptr<OHOS::Notification::Notification>> notifications;
334 notifications.emplace_back(notification);
335 notifications.emplace_back(nullptr);
336 sptr<NotificationSortingMap> notificationMap = new (std::nothrow) NotificationSortingMap();
337
338 std::shared_ptr<NotificationSubscriberManager::SubscriberRecord> record =
339 notificationSubscriberManager_->CreateSubscriberRecord(mockSubscriber);
340 const sptr<NotificationSubscribeInfo> subscribeInfo = new NotificationSubscribeInfo();
341 subscribeInfo->AddAppName("test");
342 subscribeInfo->AddAppUserId(SUBSCRIBE_USER_ALL);
343 notificationSubscriberManager_->AddRecordInfo(record, subscribeInfo);
344 notificationSubscriberManager_->BatchNotifyConsumedInner(notifications, notificationMap, record);
345 }
346
347 /**
348 * @tc.number : BatchNotifyConsumedInner_002
349 * @tc.name : BatchNotifyConsumedInner and params is invalid
350 * @tc.desc : Test BatchNotifyConsumedInner .
351 */
352 HWTEST_F(NotificationSubscriberManagerTest, BatchNotifyConsumedInner_002, Function | SmallTest | Level1)
353 {
354 sptr<MockAnsSubscriber> mockSubscriber = new MockAnsSubscriber();
355 EXPECT_CALL(*mockSubscriber, OnConsumedList(_, _)).Times(0);
356 std::vector<sptr<OHOS::Notification::Notification>> notifications;
357 notificationSubscriberManager_->BatchNotifyConsumedInner(notifications, nullptr, nullptr);
358 }
359
360 /**
361 * @tc.number : BatchNotifyConsumedInner_003
362 * @tc.name : BatchNotifyConsumedInner and subscriber isn't subscribed to this notification
363 * @tc.desc : Test BatchNotifyConsumedInner .
364 */
365 HWTEST_F(NotificationSubscriberManagerTest, BatchNotifyConsumedInner_003, Function | SmallTest | Level1)
366 {
367 sptr<MockAnsSubscriber> mockSubscriber = new MockAnsSubscriber();
368 EXPECT_CALL(*mockSubscriber, OnConsumedList(_, _)).Times(0);
369
370 sptr<NotificationRequest> request = new NotificationRequest();
371 request->SetOwnerBundleName("test");
372 sptr<Notification> notification = new Notification(request);
373
374 std::vector<sptr<OHOS::Notification::Notification>> notifications;
375 notifications.emplace_back(notification);
376 sptr<NotificationSortingMap> notificationMap = new (std::nothrow) NotificationSortingMap();
377
378 std::shared_ptr<NotificationSubscriberManager::SubscriberRecord> record =
379 notificationSubscriberManager_->CreateSubscriberRecord(mockSubscriber);
380 const sptr<NotificationSubscribeInfo> subscribeInfo = new NotificationSubscribeInfo();
381 subscribeInfo->AddAppName("test_1");
382 subscribeInfo->AddAppUserId(SUBSCRIBE_USER_ALL);
383 notificationSubscriberManager_->AddRecordInfo(record, subscribeInfo);
384 notificationSubscriberManager_->BatchNotifyConsumedInner(notifications, notificationMap, record);
385 }
386
387 /**
388 * @tc.number : BatchNotifyConsumed_001
389 * @tc.name : BatchNotifyConsumed and params is nullptr
390 * @tc.desc : Test BatchNotifyConsumed .
391 */
392 HWTEST_F(NotificationSubscriberManagerTest, BatchNotifyConsumed_001, Function | SmallTest | Level1)
393 {
394 std::vector<sptr<OHOS::Notification::Notification>> notifications;
395 sptr<NotificationSortingMap> notificationMap(new NotificationSortingMap());
396 sptr<NotificationRequest> request(new NotificationRequest());
397 sptr<Notification> notification(new Notification(request));
398 notifications.emplace_back(notification);
399
400 std::shared_ptr<TestAnsSubscriber> testAnsSubscriber = std::make_shared<TestAnsSubscriber>();
401 sptr<IAnsSubscriber> subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber));
402 auto isCallback = testAnsSubscriber->GetCallBack();
403 ASSERT_FALSE(isCallback);
404
405 NotificationSubscriberManager notificationSubscriberManager;
406 auto record = notificationSubscriberManager.CreateSubscriberRecord(subscriber);
407 notificationSubscriberManager.BatchNotifyConsumed(notifications, notificationMap, record);
408 std::this_thread::sleep_for(std::chrono::milliseconds(200));
409 isCallback = testAnsSubscriber->GetCallBack();
410 ASSERT_TRUE(isCallback);
411
412 testAnsSubscriber->SetCallBack(false);
413 notificationSubscriberManager.notificationSubQueue_ = nullptr;
414 notificationSubscriberManager.BatchNotifyConsumed(notifications, notificationMap, record);
415 std::this_thread::sleep_for(std::chrono::milliseconds(200));
416 isCallback = testAnsSubscriber->GetCallBack();
417 ASSERT_FALSE(isCallback);
418 }
419
420 /**
421 * @tc.number : AddSubscriber001
422 * @tc.name : AddSubscriber and params is nullptr
423 * @tc.desc : Test AddSubscriber .
424 */
425 HWTEST_F(NotificationSubscriberManagerTest, AddSubscriber_001, Function | SmallTest | Level1)
426 {
427 MockGetOsAccountLocalIdFromUid(false, 0);
428 NotificationSubscriberManager notificationSubscriberManager;
429 std::shared_ptr<TestAnsSubscriber> testAnsSubscriber = std::make_shared<TestAnsSubscriber>();
430 sptr<IAnsSubscriber> subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber));
431
432 ASSERT_EQ(notificationSubscriberManager.AddSubscriber(
433 subscriber, nullptr), (int)ERR_ANS_INVALID_PARAM);
434 }
435
436 /**
437 * @tc.number : AddSubscriber_002
438 * @tc.name : AddSubscriber and params is nullptr
439 * @tc.desc : Test AddSubscriber .he
440 */
441 HWTEST_F(NotificationSubscriberManagerTest, AddSubscriber_002, Function | SmallTest | Level1)
442 {
443 NotificationSubscriberManager notificationSubscriberManager;
444 std::shared_ptr<TestAnsSubscriber> testAnsSubscriber = std::make_shared<TestAnsSubscriber>();
445 sptr<IAnsSubscriber> subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber));
446 auto isCallback = testAnsSubscriber->GetCallBack();
447 ASSERT_FALSE(isCallback);
448 sptr<NotificationSubscribeInfo> info(new NotificationSubscribeInfo());
449 info->AddDeviceType("current");
450 std::vector<NotificationConstant::SlotType> slotTypes;
451 slotTypes.push_back(NotificationConstant::SlotType::SOCIAL_COMMUNICATION);
452 info->SetSlotTypes(slotTypes);
453
454 ASSERT_EQ(notificationSubscriberManager.AddSubscriber(subscriber, info), (int)ERR_OK);
455
456 sptr<NotificationSortingMap> notificationMap(new NotificationSortingMap());
457 notificationSubscriberManager.NotifyUpdated(notificationMap);
458 std::this_thread::sleep_for(std::chrono::milliseconds(200));
459 isCallback = testAnsSubscriber->GetCallBack();
460 ASSERT_TRUE(isCallback);
461
462 ASSERT_EQ(notificationSubscriberManager.RemoveSubscriber(subscriber, nullptr), (int)ERR_OK);
463 }
464
465 HWTEST_F(NotificationSubscriberManagerTest, IsSubscribedBysubscriber_001, Function | SmallTest | Level1)
466 {
467 sptr<NotificationRequest> request(new NotificationRequest());
468 request->SetSlotType(NotificationConstant::SlotType::SOCIAL_COMMUNICATION);
469 request->SetCreatorUserId(101);
470 request->SetCreatorUid(101);
471 sptr<Notification> notification(new Notification(request));
472
473 std::shared_ptr<TestAnsSubscriber> testAnsSubscriber = std::make_shared<TestAnsSubscriber>();
474 sptr<IAnsSubscriber> subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber));
475 NotificationSubscriberManager notificationSubscriberManager;
476 std::shared_ptr<NotificationSubscriberManager::SubscriberRecord> record =
477 notificationSubscriberManager.CreateSubscriberRecord(subscriber);
478
479 sptr<NotificationSubscribeInfo> subscribeInfo(new NotificationSubscribeInfo());
480 subscribeInfo->SetSubscriberUid(101);
481 subscribeInfo->AddAppUserId(102);
482 notificationSubscriberManager.AddRecordInfo(record, subscribeInfo);
483 auto res = notificationSubscriberManager.IsSubscribedBysubscriber(record, notification);
484 ASSERT_FALSE(res);
485 }
486
487 HWTEST_F(NotificationSubscriberManagerTest, IsSubscribedBysubscriber_002, Function | SmallTest | Level1)
488 {
489 sptr<NotificationRequest> request(new NotificationRequest());
490 request->SetSlotType(NotificationConstant::SlotType::SOCIAL_COMMUNICATION);
491 request->SetCreatorUserId(101);
492 request->SetCreatorUid(101);
493 sptr<Notification> notification(new Notification(request));
494
495 std::shared_ptr<TestAnsSubscriber> testAnsSubscriber = std::make_shared<TestAnsSubscriber>();
496 sptr<IAnsSubscriber> subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber));
497 NotificationSubscriberManager notificationSubscriberManager;
498 std::shared_ptr<NotificationSubscriberManager::SubscriberRecord> record =
499 notificationSubscriberManager.CreateSubscriberRecord(subscriber);
500
501 sptr<NotificationSubscribeInfo> subscribeInfo(new NotificationSubscribeInfo());
502 subscribeInfo->SetSubscriberUid(101);
503 subscribeInfo->AddAppUserId(101);
504 notificationSubscriberManager.AddRecordInfo(record, subscribeInfo);
505 auto res = notificationSubscriberManager.IsSubscribedBysubscriber(record, notification);
506 ASSERT_TRUE(res);
507 }
508
509 HWTEST_F(NotificationSubscriberManagerTest, IsSubscribedBysubscriber_003, Function | SmallTest | Level1)
510 {
511 sptr<NotificationRequest> request(new NotificationRequest());
512 request->SetSlotType(NotificationConstant::SlotType::SOCIAL_COMMUNICATION);
513 request->SetCreatorUid(101);
514 sptr<Notification> notification(new Notification(request));
515
516 std::shared_ptr<TestAnsSubscriber> testAnsSubscriber = std::make_shared<TestAnsSubscriber>();
517 sptr<IAnsSubscriber> subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber));
518 NotificationSubscriberManager notificationSubscriberManager;
519 std::shared_ptr<NotificationSubscriberManager::SubscriberRecord> record =
520 notificationSubscriberManager.CreateSubscriberRecord(subscriber);
521
522 std::vector<NotificationConstant::SlotType> slotTypes;
523 slotTypes.push_back(NotificationConstant::SlotType::OTHER);
524 sptr<NotificationSubscribeInfo> subscribeInfo(new NotificationSubscribeInfo());
525 subscribeInfo->SetSlotTypes(slotTypes);
526 subscribeInfo->SetSubscriberUid(101);
527 notificationSubscriberManager.AddRecordInfo(record, subscribeInfo);
528 auto res = notificationSubscriberManager.IsSubscribedBysubscriber(record, notification);
529 ASSERT_FALSE(res);
530 }
531
532 // /**
533 // * @tc.number : NotifyConsumed_001
534 // * @tc.name :
535 // */
536 HWTEST_F(NotificationSubscriberManagerTest, NotifyConsumed_001, Function | SmallTest | Level1)
537 {
538 sptr<NotificationSortingMap> notificationMap(new NotificationSortingMap());
539 sptr<NotificationRequest> request(new NotificationRequest());
540 request->SetSlotType(NotificationConstant::SlotType::OTHER);
541 request->SetLabel("label");
542 request->SetCreatorUid(0);
543 std::shared_ptr<NotificationPictureContent> pictureContent = std::make_shared<NotificationPictureContent>();
544 EXPECT_NE(pictureContent, nullptr);
545 pictureContent->SetText("notification text");
546 pictureContent->SetTitle("notification title");
547 pictureContent->SetBigPicture(nullptr);
548 EXPECT_EQ(nullptr, pictureContent->GetBigPicture());
549 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(pictureContent);
550 EXPECT_NE(content, nullptr);
551 request->SetContent(content);
552 sptr<Notification> notification(new Notification(request));
553
554 std::shared_ptr<TestAnsSubscriber> testAnsSubscriber = std::make_shared<TestAnsSubscriber>();
555 sptr<IAnsSubscriber> subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber));
556 auto isCallback = testAnsSubscriber->GetCallBack();
557 ASSERT_FALSE(isCallback);
558
559 NotificationSubscriberManager notificationSubscriberManager;
560 sptr<NotificationSubscribeInfo> info(new NotificationSubscribeInfo());
561 ASSERT_EQ(notificationSubscriberManager.AddSubscriberInner(subscriber, info), (int)ERR_OK);
562 notificationSubscriberManager.NotifyConsumed(notification, notificationMap);
563 std::this_thread::sleep_for(std::chrono::milliseconds(400));
564 isCallback = testAnsSubscriber->GetCallBack();
565 ASSERT_TRUE(isCallback);
566 }
567
568 /**
569 * @tc.number : NotifyBadgeEnabledChanged_001
570 * @tc.name : test notify badge enable to trigger call back success
571 */
572 HWTEST_F(NotificationSubscriberManagerTest, NotifyBadgeEnabledChanged_001, Function | SmallTest | Level1)
573 {
574 std::shared_ptr<TestAnsSubscriber> testAnsSubscriber = std::make_shared<TestAnsSubscriber>();
575 sptr<IAnsSubscriber> subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber));
576 auto isCallback = testAnsSubscriber->GetCallBack();
577 ASSERT_FALSE(isCallback);
578 std::string bundle = "com.example.test";
579 sptr<NotificationSubscribeInfo> subscribeInfo(new NotificationSubscribeInfo());
580 subscribeInfo->AddAppName(bundle);
581 ASSERT_EQ(notificationSubscriberManager_->AddSubscriber(subscriber, subscribeInfo), (int)ERR_OK);
582 sptr<EnabledNotificationCallbackData> callbackData(new EnabledNotificationCallbackData());
583 callbackData->SetBundle(bundle);
584 notificationSubscriberManager_->NotifyBadgeEnabledChanged(callbackData);
585 std::this_thread::sleep_for(std::chrono::milliseconds(200));
586 isCallback = testAnsSubscriber->GetCallBack();
587 ASSERT_TRUE(isCallback);
588 }
589
590 /**
591 * @tc.number : ConsumeRecordFilter_001
592 * @tc.name :
593 */
594 HWTEST_F(NotificationSubscriberManagerTest, ConsumeRecordFilter_001, Function | SmallTest | Level1)
595 {
596 std::shared_ptr<NotificationActionButton> actionButton =
597 std::make_shared<NotificationActionButton>();
598 std::shared_ptr<NotificationUserInput> userInput = NotificationUserInput::Create("userInput");
599 actionButton->AddNotificationUserInput(userInput);
600
601 sptr<NotificationRequest> request(new NotificationRequest());
602 request->SetSlotType(NotificationConstant::SlotType::SOCIAL_COMMUNICATION);
603 request->AddActionButton(actionButton);
604 sptr<Notification> notification(new Notification(request));
605
606 std::shared_ptr<TestAnsSubscriber> testAnsSubscriber = std::make_shared<TestAnsSubscriber>();
607 sptr<IAnsSubscriber> subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber));
608 NotificationSubscriberManager notificationSubscriberManager;
609 std::shared_ptr<NotificationSubscriberManager::SubscriberRecord> record =
610 notificationSubscriberManager.CreateSubscriberRecord(subscriber);
611
612 sptr<NotificationSubscribeInfo> subscribeInfo(new NotificationSubscribeInfo());
613 subscribeInfo->SetFilterType(2);
614 notificationSubscriberManager.AddRecordInfo(record, subscribeInfo);
615 auto res = notificationSubscriberManager.ConsumeRecordFilter(record, notification);
616 ASSERT_FALSE(res);
617 }
618
619 /**
620 * @tc.number : ConsumeRecordFilter_002
621 * @tc.name :
622 */
623 HWTEST_F(NotificationSubscriberManagerTest, ConsumeRecordFilter_002, Function | SmallTest | Level1)
624 {
625 std::shared_ptr<NotificationActionButton> actionButton = std::make_shared<NotificationActionButton>();
626 std::shared_ptr<NotificationUserInput> userInput = NotificationUserInput::Create("userInput");
627 actionButton->AddNotificationUserInput(userInput);
628
629 sptr<NotificationRequest> request(new NotificationRequest());
630 request->SetSlotType(NotificationConstant::SlotType::SOCIAL_COMMUNICATION);
631 request->AddActionButton(actionButton);
632 sptr<Notification> notification(new Notification(request));
633
634 NotificationSubscriberManager notificationSubscriberManager;
635 std::shared_ptr<TestAnsSubscriber> testAnsSubscriber = std::make_shared<TestAnsSubscriber>();
636 sptr<IAnsSubscriber> subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber));
637 std::shared_ptr<NotificationSubscriberManager::SubscriberRecord> record =
638 notificationSubscriberManager.CreateSubscriberRecord(subscriber);
639
640 sptr<NotificationSubscribeInfo> subscribeInfo(new NotificationSubscribeInfo());
641 subscribeInfo->SetFilterType(4);
642 notificationSubscriberManager.AddRecordInfo(record, subscribeInfo);
643 auto res = notificationSubscriberManager.ConsumeRecordFilter(record, notification);
644 ASSERT_TRUE(res);
645 }
646
647 /**
648 * @tc.number : ConsumeRecordFilter_003
649 * @tc.name :
650 */
651 HWTEST_F(NotificationSubscriberManagerTest, ConsumeRecordFilter_003, Function | SmallTest | Level1)
652 {
653 sptr<NotificationRequest> request(new NotificationRequest());
654 request->SetSlotType(NotificationConstant::SlotType::SOCIAL_COMMUNICATION);
655 sptr<Notification> notification(new Notification(request));
656
657 NotificationSubscriberManager notificationSubscriberManager;
658 std::shared_ptr<TestAnsSubscriber> testAnsSubscriber = std::make_shared<TestAnsSubscriber>();
659 sptr<IAnsSubscriber> subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber));
660 std::shared_ptr<NotificationSubscriberManager::SubscriberRecord> record =
661 notificationSubscriberManager.CreateSubscriberRecord(subscriber);
662
663 sptr<NotificationSubscribeInfo> subscribeInfo(new NotificationSubscribeInfo());
664 subscribeInfo->SetFilterType(1);
665 notificationSubscriberManager.AddRecordInfo(record, subscribeInfo);
666 auto res = notificationSubscriberManager.ConsumeRecordFilter(record, notification);
667 ASSERT_FALSE(res);
668 }
669
670 /**
671 * @tc.number : BatchNotifyCanceledInner_001
672 * @tc.name :
673 */
674 HWTEST_F(NotificationSubscriberManagerTest, BatchNotifyCanceledInner_001, Function | SmallTest | Level1)
675 {
676 //build request
677 sptr<NotificationSortingMap> notificationMap(new NotificationSortingMap());
678 sptr<NotificationRequest> request(new NotificationRequest());
679 request->SetSlotType(NotificationConstant::SlotType::LIVE_VIEW);
680 request->SetLabel("label");
681 request->SetCreatorUid(0);
682 std::shared_ptr<NotificationLiveViewContent> liveViewContentcontent =
683 std::make_shared<NotificationLiveViewContent>();
684 liveViewContentcontent->SetText("notification text");
685 liveViewContentcontent->SetTitle("notification title");
686 std::map<std::string, std::vector<std::shared_ptr<Media::PixelMap>>> pixelMap;
687 liveViewContentcontent->SetPicture(pixelMap);
688 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(liveViewContentcontent);
689 request->SetContent(content);
690 sptr<Notification> notification(new Notification(request));
691
692 sptr<NotificationRequest> requestLocal(new NotificationRequest());
693 requestLocal->SetSlotType(NotificationConstant::SlotType::LIVE_VIEW);
694 requestLocal->SetLabel("label");
695 requestLocal->SetCreatorUid(0);
696 std::shared_ptr<NotificationLocalLiveViewContent> liveViewLocalContentcontent =
697 std::make_shared<NotificationLocalLiveViewContent>();
698 liveViewLocalContentcontent->SetText("notification text");
699 liveViewLocalContentcontent->SetTitle("notification title");
700 std::shared_ptr<NotificationContent> contentLocal =
701 std::make_shared<NotificationContent>(liveViewLocalContentcontent);
702 requestLocal->SetContent(contentLocal);
703 sptr<Notification> notificationLocal(new Notification(requestLocal));
704
705 std::vector<sptr<Notification>> notifications;
706 notifications.push_back(notification);
707 notifications.push_back(notificationLocal);
708 //build subscriber
709 std::shared_ptr<TestAnsSubscriber> testAnsSubscriber = std::make_shared<TestAnsSubscriber>();
710 sptr<IAnsSubscriber> subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber));
711 auto isCallback = testAnsSubscriber->GetCallBack();
712 ASSERT_FALSE(isCallback);
713
714 NotificationSubscriberManager notificationSubscriberManager;
715 sptr<NotificationSubscribeInfo> info(new NotificationSubscribeInfo());
716 ASSERT_EQ(notificationSubscriberManager.AddSubscriberInner(subscriber, info), (int)ERR_OK);
717 //brach need nullptr
718 notificationSubscriberManager.subscriberRecordList_.push_back(nullptr);
719
720 notificationSubscriberManager.BatchNotifyCanceledInner(notifications, notificationMap, 99);
721 std::this_thread::sleep_for(std::chrono::milliseconds(400));
722 isCallback = testAnsSubscriber->GetCallBack();
723 ASSERT_TRUE(isCallback);
724 }
725
726 /**
727 * @tc.number : NotifyDoNotDisturbDateChangedInner_001
728 * @tc.name : test set do not disturb date to trigger call back success
729 */
730 HWTEST_F(NotificationSubscriberManagerTest, NotifyDoNotDisturbDateChangedInner_001, Function | SmallTest | Level1)
731 {
732 //build notificationMap
733 sptr<NotificationDoNotDisturbDate> date(new NotificationDoNotDisturbDate());
734 std::string bundle = "com.example.test";
735
736 //build subscriber
737 std::shared_ptr<TestAnsSubscriber> testAnsSubscriber = std::make_shared<TestAnsSubscriber>();
738 sptr<IAnsSubscriber> subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber));
739 auto isCallback = testAnsSubscriber->GetCallBack();
740 ASSERT_FALSE(isCallback);
741
742 NotificationSubscriberManager notificationSubscriberManager;
743 sptr<NotificationSubscribeInfo> info(new NotificationSubscribeInfo());
744
745 info->AddAppUserId(101);
746 info->AddAppName(bundle);
747 ASSERT_EQ(notificationSubscriberManager.AddSubscriberInner(subscriber, info), (int)ERR_OK);
748
749 notificationSubscriberManager.NotifyDoNotDisturbDateChangedInner(101, date, bundle);
750 std::this_thread::sleep_for(std::chrono::milliseconds(200));
751 isCallback = testAnsSubscriber->GetCallBack();
752 ASSERT_TRUE(isCallback);
753 }
754
755 /**
756 * @tc.number : NotifyEnabledNotificationChangedInner_002
757 * @tc.name : test enable notification changed to trigger call back success
758 */
759 HWTEST_F(NotificationSubscriberManagerTest, NotifyEnabledNotificationChangedInner_002, Function | SmallTest | Level1)
760 {
761 //build notificationMap
762 sptr<EnabledNotificationCallbackData> callback(new EnabledNotificationCallbackData());
763 std::string bundle = "com.example.test";
764 callback->SetBundle(bundle);
765 callback->SetUid(101);
766
767 //build subscriber
768 std::shared_ptr<TestAnsSubscriber> testAnsSubscriber = std::make_shared<TestAnsSubscriber>();
769 sptr<IAnsSubscriber> subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber));
770 auto isCallback = testAnsSubscriber->GetCallBack();
771 ASSERT_FALSE(isCallback);
772
773 NotificationSubscriberManager notificationSubscriberManager;
774 sptr<NotificationSubscribeInfo> info(new NotificationSubscribeInfo());
775 info->AddAppUserId(100);
776 info->AddAppName(bundle);
777 ASSERT_EQ(notificationSubscriberManager.AddSubscriberInner(subscriber, info), (int)ERR_OK);
778
779 notificationSubscriberManager.NotifyEnabledNotificationChangedInner(callback);
780 std::this_thread::sleep_for(std::chrono::milliseconds(200));
781 isCallback = testAnsSubscriber->GetCallBack();
782 ASSERT_TRUE(isCallback);
783 }
784
785 /**
786 * @tc.number : SetBadgeNumber_001
787 * @tc.name : test set badge number to trigger call back success
788 */
789 HWTEST_F(NotificationSubscriberManagerTest, SetBadgeNumber_001, Function | SmallTest | Level1)
790 {
791 //build notificationMap
792 sptr<BadgeNumberCallbackData> badge(new BadgeNumberCallbackData());
793 std::string bundle = "com.example.test";
794 badge->SetBundle(bundle);
795
796 //build subscriber
797 std::shared_ptr<TestAnsSubscriber> testAnsSubscriber = std::make_shared<TestAnsSubscriber>();
798 sptr<IAnsSubscriber> subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber));
799 auto isCallback = testAnsSubscriber->GetCallBack();
800 ASSERT_FALSE(isCallback);
801
802 NotificationSubscriberManager notificationSubscriberManager;
803 std::shared_ptr<NotificationSubscriberManager::SubscriberRecord> record =
804 notificationSubscriberManager.CreateSubscriberRecord(subscriber);
805
806 sptr<NotificationSubscribeInfo> info(new NotificationSubscribeInfo());
807 info->AddAppUserId(100);
808 info->AddAppName(bundle);
809 ASSERT_EQ(notificationSubscriberManager.AddSubscriberInner(subscriber, info), (int)ERR_OK);
810
811 notificationSubscriberManager.SetBadgeNumber(badge);
812 std::this_thread::sleep_for(std::chrono::milliseconds(200));
813 isCallback = testAnsSubscriber->GetCallBack();
814 ASSERT_TRUE(isCallback);
815 }
816
817 /**
818 * @tc.number : NotifyApplicationInfoNeedChanged_001
819 * @tc.name :
820 */
821 HWTEST_F(NotificationSubscriberManagerTest, NotifyApplicationInfoNeedChanged_001, Function | SmallTest | Level1)
822 {
823 //build subscriber
824 std::shared_ptr<TestAnsSubscriber> testAnsSubscriber = std::make_shared<TestAnsSubscriber>();
825 sptr<IAnsSubscriber> subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber));
826 auto isCallback = testAnsSubscriber->GetCallBack();
827 ASSERT_FALSE(isCallback);
828
829 NotificationSubscriberManager notificationSubscriberManager;
830 sptr<NotificationSubscribeInfo> info(new NotificationSubscribeInfo());
831 info->SetNeedNotifyApplication(true);
832 ASSERT_EQ(notificationSubscriberManager.AddSubscriberInner(subscriber, info), (int)ERR_OK);
833
834 notificationSubscriberManager.NotifyApplicationInfoNeedChanged("test");
835 std::this_thread::sleep_for(std::chrono::milliseconds(200));
836 isCallback = testAnsSubscriber->GetCallBack();
837 ASSERT_TRUE(isCallback);
838 }
839
840 /**
841 * @tc.number : DistributeOperation_001
842 * @tc.name : test DistributeOperation call back success
843 */
844 HWTEST_F(NotificationSubscriberManagerTest, DistributeOperation_001, Function | SmallTest | Level1)
845 {
846 sptr<NotificationOperationInfo> operationInfo(new NotificationOperationInfo);
847 //build subscriber
848 std::shared_ptr<TestAnsSubscriber> testAnsSubscriber = std::make_shared<TestAnsSubscriber>();
849 sptr<IAnsSubscriber> subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber));
850 auto isCallback = testAnsSubscriber->GetCallBack();
851 ASSERT_FALSE(isCallback);
852
853 NotificationSubscriberManager notificationSubscriberManager;
854 sptr<NotificationSubscribeInfo> info(new NotificationSubscribeInfo());
855 info->SetNeedNotifyResponse(true);
856 ASSERT_EQ(notificationSubscriberManager.AddSubscriberInner(subscriber, info), (int)ERR_OK);
857
858 sptr request = new (std::nothrow) NotificationRequest();
859 notificationSubscriberManager.DistributeOperation(operationInfo, request);
860 std::this_thread::sleep_for(std::chrono::milliseconds(400));
861 isCallback = testAnsSubscriber->GetCallBack();
862 ASSERT_TRUE(isCallback);
863 }
864
865 /**
866 * @tc.number : DistributeOperation_002
867 * @tc.name : test DistributeOperation with operationInfo nullptr
868 */
869 HWTEST_F(NotificationSubscriberManagerTest, DistributeOperation_002, Function | SmallTest | Level1)
870 {
871 NotificationSubscriberManager notificationSubscriberManager;
872 ASSERT_EQ((int)ERR_ANS_TASK_ERR, notificationSubscriberManager.DistributeOperation(nullptr, nullptr));
873 }
874
875 /**
876 * @tc.number : DistributeOperation_003
877 * @tc.name : test DistributeOperation ERR_ANS_DISTRIBUTED_OPERATION_FAILED
878 */
879 HWTEST_F(NotificationSubscriberManagerTest, DistributeOperation_003, Function | SmallTest | Level1)
880 {
881 sptr<NotificationRequest> request = new (std::nothrow) NotificationRequest();
882 std::shared_ptr<AAFwk::WantParams> extendInfo = std::make_shared<AAFwk::WantParams>();
883 request->SetExtendInfo(extendInfo);
884 sptr<NotificationOperationInfo> operationInfo = new (std::nothrow) NotificationOperationInfo();
885 operationInfo->SetHashCode("hashCode");
886 NotificationSubscriberManager notificationSubscriberManager;
887 notificationSubscriberManager.subscriberRecordList_.push_back(nullptr);
888 notificationSubscriberManager.subscriberRecordList_.push_back(
889 notificationSubscriberManager.CreateSubscriberRecord(nullptr));
890 ASSERT_EQ((int)ERR_ANS_DISTRIBUTED_OPERATION_FAILED,
891 notificationSubscriberManager.DistributeOperation(operationInfo, request));
892 }
893
894 /**
895 * @tc.number : OnRemoteDied_001
896 * @tc.name : OnRemoteDied and params is nullptr
897 * @tc.desc : Test OnRemoteDied .
898 */
899 HWTEST_F(NotificationSubscriberManagerTest, OnRemoteDied_001, Function | SmallTest | Level1)
900 {
901 notificationSubscriberManager_->notificationSubQueue_ = nullptr;
902 wptr<IRemoteObject> obj = nullptr;
903 notificationSubscriberManager_->OnRemoteDied(obj);
904 EXPECT_NE(notificationSubscriberManager_, nullptr);
905 }
906 /**
907 * @tc.name: NotifyConsumedInner_001
908 * @tc.desc: Test NotifyConsumedInner when notification is nullptr
909 * @tc.type: FUNC
910 */
911 HWTEST_F(NotificationSubscriberManagerTest, NotifyConsumedInner_001, Function | SmallTest | Level1)
912 {
913 sptr<Notification> notification = nullptr;
914 sptr<NotificationSortingMap> notificationMap = nullptr;
915
916 NotificationSubscriberManager notificationSubscriberManager;
917 notificationSubscriberManager.NotifyConsumedInner(notification, notificationMap);
918
919 ASSERT_EQ(notification, nullptr);
920 }
921
922 /**
923 * @tc.name: NotifyConsumedInner_002
924 * @tc.desc: Test NotifyConsumedInner when notificationMap is not nullptr and notification type is not liveview
925 * @tc.type: FUNC
926 */
927 HWTEST_F(NotificationSubscriberManagerTest, NotifyConsumedInner_002, Function | SmallTest | Level1)
928 {
929 NotificationSubscriberManager notificationSubscriberManager;
930 sptr<MockAnsSubscriberTest> subscriber(new (std::nothrow) MockAnsSubscriberTest());
931 const sptr<NotificationSubscribeInfo> subscribeInfo = new NotificationSubscribeInfo();
932 subscribeInfo->AddAppUserId(SUBSCRIBE_USER_ALL);
933 notificationSubscriberManager.AddSubscriberInner(subscriber, subscribeInfo);
934 sptr<NotificationRequest> request = new NotificationRequest();
935 request->SetCreatorUid(DEFAULT_UID);
936 request->SetOwnerBundleName("test1");
937 sptr<Notification> notification = new Notification(request);
938 sptr<NotificationSortingMap> notificationMap = new (std::nothrow) NotificationSortingMap();
939
940 notificationSubscriberManager.NotifyConsumedInner(notification, notificationMap);
941
942 auto isCall = subscriber->IsCalled();
943 ASSERT_TRUE(isCall);
944 }
945
946 /**
947 * @tc.name: NotifyConsumedInner_003
948 * @tc.desc: Test NotifyConsumedInner when notificationMap is not nullptr and notification type is liveview
949 * @tc.type: FUNC
950 */
951 HWTEST_F(NotificationSubscriberManagerTest, NotifyConsumedInner_003, Function | SmallTest | Level1)
952 {
953 NotificationSubscriberManager notificationSubscriberManager;
954 sptr<MockAnsSubscriberTest> subscriber(new (std::nothrow) MockAnsSubscriberTest());
955 const sptr<NotificationSubscribeInfo> subscribeInfo = new NotificationSubscribeInfo();
956 subscribeInfo->AddAppUserId(SUBSCRIBE_USER_ALL);
957 notificationSubscriberManager.AddSubscriberInner(subscriber, subscribeInfo);
958 sptr<NotificationRequest> request = new NotificationRequest();
959 request->SetCreatorUid(DEFAULT_UID);
960 request->SetOwnerBundleName("test1");
961 request->SetSlotType(NotificationConstant::SlotType::LIVE_VIEW);
962 auto liveViewContent = std::make_shared<NotificationLiveViewContent>();
963 auto content = std::make_shared<NotificationContent>(liveViewContent);
964 request->SetContent(content);
965 sptr<Notification> notification = new Notification(request);
966 sptr<NotificationSortingMap> notificationMap = new (std::nothrow) NotificationSortingMap();
967
968 notificationSubscriberManager.NotifyConsumedInner(notification, notificationMap);
969
970 auto isCall = subscriber->IsCalled();
971 ASSERT_TRUE(isCall);
972 }
973
974 /**
975 * @tc.name: NotifyConsumedInner_004
976 * @tc.desc: Test NotifyConsumedInner when notificationMap is nullptr and notification type is not liveview
977 * @tc.type: FUNC
978 */
979 HWTEST_F(NotificationSubscriberManagerTest, NotifyConsumedInner_004, Function | SmallTest | Level1)
980 {
981 NotificationSubscriberManager notificationSubscriberManager;
982 sptr<MockAnsSubscriberTest> subscriber(new (std::nothrow) MockAnsSubscriberTest());
983 const sptr<NotificationSubscribeInfo> subscribeInfo = new NotificationSubscribeInfo();
984 subscribeInfo->AddAppUserId(SUBSCRIBE_USER_ALL);
985 notificationSubscriberManager.AddSubscriberInner(subscriber, subscribeInfo);
986 sptr<NotificationRequest> request = new NotificationRequest();
987 request->SetCreatorUid(DEFAULT_UID);
988 request->SetOwnerBundleName("test1");
989 sptr<Notification> notification = new Notification(request);
990 sptr<NotificationSortingMap> notificationMap = nullptr;
991
992 notificationSubscriberManager.NotifyConsumedInner(notification, notificationMap);
993
994 auto isCall = subscriber->IsCalled();
995 ASSERT_TRUE(isCall);
996 }
997
998 /**
999 * @tc.name: NotifyConsumedInner_005
1000 * @tc.desc: Test NotifyConsumedInner when notificationMap is nullptr and notification type is liveview
1001 * @tc.type: FUNC
1002 */
1003 HWTEST_F(NotificationSubscriberManagerTest, NotifyConsumedInner_005, Function | SmallTest | Level1)
1004 {
1005 NotificationSubscriberManager notificationSubscriberManager;
1006 sptr<MockAnsSubscriberTest> subscriber(new (std::nothrow) MockAnsSubscriberTest());
1007 const sptr<NotificationSubscribeInfo> subscribeInfo = new NotificationSubscribeInfo();
1008 subscribeInfo->AddAppUserId(SUBSCRIBE_USER_ALL);
1009 notificationSubscriberManager.AddSubscriberInner(subscriber, subscribeInfo);
1010 sptr<NotificationRequest> request = new NotificationRequest();
1011 request->SetCreatorUid(DEFAULT_UID);
1012 request->SetOwnerBundleName("test1");
1013 request->SetSlotType(NotificationConstant::SlotType::LIVE_VIEW);
1014 auto liveViewContent = std::make_shared<NotificationLiveViewContent>();
1015 auto content = std::make_shared<NotificationContent>(liveViewContent);
1016 request->SetContent(content);
1017 sptr<Notification> notification = new Notification(request);
1018 sptr<NotificationSortingMap> notificationMap = nullptr;
1019
1020 notificationSubscriberManager.NotifyConsumedInner(notification, notificationMap);
1021
1022 auto isCall = subscriber->IsCalled();
1023 ASSERT_TRUE(isCall);
1024 }
1025
1026 #ifdef NOTIFICATION_SMART_REMINDER_SUPPORTED
1027 /**
1028 * @tc.name: GetIsEnableEffectedRemind_001
1029 * @tc.desc: Test GetIsEnableEffectedRemind when subscriberRecordList_ is empty
1030 * @tc.type: FUNC
1031 */
1032 HWTEST_F(NotificationSubscriberManagerTest, GetIsEnableEffectedRemind_001, Function | SmallTest | Level1)
1033 {
1034 NotificationSubscriberManager notificationSubscriberManager;
1035
1036 auto ret = notificationSubscriberManager.GetIsEnableEffectedRemind();
1037
1038 ASSERT_FALSE(ret);
1039 }
1040
1041 /**
1042 * @tc.name: GetIsEnableEffectedRemind_002
1043 * @tc.desc: Test GetIsEnableEffectedRemind when subscriberRecordList_ is not empty
1044 * @tc.type: FUNC
1045 */
1046 HWTEST_F(NotificationSubscriberManagerTest, GetIsEnableEffectedRemind_002, Function | SmallTest | Level1)
1047 {
1048 NotificationSubscriberManager notificationSubscriberManager;
1049 sptr<MockAnsSubscriberTest> subscriber(new (std::nothrow) MockAnsSubscriberTest());
1050 const sptr<NotificationSubscribeInfo> subscribeInfo = new NotificationSubscribeInfo();
1051 subscribeInfo->AddAppUserId(SUBSCRIBE_USER_ALL);
1052 subscribeInfo->AddDeviceType(NotificationConstant::PC_DEVICE_TYPE);
1053 notificationSubscriberManager.AddSubscriberInner(subscriber, subscribeInfo);
1054
1055 auto ret = notificationSubscriberManager.GetIsEnableEffectedRemind();
1056
1057 ASSERT_TRUE(ret);
1058 }
1059 /**
1060 * @tc.name: IsDeviceTypeSubscriberd_001
1061 * @tc.desc: Test IsDeviceTypeSubscriberd when subscriberRecordList_ is empty
1062 * @tc.type: FUNC
1063 */
1064 HWTEST_F(NotificationSubscriberManagerTest, IsDeviceTypeSubscriberd_001, Function | SmallTest | Level1)
1065 {
1066 NotificationSubscriberManager notificationSubscriberManager;
1067 std::string deviceType = NotificationConstant::PC_DEVICE_TYPE;
1068
1069 auto ret = notificationSubscriberManager.IsDeviceTypeSubscriberd(deviceType);
1070
1071 ASSERT_FALSE(ret);
1072 }
1073
1074 /**
1075 * @tc.name: IsDeviceTypeSubscriberd_002
1076 * @tc.desc: Test IsDeviceTypeSubscriberd when subscriberRecordList_ is not empty
1077 * @tc.type: FUNC
1078 */
1079 HWTEST_F(NotificationSubscriberManagerTest, IsDeviceTypeSubscriberd_002, Function | SmallTest | Level1)
1080 {
1081 NotificationSubscriberManager notificationSubscriberManager;
1082 std::string deviceType = NotificationConstant::PC_DEVICE_TYPE;
1083 sptr<MockAnsSubscriberTest> subscriber(new (std::nothrow) MockAnsSubscriberTest());
1084 const sptr<NotificationSubscribeInfo> subscribeInfo = new NotificationSubscribeInfo();
1085 subscribeInfo->AddAppUserId(SUBSCRIBE_USER_ALL);
1086 subscribeInfo->AddDeviceType(deviceType);
1087 notificationSubscriberManager.AddSubscriberInner(subscriber, subscribeInfo);
1088
1089 auto ret = notificationSubscriberManager.IsDeviceTypeSubscriberd(deviceType);
1090
1091 ASSERT_TRUE(ret);
1092 }
1093
1094 /**
1095 * @tc.name: IsDeviceTypeAffordConsume_001
1096 * @tc.desc: Test IsDeviceTypeAffordConsume
1097 * @tc.type: FUNC
1098 */
1099 HWTEST_F(NotificationSubscriberManagerTest, IsDeviceTypeAffordConsume_001, Function | SmallTest | Level1)
1100 {
1101 NotificationSubscriberManager notificationSubscriberManager;
1102 std::string deviceType = NotificationConstant::PC_DEVICE_TYPE;
1103 sptr<MockAnsSubscriberTest> subscriber(new (std::nothrow) MockAnsSubscriberTest());
1104 const sptr<NotificationSubscribeInfo> subscribeInfo = new NotificationSubscribeInfo();
1105 subscribeInfo->AddAppUserId(SUBSCRIBE_USER_ALL);
1106 subscribeInfo->AddDeviceType(deviceType);
1107 notificationSubscriberManager.AddSubscriberInner(subscriber, subscribeInfo);
1108 sptr<NotificationRequest> request = new NotificationRequest();
1109 bool result = false;
1110
1111 notificationSubscriberManager.IsDeviceTypeAffordConsume(deviceType, request, result);
1112
1113 ASSERT_TRUE(result);
1114 }
1115 #endif
1116 } // namespace Notification
1117 } // namespace OHOS
1118