From 07b7a669d8f6ddcbd851b55c7cbc732ccfcf465d Mon Sep 17 00:00:00 2001 From: baozeyu Date: Fri, 28 Mar 2025 11:14:51 +0800 Subject: [PATCH] otification_subscriber_manager test add Signed-off-by: baozeyu --- services/ans/test/unittest/BUILD.gn | 1 + .../notification_subscriber_manager_test.cpp | 714 +++++++++++++++++- 2 files changed, 694 insertions(+), 21 deletions(-) diff --git a/services/ans/test/unittest/BUILD.gn b/services/ans/test/unittest/BUILD.gn index 19aad802a..ef60b42a9 100644 --- a/services/ans/test/unittest/BUILD.gn +++ b/services/ans/test/unittest/BUILD.gn @@ -226,6 +226,7 @@ ohos_unittest("notification_subscriber_manager_test") { "mock/mock_push_callback_stub.cpp", "mock/mock_single_kv_store.cpp", "mock/mock_swing_callback_stub.cpp", + "notification_dialog_test/mock_os_account_manager_annex.cpp", "notification_subscriber_manager_test.cpp", ] diff --git a/services/ans/test/unittest/notification_subscriber_manager_test.cpp b/services/ans/test/unittest/notification_subscriber_manager_test.cpp index d5b9e47e6..1a366c434 100644 --- a/services/ans/test/unittest/notification_subscriber_manager_test.cpp +++ b/services/ans/test/unittest/notification_subscriber_manager_test.cpp @@ -15,15 +15,20 @@ #include #include +#include #define private public #include "notification_subscriber.h" #include "notification_subscriber_manager.h" #include "mock_ans_subscriber.h" +#include "ans_const_define.h" +#include "notification_preferences.h" #include "ans_inner_errors.h" #include "ans_subscriber_listener.h" +extern void MockGetOsAccountLocalIdFromUid(bool mockRet, uint8_t mockCase = 0); + using namespace testing::ext; using namespace testing; @@ -47,26 +52,63 @@ private: {} void OnEnabledNotificationChanged( const std::shared_ptr &callbackData) override - {} + { + isCallback_ = true; + } void OnCanceled(const std::shared_ptr &request, const std::shared_ptr &sortingMap, int deleteReason) override - {} + { + isCallback_ = true; + } void OnConsumed(const std::shared_ptr &request, const std::shared_ptr &sortingMap) override - {} + { + isCallback_ = true; + } void OnUpdate(const std::shared_ptr &sortingMap) override - {} + { + isCallback_ = true; + } void OnDoNotDisturbDateChange(const std::shared_ptr &date) override - {} + { + isCallback_ = true; + } void OnBadgeChanged(const std::shared_ptr &badgeData) override - {} + { + isCallback_ = true; + } void OnBadgeEnabledChanged(const sptr &callbackData) override - {} - void OnBatchCanceled(const std::vector> - &requestList, const std::shared_ptr &sortingMap, int32_t deleteReason) override - {} + { + isCallback_ = true; + } + void OnBatchCanceled(const std::vector> &requestList, + const std::shared_ptr &sortingMap, int32_t deleteReason) override + { + isCallback_ = true; + } void OnApplicationInfoNeedChanged(const std::string& bundleName) override - {} + { + isCallback_ = true; + } + + ErrCode OnOperationResponse(const std::shared_ptr &operationInfo) + { + isCallback_ = true; + return ERR_OK; + } + + bool GetCallBack() + { + return isCallback_; + } + + void SetCallBack(bool isCallback) + { + isCallback_ = isCallback; + } + + private: + bool isCallback_; }; static std::shared_ptr notificationSubscriberManager_; @@ -96,6 +138,7 @@ void NotificationSubscriberManagerTest::TearDownTestCase() void NotificationSubscriberManagerTest::SetUp() { + MockGetOsAccountLocalIdFromUid(true, 0); notificationSubscriberManager_->AddSubscriber(subscriber_, nullptr); } @@ -244,6 +287,7 @@ HWTEST_F(NotificationSubscriberManagerTest, BatchNotifyConsumedInner_001, Functi std::vector> notifications; notifications.emplace_back(notification); + notifications.emplace_back(nullptr); sptr notificationMap = new (std::nothrow) NotificationSortingMap(); std::shared_ptr record = @@ -303,19 +347,647 @@ HWTEST_F(NotificationSubscriberManagerTest, BatchNotifyConsumedInner_003, Functi HWTEST_F(NotificationSubscriberManagerTest, BatchNotifyConsumed_001, Function | SmallTest | Level1) { std::vector> notifications; - sptr notificationMap = new NotificationSortingMap(); - sptr mockSubscriber = new MockAnsSubscriber(); - auto record = notificationSubscriberManager_->CreateSubscriberRecord(mockSubscriber); - notificationSubscriberManager_->BatchNotifyConsumed(notifications, notificationMap, record); - - sptr request = new NotificationRequest(); - sptr notification = new Notification(request); + sptr notificationMap(new NotificationSortingMap()); + sptr request(new NotificationRequest()); + sptr notification(new Notification(request)); notifications.emplace_back(notification); - notificationSubscriberManager_->notificationSubQueue_ = nullptr; - notificationSubscriberManager_->BatchNotifyConsumed(notifications, notificationMap, record); - EXPECT_NE(notificationSubscriberManager_, nullptr); + + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + auto isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_FALSE(isCallback); + + NotificationSubscriberManager notificationSubscriberManager; + auto record = notificationSubscriberManager.CreateSubscriberRecord(subscriber); + notificationSubscriberManager.BatchNotifyConsumed(notifications, notificationMap, record); + std::this_thread::sleep_for(std::chrono::milliseconds(200)); + isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_TRUE(isCallback); + + testAnsSubscriber->SetCallBack(false); + notificationSubscriberManager.notificationSubQueue_ = nullptr; + notificationSubscriberManager.BatchNotifyConsumed(notifications, notificationMap, record); + std::this_thread::sleep_for(std::chrono::milliseconds(200)); + isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_FALSE(isCallback); } +/** + * @tc.number : AddSubscriber001 + * @tc.name : AddSubscriber and params is nullptr + * @tc.desc : Test AddSubscriber . + */ +HWTEST_F(NotificationSubscriberManagerTest, AddSubscriber_001, Function | SmallTest | Level1) +{ + MockGetOsAccountLocalIdFromUid(false, 0); + NotificationSubscriberManager notificationSubscriberManager; + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + + ASSERT_EQ(notificationSubscriberManager.AddSubscriber( + subscriber, nullptr), (int)ERR_ANS_INVALID_PARAM); +} + +/** + * @tc.number : AddSubscriber_002 + * @tc.name : AddSubscriber and params is nullptr + * @tc.desc : Test AddSubscriber .he + */ +HWTEST_F(NotificationSubscriberManagerTest, AddSubscriber_002, Function | SmallTest | Level1) +{ + NotificationSubscriberManager notificationSubscriberManager; + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + auto isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_FALSE(isCallback); + sptr info(new NotificationSubscribeInfo()); + info->AddDeviceType("current"); + std::vector slotTypes; + slotTypes.push_back(NotificationConstant::SlotType::SOCIAL_COMMUNICATION); + info->SetSlotTypes(slotTypes); + + ASSERT_EQ(notificationSubscriberManager.AddSubscriber(subscriber, info), (int)ERR_OK); + + sptr notificationMap(new NotificationSortingMap()); + notificationSubscriberManager.NotifyUpdated(notificationMap); + std::this_thread::sleep_for(std::chrono::milliseconds(200)); + isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_TRUE(isCallback); + + ASSERT_EQ(notificationSubscriberManager.RemoveSubscriber(subscriber, nullptr), (int)ERR_OK); +} + +HWTEST_F(NotificationSubscriberManagerTest, IsSubscribedBysubscriber_001, Function | SmallTest | Level1) +{ + sptr request(new NotificationRequest()); + request->SetSlotType(NotificationConstant::SlotType::SOCIAL_COMMUNICATION); + request->SetCreatorUserId(101); + request->SetCreatorUid(101); + sptr notification(new Notification(request)); + + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + NotificationSubscriberManager notificationSubscriberManager; + std::shared_ptr record = + notificationSubscriberManager.CreateSubscriberRecord(subscriber); + + sptr subscribeInfo(new NotificationSubscribeInfo()); + subscribeInfo->SetSubscriberUid(101); + subscribeInfo->AddAppUserId(102); + notificationSubscriberManager.AddRecordInfo(record, subscribeInfo); + auto res = notificationSubscriberManager.IsSubscribedBysubscriber(record, notification); + ASSERT_FALSE(res); +} + +HWTEST_F(NotificationSubscriberManagerTest, IsSubscribedBysubscriber_002, Function | SmallTest | Level1) +{ + sptr request(new NotificationRequest()); + request->SetSlotType(NotificationConstant::SlotType::SOCIAL_COMMUNICATION); + request->SetCreatorUserId(101); + request->SetCreatorUid(101); + sptr notification(new Notification(request)); + + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + NotificationSubscriberManager notificationSubscriberManager; + std::shared_ptr record = + notificationSubscriberManager.CreateSubscriberRecord(subscriber); + + sptr subscribeInfo(new NotificationSubscribeInfo()); + subscribeInfo->SetSubscriberUid(101); + subscribeInfo->AddAppUserId(101); + notificationSubscriberManager.AddRecordInfo(record, subscribeInfo); + auto res = notificationSubscriberManager.IsSubscribedBysubscriber(record, notification); + ASSERT_TRUE(res); +} + +HWTEST_F(NotificationSubscriberManagerTest, IsSubscribedBysubscriber_003, Function | SmallTest | Level1) +{ + sptr request(new NotificationRequest()); + request->SetSlotType(NotificationConstant::SlotType::SOCIAL_COMMUNICATION); + request->SetCreatorUid(101); + sptr notification(new Notification(request)); + + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + NotificationSubscriberManager notificationSubscriberManager; + std::shared_ptr record = + notificationSubscriberManager.CreateSubscriberRecord(subscriber); + + std::vector slotTypes; + slotTypes.push_back(NotificationConstant::SlotType::OTHER); + sptr subscribeInfo(new NotificationSubscribeInfo()); + subscribeInfo->SetSlotTypes(slotTypes); + subscribeInfo->SetSubscriberUid(101); + notificationSubscriberManager.AddRecordInfo(record, subscribeInfo); + auto res = notificationSubscriberManager.IsSubscribedBysubscriber(record, notification); + ASSERT_FALSE(res); +} + +// /** +// * @tc.number : NotifyConsumed_001 +// * @tc.name : +// */ +HWTEST_F(NotificationSubscriberManagerTest, NotifyConsumed_001, Function | SmallTest | Level1) +{ + sptr notificationMap(new NotificationSortingMap()); + sptr request(new NotificationRequest()); + request->SetSlotType(NotificationConstant::SlotType::OTHER); + request->SetLabel("label"); + request->SetCreatorUid(0); + std::shared_ptr pictureContent = std::make_shared(); + EXPECT_NE(pictureContent, nullptr); + pictureContent->SetText("notification text"); + pictureContent->SetTitle("notification title"); + pictureContent->SetBigPicture(nullptr); + EXPECT_EQ(nullptr, pictureContent->GetBigPicture()); + std::shared_ptr content = std::make_shared(pictureContent); + EXPECT_NE(content, nullptr); + request->SetContent(content); + sptr notification(new Notification(request)); + + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + auto isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_FALSE(isCallback); + + NotificationSubscriberManager notificationSubscriberManager; + sptr info(new NotificationSubscribeInfo()); + ASSERT_EQ(notificationSubscriberManager.AddSubscriberInner(subscriber, info), (int)ERR_OK); + notificationSubscriberManager.NotifyConsumed(notification, notificationMap); + std::this_thread::sleep_for(std::chrono::milliseconds(400)); + isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_TRUE(isCallback); +} + +/** + * @tc.number : NotifyBadgeEnabledChanged_001 + * @tc.name : + */ +HWTEST_F(NotificationSubscriberManagerTest, NotifyBadgeEnabledChanged_001, Function | SmallTest | Level1) +{ + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + auto isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_FALSE(isCallback); + ASSERT_EQ(notificationSubscriberManager_->AddSubscriber(subscriber, nullptr), (int)ERR_OK); + + sptr callbackData(new EnabledNotificationCallbackData()); + notificationSubscriberManager_->NotifyBadgeEnabledChanged(callbackData); + std::this_thread::sleep_for(std::chrono::milliseconds(200)); + isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_TRUE(isCallback); +} + +/** + * @tc.number : ConsumeRecordFilter_001 + * @tc.name : + */ +HWTEST_F(NotificationSubscriberManagerTest, ConsumeRecordFilter_001, Function | SmallTest | Level1) +{ + std::shared_ptr actionButton = + std::make_shared(); + std::shared_ptr userInput = + std::make_shared(); + actionButton->AddNotificationUserInput(userInput); + + sptr request(new NotificationRequest()); + request->SetSlotType(NotificationConstant::SlotType::SOCIAL_COMMUNICATION); + request->AddActionButton(actionButton); + sptr notification(new Notification(request)); + + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + NotificationSubscriberManager notificationSubscriberManager; + std::shared_ptr record = + notificationSubscriberManager.CreateSubscriberRecord(subscriber); + + sptr subscribeInfo(new NotificationSubscribeInfo()); + subscribeInfo->SetFilterType(2); + notificationSubscriberManager.AddRecordInfo(record, subscribeInfo); + auto res = notificationSubscriberManager.ConsumeRecordFilter(record, notification); + ASSERT_FALSE(res); +} + +/** + * @tc.number : ConsumeRecordFilter_002 + * @tc.name : + */ +HWTEST_F(NotificationSubscriberManagerTest, ConsumeRecordFilter_002, Function | SmallTest | Level1) +{ + std::shared_ptr actionButton = std::make_shared(); + std::shared_ptr userInput = std::make_shared(); + actionButton->AddNotificationUserInput(userInput); + + sptr request(new NotificationRequest()); + request->SetSlotType(NotificationConstant::SlotType::SOCIAL_COMMUNICATION); + request->AddActionButton(actionButton); + sptr notification(new Notification(request)); + + NotificationSubscriberManager notificationSubscriberManager; + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + std::shared_ptr record = + notificationSubscriberManager.CreateSubscriberRecord(subscriber); + + sptr subscribeInfo(new NotificationSubscribeInfo()); + subscribeInfo->SetFilterType(4); + notificationSubscriberManager.AddRecordInfo(record, subscribeInfo); + auto res = notificationSubscriberManager.ConsumeRecordFilter(record, notification); + ASSERT_TRUE(res); +} + +/** + * @tc.number : ConsumeRecordFilter_003 + * @tc.name : + */ +HWTEST_F(NotificationSubscriberManagerTest, ConsumeRecordFilter_003, Function | SmallTest | Level1) +{ + sptr request(new NotificationRequest()); + request->SetSlotType(NotificationConstant::SlotType::SOCIAL_COMMUNICATION); + sptr notification(new Notification(request)); + + NotificationSubscriberManager notificationSubscriberManager; + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + std::shared_ptr record = + notificationSubscriberManager.CreateSubscriberRecord(subscriber); + + sptr subscribeInfo(new NotificationSubscribeInfo()); + subscribeInfo->SetFilterType(1); + notificationSubscriberManager.AddRecordInfo(record, subscribeInfo); + auto res = notificationSubscriberManager.ConsumeRecordFilter(record, notification); + ASSERT_FALSE(res); +} + +/** + * @tc.number : BatchNotifyCanceledInner_001 + * @tc.name : + */ +HWTEST_F(NotificationSubscriberManagerTest, BatchNotifyCanceledInner_001, Function | SmallTest | Level1) +{ + //build request + sptr notificationMap(new NotificationSortingMap()); + sptr request(new NotificationRequest()); + request->SetSlotType(NotificationConstant::SlotType::LIVE_VIEW); + request->SetLabel("label"); + request->SetCreatorUid(0); + std::shared_ptr liveViewContentcontent = + std::make_shared(); + liveViewContentcontent->SetText("notification text"); + liveViewContentcontent->SetTitle("notification title"); + std::map>> pixelMap; + liveViewContentcontent->SetPicture(pixelMap); + std::shared_ptr content = std::make_shared(liveViewContentcontent); + request->SetContent(content); + sptr notification(new Notification(request)); + + sptr requestLocal(new NotificationRequest()); + requestLocal->SetSlotType(NotificationConstant::SlotType::LIVE_VIEW); + requestLocal->SetLabel("label"); + requestLocal->SetCreatorUid(0); + std::shared_ptr liveViewLocalContentcontent = + std::make_shared(); + liveViewLocalContentcontent->SetText("notification text"); + liveViewLocalContentcontent->SetTitle("notification title"); + std::shared_ptr contentLocal = + std::make_shared(liveViewLocalContentcontent); + requestLocal->SetContent(contentLocal); + sptr notificationLocal(new Notification(requestLocal)); + + std::vector> notifications; + notifications.push_back(notification); + notifications.push_back(notificationLocal); + //build subscriber + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + auto isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_FALSE(isCallback); + + NotificationSubscriberManager notificationSubscriberManager; + sptr info(new NotificationSubscribeInfo()); + ASSERT_EQ(notificationSubscriberManager.AddSubscriberInner(subscriber, info), (int)ERR_OK); + //brach need nullptr + notificationSubscriberManager.subscriberRecordList_.push_back(nullptr); + + notificationSubscriberManager.BatchNotifyCanceledInner(notifications, notificationMap, 99); + std::this_thread::sleep_for(std::chrono::milliseconds(400)); + isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_TRUE(isCallback); +} + +/** + * @tc.number : NotifyDoNotDisturbDateChangedInner_001 + * @tc.name : + */ +HWTEST_F(NotificationSubscriberManagerTest, NotifyDoNotDisturbDateChangedInner_001, Function | SmallTest | Level1) +{ + //build notificationMap + sptr date(new NotificationDoNotDisturbDate()); + + //build subscriber + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + auto isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_FALSE(isCallback); + + NotificationSubscriberManager notificationSubscriberManager; + sptr info(new NotificationSubscribeInfo()); + info->AddAppUserId(101); + ASSERT_EQ(notificationSubscriberManager.AddSubscriberInner(subscriber, info), (int)ERR_OK); + + notificationSubscriberManager.NotifyDoNotDisturbDateChangedInner(101, date); + std::this_thread::sleep_for(std::chrono::milliseconds(200)); + isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_TRUE(isCallback); +} + + +/** + * @tc.number : NotifyEnabledNotificationChangedInner_002 + * @tc.name : + */ +HWTEST_F(NotificationSubscriberManagerTest, NotifyEnabledNotificationChangedInner_002, Function | SmallTest | Level1) +{ + //build notificationMap + sptr date(new EnabledNotificationCallbackData()); + date->SetUid(101); + + //build subscriber + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + auto isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_FALSE(isCallback); + + NotificationSubscriberManager notificationSubscriberManager; + sptr info(new NotificationSubscribeInfo()); + info->AddAppUserId(100); + ASSERT_EQ(notificationSubscriberManager.AddSubscriberInner(subscriber, info), (int)ERR_OK); + + notificationSubscriberManager.NotifyEnabledNotificationChangedInner(date); + std::this_thread::sleep_for(std::chrono::milliseconds(200)); + isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_TRUE(isCallback); +} + +/** + * @tc.number : SetBadgeNumber_001 + * @tc.name : + */ +HWTEST_F(NotificationSubscriberManagerTest, SetBadgeNumber_001, Function | SmallTest | Level1) +{ + //build notificationMap + sptr date(new BadgeNumberCallbackData()); + + //build subscriber + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + auto isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_FALSE(isCallback); + + NotificationSubscriberManager notificationSubscriberManager; + std::shared_ptr record = + notificationSubscriberManager.CreateSubscriberRecord(subscriber); + + sptr info(new NotificationSubscribeInfo()); + info->AddAppUserId(100); + ASSERT_EQ(notificationSubscriberManager.AddSubscriberInner(subscriber, info), (int)ERR_OK); + + notificationSubscriberManager.SetBadgeNumber(date); + std::this_thread::sleep_for(std::chrono::milliseconds(200)); + isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_TRUE(isCallback); +} + +/** + * @tc.number : NotifyApplicationInfoNeedChanged_001 + * @tc.name : + */ +HWTEST_F(NotificationSubscriberManagerTest, NotifyApplicationInfoNeedChanged_001, Function | SmallTest | Level1) +{ + //build subscriber + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + auto isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_FALSE(isCallback); + + NotificationSubscriberManager notificationSubscriberManager; + sptr info(new NotificationSubscribeInfo()); + info->SetNeedNotifyApplication(true); + ASSERT_EQ(notificationSubscriberManager.AddSubscriberInner(subscriber, info), (int)ERR_OK); + + notificationSubscriberManager.NotifyApplicationInfoNeedChanged("test"); + std::this_thread::sleep_for(std::chrono::milliseconds(200)); + isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_TRUE(isCallback); +} + +// /** +// * @tc.number : IsDeviceFlag_001 +// * @tc.name : +// */ +HWTEST_F(NotificationSubscriberManagerTest, IsDeviceFlag_001, Function | SmallTest | Level1) +{ + ///build request + sptr notificationMap(new NotificationSortingMap()); + sptr request(new NotificationRequest()); + request->SetSlotType(NotificationConstant::SlotType::LIVE_VIEW); + std::shared_ptr liveViewContentcontent = + std::make_shared(); + std::shared_ptr content = std::make_shared(liveViewContentcontent); + request->SetContent(content); + std::shared_ptr flags = std::make_shared(); + flags->SetReminderFlags(63); + request->SetFlags(flags); + + std::shared_ptr>> notificationFlagsOfDevices = + std::make_shared>>(); + + std::shared_ptr reminderFlags = std::make_shared(); + (*notificationFlagsOfDevices)[NotificationConstant::CURRENT_DEVICE_TYPE] = flags; + request->SetDeviceFlags(notificationFlagsOfDevices); + + sptr notification(new Notification(request)); + NotificationSubscriberManager notificationSubscriberManager; + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + std::shared_ptr subscriberRecord = + notificationSubscriberManager.CreateSubscriberRecord(subscriber); + + bool wearableFlag = false; + bool headsetFlag = false; + bool keyNodeFlag = false; + notificationSubscriberManager.IsDeviceFlag( + subscriberRecord, notification, wearableFlag, headsetFlag, keyNodeFlag); + ASSERT_TRUE(keyNodeFlag); + + request->SetFlags(nullptr); + keyNodeFlag = false; + notificationSubscriberManager.IsDeviceFlag( + subscriberRecord, notification, wearableFlag, headsetFlag, keyNodeFlag); + ASSERT_FALSE(keyNodeFlag); +} + +HWTEST_F(NotificationSubscriberManagerTest, IsDeviceFlag_002, Function | SmallTest | Level1) +{ + ///build request + sptr notificationMap(new NotificationSortingMap()); + sptr request(new NotificationRequest()); + std::shared_ptr liveViewContentcontent = + std::make_shared(); + std::shared_ptr content = + std::make_shared(liveViewContentcontent); + request->SetContent(content); + std::shared_ptr flags = std::make_shared(); + + std::shared_ptr>> notificationFlagsOfDevices = + std::make_shared>>(); + + std::shared_ptr reminderFlags = std::make_shared(); + (*notificationFlagsOfDevices)[NotificationConstant::CURRENT_DEVICE_TYPE] = flags; + request->SetDeviceFlags(notificationFlagsOfDevices); + + sptr notification(new Notification(request)); + + NotificationSubscriberManager notificationSubscriberManager; + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + std::shared_ptr subscriberRecord = + notificationSubscriberManager.CreateSubscriberRecord(subscriber); + + bool wearableFlag = false; + bool headsetFlag = false; + bool keyNodeFlag = false; + + (*notificationFlagsOfDevices)[DEVICE_TYPE_LITE_WEARABLE] = flags; + sptr subscribeInfo(new NotificationSubscribeInfo()); + subscribeInfo->AddDeviceType(DEVICE_TYPE_LITE_WEARABLE); + notificationSubscriberManager.AddRecordInfo(subscriberRecord, subscribeInfo); + + notificationSubscriberManager.IsDeviceFlag( + subscriberRecord, notification, wearableFlag, headsetFlag, keyNodeFlag); + ASSERT_TRUE(wearableFlag); +} + +HWTEST_F(NotificationSubscriberManagerTest, IsDeviceFlag_003, Function | SmallTest | Level1) +{ + ///build request + sptr notificationMap(new NotificationSortingMap()); + sptr request(new NotificationRequest()); + std::shared_ptr liveViewContentcontent = + std::make_shared(); + std::shared_ptr content = + std::make_shared(liveViewContentcontent); + request->SetContent(content); + std::shared_ptr flags = std::make_shared(); + + std::shared_ptr>> notificationFlagsOfDevices = + std::make_shared>>(); + + std::shared_ptr reminderFlags = std::make_shared(); + (*notificationFlagsOfDevices)[NotificationConstant::CURRENT_DEVICE_TYPE] = flags; + request->SetDeviceFlags(notificationFlagsOfDevices); + + sptr notification(new Notification(request)); + + NotificationSubscriberManager notificationSubscriberManager; + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + std::shared_ptr subscriberRecord = + notificationSubscriberManager.CreateSubscriberRecord(subscriber); + + bool wearableFlag = false; + bool headsetFlag = false; + bool keyNodeFlag = false; + + (*notificationFlagsOfDevices)[DEVICE_TYPE_WEARABLE] = flags; + sptr subscribeInfo(new NotificationSubscribeInfo()); + subscribeInfo->AddDeviceType(DEVICE_TYPE_WEARABLE); + notificationSubscriberManager.AddRecordInfo(subscriberRecord, subscribeInfo); + + notificationSubscriberManager.IsDeviceFlag( + subscriberRecord, notification, wearableFlag, headsetFlag, keyNodeFlag); + ASSERT_TRUE(wearableFlag); +} + +HWTEST_F(NotificationSubscriberManagerTest, IsDeviceFlag_004, Function | SmallTest | Level1) +{ + ///build request + sptr notificationMap(new NotificationSortingMap()); + sptr request(new NotificationRequest()); + request->SetSlotType(NotificationConstant::SlotType::LIVE_VIEW); + request->SetLabel("label"); + request->SetCreatorUid(0); + std::shared_ptr liveViewContentcontent = + std::make_shared(); + liveViewContentcontent->SetText("notification text"); + liveViewContentcontent->SetTitle("notification title"); + std::shared_ptr content = std::make_shared(liveViewContentcontent); + request->SetContent(content); + std::shared_ptr flags = std::make_shared(); + + std::shared_ptr>> notificationFlagsOfDevices = + std::make_shared>>(); + + std::shared_ptr reminderFlags = std::make_shared(); + (*notificationFlagsOfDevices)[NotificationConstant::CURRENT_DEVICE_TYPE] = flags; + request->SetDeviceFlags(notificationFlagsOfDevices); + + sptr notification(new Notification(request)); + + NotificationSubscriberManager notificationSubscriberManager; + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + std::shared_ptr subscriberRecord = + notificationSubscriberManager.CreateSubscriberRecord(subscriber); + + bool wearableFlag = false; + bool headsetFlag = false; + bool keyNodeFlag = false; + + (*notificationFlagsOfDevices)[DEVICE_TYPE_HEADSET] = flags; + sptr subscribeInfo(new NotificationSubscribeInfo()); + subscribeInfo->AddDeviceType(DEVICE_TYPE_HEADSET); + notificationSubscriberManager.AddRecordInfo(subscriberRecord, subscribeInfo); + + notificationSubscriberManager.IsDeviceFlag( + subscriberRecord, notification, wearableFlag, headsetFlag, keyNodeFlag); + ASSERT_TRUE(headsetFlag); + headsetFlag = false; + + notificationSubscriberManager.IsDeviceFlag( + subscriberRecord, nullptr, wearableFlag, headsetFlag, keyNodeFlag); + ASSERT_FALSE(headsetFlag); + + sptr nullNotification(nullptr); + notificationSubscriberManager.IsDeviceFlag( + subscriberRecord, nullNotification, wearableFlag, headsetFlag, keyNodeFlag); + ASSERT_FALSE(headsetFlag); +} + +/** + * @tc.number : DistributeOperation_001 + * @tc.name : + */ +HWTEST_F(NotificationSubscriberManagerTest, DistributeOperation_001, Function | SmallTest | Level1) +{ + sptr operationInfo(new NotificationOperationInfo); + //build subscriber + std::shared_ptr testAnsSubscriber = std::make_shared(); + sptr subscriber(new (std::nothrow) SubscriberListener(testAnsSubscriber)); + auto isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_FALSE(isCallback); + + NotificationSubscriberManager notificationSubscriberManager; + sptr info(new NotificationSubscribeInfo()); + info->SetNeedNotifyResponse(true); + ASSERT_EQ(notificationSubscriberManager.AddSubscriberInner(subscriber, info), (int)ERR_OK); + + notificationSubscriberManager.DistributeOperation(operationInfo); + std::this_thread::sleep_for(std::chrono::milliseconds(400)); + isCallback = testAnsSubscriber->GetCallBack(); + ASSERT_TRUE(isCallback); +} /** * @tc.number : OnRemoteDied_001 * @tc.name : OnRemoteDied and params is nullptr -- Gitee