From b124f38c3ddb4cf40fc1fab714476bf4bc03d46f Mon Sep 17 00:00:00 2001 From: zhengzhuolan Date: Mon, 20 Jan 2025 09:27:38 +0800 Subject: [PATCH] =?UTF-8?q?=E5=8D=8F=E5=90=8C=E5=88=A0=E9=99=A4tdd?= =?UTF-8?q?=E8=A1=A5=E5=85=85?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhengzhuolan --- services/distributed/test/unittest/BUILD.gn | 2 + .../unittest/distributed_service_test.cpp | 196 +++++++++++++++++ .../unittest/distributed_subscriber_test.cpp | 202 ++++++++++++++++++ 3 files changed, 400 insertions(+) create mode 100644 services/distributed/test/unittest/distributed_service_test.cpp create mode 100644 services/distributed/test/unittest/distributed_subscriber_test.cpp diff --git a/services/distributed/test/unittest/BUILD.gn b/services/distributed/test/unittest/BUILD.gn index 498f66e0a..fc948221f 100644 --- a/services/distributed/test/unittest/BUILD.gn +++ b/services/distributed/test/unittest/BUILD.gn @@ -29,6 +29,8 @@ group("ans_unit_test") { ":distributed_preferences_branch_test", ":distributed_preferences_database_test", ":distributed_screen_status_manager_branch_test", + ":distributed_service_test", + ":distributed_subscriber_test", ] } } diff --git a/services/distributed/test/unittest/distributed_service_test.cpp b/services/distributed/test/unittest/distributed_service_test.cpp new file mode 100644 index 000000000..8c1a429ce --- /dev/null +++ b/services/distributed/test/unittest/distributed_service_test.cpp @@ -0,0 +1,196 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "gtest/gtest.h" +#define private public +#include "batch_remove_box.h" +#include "distributed_service.h" +#undef private +#include "remove_box.h" + +using namespace testing::ext; + +namespace OHOS { +namespace Notification { +class DistributedServiceTest : public testing::Test { +public: + void SetUp() override; + void TearDown() override; +}; + +void DistributedServiceTest::SetUp() {} + +void DistributedServiceTest::TearDown() {} + +/** + * @tc.name : DistributedServiceTest_00100 + * @tc.number : DistributedServiceTest_00100 + * @tc.desc : Test the RemoveNotification function with a null boxMessage. + */ +HWTEST_F(DistributedServiceTest, DistributedServiceTest_00100, Function | SmallTest | Level1) +{ + std::shared_ptr boxMessage = nullptr; + DistributedService::GetInstance().RemoveNotification(boxMessage); +} + +/** + * @tc.name : DistributedServiceTest_00200 + * @tc.number : DistributedServiceTest_00200 + * @tc.desc : Test the RemoveNotification function with a valid NotificationRemoveBox. + */ +HWTEST_F(DistributedServiceTest, DistributedServiceTest_00200, Function | SmallTest | Level1) +{ + NotificationRemoveBox removeBox; + std::string notificationKey = "notificationId"; + removeBox.SetNotificationHashCode(notificationKey); + DistributedService::GetInstance().RemoveNotification(removeBox.box_); +} + +/** + * @tc.name : DistributedServiceTest_00300 + * @tc.number : DistributedServiceTest_00300 + * @tc.desc : Test the RemoveNotification function with empty notificationKey. + */ +HWTEST_F(DistributedServiceTest, DistributedServiceTest_00300, Function | SmallTest | Level1) +{ + std::shared_ptr boxMessage = nullptr; + DistributedService::GetInstance().RemoveNotifications(boxMessage); +} + +/** + * @tc.name : DistributedServiceTest_00400 + * @tc.number : DistributedServiceTest_00400 + * @tc.desc : Test the OnBatchCanceled function with an valid notifications. + */ +HWTEST_F(DistributedServiceTest, DistributedServiceTest_00400, Function | SmallTest | Level1) +{ + BatchRemoveNotificationBox batchRemoveBox; + std::string hashCodes = "notificationId1 notificationId2"; + batchRemoveBox.SetNotificationHashCode(hashCodes); + DistributedService::GetInstance().RemoveNotifications(batchRemoveBox.box_); +} + +/** + * @tc.name : DistributedServiceTest_00500 + * @tc.number : DistributedServiceTest_00500 + * @tc.desc : Test the OnBatchCanceled function with a null serviceQueue_. + */ +HWTEST_F(DistributedServiceTest, DistributedServiceTest_00500, Function | SmallTest | Level1) +{ + std::vector> notifications; + DistributedDeviceInfo peerDevice; + + std::shared_ptr serviceQueue = DistributedService::GetInstance().serviceQueue_; + DistributedService::GetInstance().serviceQueue_ = nullptr; + DistributedService::GetInstance().OnBatchCanceled(notifications, peerDevice); + DistributedService::GetInstance().serviceQueue_ = serviceQueue; +} + +/** + * @tc.name : DistributedServiceTest_00600 + * @tc.number : DistributedServiceTest_00600 + * @tc.desc : Test the OnBatchCanceled function with valid notifications and peer device. + */ +HWTEST_F(DistributedServiceTest, DistributedServiceTest_00600, Function | SmallTest | Level1) +{ + std::vector> notifications; + DistributedDeviceInfo peerDevice; + peerDevice.deviceId_ = 1; + peerDevice.deviceType_ = 1; + + std::shared_ptr notificationNull = nullptr; + sptr request = new NotificationRequest(); + std::shared_ptr notification = std::make_shared(request); + notification->SetKey("notificationKey"); + notifications.push_back(notificationNull); + notifications.push_back(notification); + DistributedService::GetInstance().OnBatchCanceled(notifications, peerDevice); +} + +/** + * @tc.name : DistributedServiceTest_00700 + * @tc.number : DistributedServiceTest_00700 + * @tc.desc : Test the OnCanceled function with a valid notification and peer device. + */ +HWTEST_F(DistributedServiceTest, DistributedServiceTest_00700, Function | SmallTest | Level1) +{ + sptr request = new NotificationRequest(); + std::shared_ptr notification = std::make_shared(request); + notification->SetKey("notificationKey"); + DistributedDeviceInfo peerDevice; + peerDevice.deviceId_ = 1; + peerDevice.deviceType_ = 1; + + std::shared_ptr serviceQueue = DistributedService::GetInstance().serviceQueue_; + DistributedService::GetInstance().serviceQueue_ = nullptr; + DistributedService::GetInstance().OnCanceled(notification, peerDevice); + DistributedService::GetInstance().serviceQueue_ = serviceQueue; +} + +/** + * @tc.name : DistributedServiceTest_00800 + * @tc.number : DistributedServiceTest_00800 + * @tc.desc : Test the OnCanceled function with a null notification. + */ +HWTEST_F(DistributedServiceTest, DistributedServiceTest_00800, Function | SmallTest | Level1) +{ + std::shared_ptr notificationNull = nullptr; + DistributedDeviceInfo peerDevice; + DistributedService::GetInstance().OnCanceled(notificationNull, peerDevice); +} + +/** + * @tc.name : DistributedServiceTest_00900 + * @tc.number : DistributedServiceTest_00900 + * @tc.desc : Test the OnCanceled function with a valid notification and null peer device. + */ +HWTEST_F(DistributedServiceTest, DistributedServiceTest_00900, Function | SmallTest | Level1) +{ + sptr request = new NotificationRequest(); + std::shared_ptr notification = std::make_shared(request); + notification->SetKey("notificationKey"); + DistributedDeviceInfo peerDevice; + peerDevice.deviceId_ = 1; + peerDevice.deviceType_ = 1; + DistributedService::GetInstance().OnCanceled(notification, peerDevice); +} + +/** + * @tc.name : DistributedServiceTest_01000 + * @tc.number : DistributedServiceTest_01000 + * @tc.desc : Test the OnCanceled function with a null notification. + */ +HWTEST_F(DistributedServiceTest, DistributedServiceTest_01000, Function | SmallTest | Level1) +{ + std::shared_ptr notificationNull = nullptr; + DistributedService::GetInstance().GetNotificationKey(notificationNull); +} + +/** + * @tc.name : DistributedServiceTest_01100 + * @tc.number : DistributedServiceTest_01100 + * @tc.desc : Test the OnCanceled function with a valid notification. + */ +HWTEST_F(DistributedServiceTest, DistributedServiceTest_01100, Function | SmallTest | Level1) +{ + sptr request = new NotificationRequest(); + std::shared_ptr notification = std::make_shared(request); + notification->SetKey("notificationKey"); + DistributedService::GetInstance().GetNotificationKey(notification); +} +} // namespace Notification +} // namespace OHOS \ No newline at end of file diff --git a/services/distributed/test/unittest/distributed_subscriber_test.cpp b/services/distributed/test/unittest/distributed_subscriber_test.cpp new file mode 100644 index 000000000..719080100 --- /dev/null +++ b/services/distributed/test/unittest/distributed_subscriber_test.cpp @@ -0,0 +1,202 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "gtest/gtest.h" +#define private public +#include "distributed_service.h" +#include "distributed_subscriber.h" +#undef private +#include "notification.h" +#include "notification_request.h" + +using namespace testing::ext; + +namespace OHOS { +namespace Notification { +class DistribuedSubscriberTest : public testing::Test { +public: + void SetUp() override; + void TearDown() override; + +private: + std::unordered_set collaborativeDeleteTypes_; +}; + +void DistribuedSubscriberTest::SetUp() +{ + collaborativeDeleteTypes_ = DistributedService::GetInstance().localDevice_.collaborativeDeleteTypes_; + std::unordered_set collaborativeDeleteTypes({ "LIVE_VIEW" }); + DistributedService::GetInstance().localDevice_.collaborativeDeleteTypes_ = collaborativeDeleteTypes; +} + +void DistribuedSubscriberTest::TearDown() +{ + DistributedService::GetInstance().localDevice_.collaborativeDeleteTypes_ = collaborativeDeleteTypes_; +} + +/** + * @tc.name : DistribuedSubscriberTest_00100 + * @tc.number : DistribuedSubscriberTest_00100 + * @tc.desc : Test the SubscribeNotification function with null notification. + */ +HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_00100, Function | SmallTest | Level1) +{ + std::shared_ptr notification = nullptr; + std::shared_ptr subscriber = std::make_shared(); + EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false); +} + +/** + * @tc.name : DistribuedSubscriberTest_00200 + * @tc.number : DistribuedSubscriberTest_00200 + * @tc.desc : Test the SubscribeNotification function with null SlotType. + */ +HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_00200, Function | SmallTest | Level1) +{ + sptr request = new NotificationRequest(); + std::shared_ptr notification = std::make_shared(request); + std::shared_ptr subscriber = std::make_shared(); + EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false); +} + +/** + * @tc.name : DistribuedSubscriberTest_00300 + * @tc.number : DistribuedSubscriberTest_00300 + * @tc.desc : Test the UnSubscribeNotification function with SlotType SOCIAL_COMMUNICATION. + */ +HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_00300, Function | SmallTest | Level1) +{ + sptr request = new NotificationRequest(); + request->SetSlotType(NotificationConstant::SlotType::SOCIAL_COMMUNICATION); + std::shared_ptr notification = std::make_shared(request); + std::shared_ptr subscriber = std::make_shared(); + EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false); +} + +/** + * @tc.name : DistribuedSubscriberTest_00400 + * @tc.number : DistribuedSubscriberTest_00400 + * @tc.desc : Test the UnSubscribeNotification function with SlotType SERVICE_REMINDER. + */ +HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_00400, Function | SmallTest | Level1) +{ + sptr request = new NotificationRequest(); + request->SetSlotType(NotificationConstant::SlotType::SERVICE_REMINDER); + std::shared_ptr notification = std::make_shared(request); + std::shared_ptr subscriber = std::make_shared(); + EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false); +} + +/** + * @tc.name : DistribuedSubscriberTest_00500 + * @tc.number : DistribuedSubscriberTest_00500 + * @tc.desc : Test the UnSubscribeNotification function with SlotType CONTENT_INFORMATION. + */ +HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_00500, Function | SmallTest | Level1) +{ + sptr request = new NotificationRequest(); + request->SetSlotType(NotificationConstant::SlotType::CONTENT_INFORMATION); + std::shared_ptr notification = std::make_shared(request); + std::shared_ptr subscriber = std::make_shared(); + EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false); +} + +/** + * @tc.name : DistribuedSubscriberTest_00600 + * @tc.number : DistribuedSubscriberTest_00600 + * @tc.desc : Test the SubscribeNotification function with SlotType OTHER. + */ +HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_00600, Function | SmallTest | Level1) +{ + sptr request = new NotificationRequest(); + request->SetSlotType(NotificationConstant::SlotType::OTHER); + std::shared_ptr notification = std::make_shared(request); + std::shared_ptr subscriber = std::make_shared(); + EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false); +} + +/** + * @tc.name : DistribuedSubscriberTest_00700 + * @tc.number : DistribuedSubscriberTest_00700 + * @tc.desc : Test the SubscribeNotification function with SlotType CUSTOM. + */ +HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_00700, Function | SmallTest | Level1) +{ + sptr request = new NotificationRequest(); + request->SetSlotType(NotificationConstant::SlotType::CUSTOM); + std::shared_ptr notification = std::make_shared(request); + std::shared_ptr subscriber = std::make_shared(); + EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false); +} + +/** + * @tc.name : DistribuedSubscriberTest_00800 + * @tc.number : DistribuedSubscriberTest_00800 + * @tc.desc : Test the UnSubscribeNotification function with SlotType LIVE_VIEW. + */ +HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_00800, Function | SmallTest | Level1) +{ + sptr request = new NotificationRequest(); + request->SetSlotType(NotificationConstant::SlotType::LIVE_VIEW); + std::shared_ptr notification = std::make_shared(request); + std::shared_ptr subscriber = std::make_shared(); + EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), true); +} + +/** + * @tc.name : DistribuedSubscriberTest_00900 + * @tc.number : DistribuedSubscriberTest_00900 + * @tc.desc : Test the UnSubscribeNotification function with SlotType CUSTOMER_SERVICE. + */ +HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_00900, Function | SmallTest | Level1) +{ + sptr request = new NotificationRequest(); + request->SetSlotType(NotificationConstant::SlotType::CUSTOMER_SERVICE); + std::shared_ptr notification = std::make_shared(request); + std::shared_ptr subscriber = std::make_shared(); + EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false); +} + +/** + * @tc.name : DistribuedSubscriberTest_01000 + * @tc.number : DistribuedSubscriberTest_01000 + * @tc.desc : Test the UnSubscribeNotification function with SlotType EMERGENCY_INFORMATION. + */ +HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_01000, Function | SmallTest | Level1) +{ + sptr request = new NotificationRequest(); + request->SetSlotType(NotificationConstant::SlotType::EMERGENCY_INFORMATION); + std::shared_ptr notification = std::make_shared(request); + std::shared_ptr subscriber = std::make_shared(); + EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false); +} + +/** + * @tc.name : DistribuedSubscriberTest_01100 + * @tc.number : DistribuedSubscriberTest_01100 + * @tc.desc : Test the SubscribeNotification function with SlotType ILLEGAL_TYPE. + */ +HWTEST_F(DistribuedSubscriberTest, DistribuedSubscriberTest_01100, Function | SmallTest | Level1) +{ + sptr request = new NotificationRequest(); + request->SetSlotType(NotificationConstant::SlotType::ILLEGAL_TYPE); + std::shared_ptr notification = std::make_shared(request); + std::shared_ptr subscriber = std::make_shared(); + EXPECT_EQ(subscriber->CheckNeedCollaboration(notification), false); +} +} // namespace Notification +} // namespace OHOS \ No newline at end of file -- Gitee