diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 9325d03ef428e43f7cc3753ec610c25ac8d08270..2bb887d62454f8bad34a378407d6d25c49b48842 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -25,6 +25,7 @@ group("unittest") { ":UTTest_device_manager_service", ":UTTest_device_manager_service_listener", ":UTTest_dm_auth_manager", + ":UTTest_dm_common_event_manager", ":UTTest_dm_device_info_manager", ":UTTest_dm_device_state_manager", ":UTTest_dm_discovery_manager", @@ -39,6 +40,17 @@ group("unittest") { ] } +## UnitTest UTTest_dm_common_event_manager {{{ +ohos_unittest("UTTest_dm_common_event_manager") { + module_out_path = module_out_path + + sources = [ "UTTest_dm_common_event_manager.cpp" ] + + deps = [ ":device_manager_test_common" ] +} + +## UnitTest UTTest_dm_common_event_manager }}} + ## UnitTest device_manager_impl_test {{{ ohos_unittest("device_manager_impl_test") { module_out_path = module_out_path @@ -403,6 +415,9 @@ ohos_static_library("device_manager_test_common") { "${innerkits_path}/native_cpp:devicemanagersdk", "${services_path}:devicemanagerservice", "${utils_path}:devicemanagerutils", + "//base/notification/ces_standard/frameworks/core:cesfwk_core", + "//base/notification/ces_standard/frameworks/native:cesfwk_innerkits", + "//foundation/aafwk/standard/interfaces/innerkits/want:want", "//foundation/communication/ipc/interfaces/innerkits/ipc_core:ipc_core", "//foundation/distributedhardware/devicemanager/interfaces/kits/js:devicemanager", "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy:samgr_proxy", @@ -512,4 +527,4 @@ ohos_static_library("device_manager_test") { "samgr_standard:samgr_proxy", ] } -## Build device_manager_test.a }}} +## Build device_manager_test.a }}} \ No newline at end of file diff --git a/test/unittest/UTTest_device_manager_service_listener.cpp b/test/unittest/UTTest_device_manager_service_listener.cpp index 8f85f3dd6f94b1b2c51c533eff81aea3b2a885c5..bcf55e5d43ca87c44f1152285690a0bdaa3e5716 100644 --- a/test/unittest/UTTest_device_manager_service_listener.cpp +++ b/test/unittest/UTTest_device_manager_service_listener.cpp @@ -107,6 +107,70 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnVerifyAuthResult_001, testing::ext: std::string ret = pReq->GetDeviceId(); EXPECT_EQ(ret, deviceId); } + +/** + * @tc.name: OnDeviceFound_001 + * @tc.desc: OnDeviceFound,construct a dummy listener, pass in pkgName, subscribeId, info + * deviceId + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceListenerTest, OnDeviceFound_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr listener_ = std::make_shared(); + std::string pkgName = "com.ohos.helloworld"; + DmDeviceInfo info = { + .deviceId = "dkdkd", + .deviceName = "asda", + .deviceTypeId = 1, + }; + uint16_t subscribeId = 1; + listener_->OnDeviceFound(pkgName, subscribeId, info); +} + +/** + * @tc.name: OnDiscoveryFailed_001 + * @tc.desc: OnDeviceFound,construct a dummy listener, pass in pkgName, subscribeId, failedReason + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceListenerTest, OnDiscoveryFailed_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr listener_ = std::make_shared(); + std::string pkgName = "com.ohos.helloworld"; + std::string deviceId = "dkdkd"; + uint16_t subscribeId = 1; + int32_t failedReason = 1; + listener_->OnDiscoveryFailed(pkgName, subscribeId, failedReason); +} + +/** + * @tc.name: OnDiscoverySuccess_001 + * @tc.desc: OnDeviceFound,construct a dummy listener, pass in pkgName, subscribeId + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceListenerTest, OnDiscoverySuccess_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr listener_ = std::make_shared(); + std::string pkgName = "com.ohos.helloworld"; + uint16_t subscribeId = 1; + listener_->OnDiscoverySuccess(pkgName, subscribeId); +} + +/** + * @tc.name: OnFaCall_001 + * @tc.desc: OnFaCall, construct a dummy listener, pass in pkgName, paramJson + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceListenerTest, OnFaCall_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr listener_ = std::make_shared(); + std::string pkgName = "com.ohos.helloworld"; + std::string paramJson = "ahaha"; + listener_->OnFaCall(pkgName, paramJson); +} } // namespace } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/test/unittest/UTTest_dm_common_event_manager.cpp b/test/unittest/UTTest_dm_common_event_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..797663f0a20afc6e861e9d1eabf7116c633cd0a4 --- /dev/null +++ b/test/unittest/UTTest_dm_common_event_manager.cpp @@ -0,0 +1,126 @@ +/* + * Copyright (c) 2021 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 "dm_common_event_manager.h" +#include "dm_constants.h" +#include "hichain_connector.h" +#include "UTTest_dm_common_event_manager.h" + +namespace OHOS { +namespace DistributedHardware { +void DmCommonEventManagerTest::SetUp() +{ +} + +void DmCommonEventManagerTest::TearDown() +{ +} + +void DmCommonEventManagerTest::SetUpTestCase() +{ +} + +void DmCommonEventManagerTest::TearDownTestCase() +{ +} + +namespace { +/** + * @tc.name: DmCommonEventManager::~DmCommonEventManager_001 + * @tc.desc: Destructor of DmCommonEventManager + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmCommonEventManagerTest, DeleteDmCommonEventManager_001, testing::ext::TestSize.Level0) +{ + DmCommonEventManager::GetInstance().~DmCommonEventManager(); +} + +/** + * @tc.name: DmCommonEventManager::SubscribeServiceEvent_001 + * @tc.desc: call SubscribeServiceEvent(), pass parameters： strEvent and callbackNode.callback_ + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmCommonEventManagerTest, SubscribeServiceEvent_001, testing::ext::TestSize.Level0) +{ + std::string strEvent = "test"; + CommomEventCallbackNode callbackNode; + callbackNode.callback_ = nullptr; + bool result = DmCommonEventManager::GetInstance().SubscribeServiceEvent(strEvent, callbackNode.callback_); + EXPECT_EQ(false, result); +} + +/** + * @tc.name: DmCommonEventManager::SubscribeServiceEvent_002 + * @tc.desc: call SubscribeServiceEvent(), pass parameters： strEvent and callbackNode.callback_ + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmCommonEventManagerTest, SubscribeServiceEvent_002, testing::ext::TestSize.Level0) +{ + std::string strEvent = "test"; + CommomEventCallbackNode callbackNode; + std::shared_ptr subscriber = nullptr; + bool result = DmCommonEventManager::GetInstance().SubscribeServiceEvent(strEvent, callbackNode.callback_); + EXPECT_EQ(false, result); +} + +/** + * @tc.name: DmCommonEventManager::SubscribeServiceEvent_003 + * @tc.desc: call SubscribeServiceEvent(), pass parameters： strEvent and callbackNode.callback_ + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmCommonEventManagerTest, SubscribeServiceEvent_003, testing::ext::TestSize.Level0) +{ + std::string strEvent = "test"; + CommomEventCallbackNode callbackNode; + bool result = DmCommonEventManager::GetInstance().SubscribeServiceEvent(strEvent, callbackNode.callback_); + EXPECT_EQ(false, result); +} +/** + * @tc.name: DmCommonEventManager::UnsubscribeServiceEvent_001 + * @tc.desc: call UnsubscribeServiceEvent(), pass parameters： strEvent + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmCommonEventManagerTest, UnsubscribeServiceEvent_001, testing::ext::TestSize.Level0) +{ + std::string strEvent = "test"; + bool result = DmCommonEventManager::GetInstance().UnsubscribeServiceEvent(strEvent); + EXPECT_EQ(false, result); +} + +/** + * @tc.name: DmCommonEventManager::EventSubscriber::OnReceiveEvent_001 + * @tc.desc: call OnReceiveEvent(), pass parameters： data + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmCommonEventManagerTest, OnReceiveEvent_001, testing::ext::TestSize.Level0) +{ + EventFwk::CommonEventData data; + EventFwk::CommonEventSubscribeInfo subscribeInfo; + CommomEventCallbackNode callbackNode; + std::string strEvent = "test"; + std::shared_ptr eventSubscriber = + std::make_shared(subscribeInfo, callbackNode.callback_, strEvent); + eventSubscriber->OnReceiveEvent(data); +} +} // namespace +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/test/unittest/UTTest_dm_common_event_manager.h b/test/unittest/UTTest_dm_common_event_manager.h new file mode 100644 index 0000000000000000000000000000000000000000..cc4c8c115958d1c0761adfca11e4148894812522 --- /dev/null +++ b/test/unittest/UTTest_dm_common_event_manager.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef OHOS_DM_COMMON_EVENT_MANAGER_TEST_H +#define OHOS_DM_COMMON_EVENT_MANAGER_TEST_H + +#include +#include +#include +#include +#include "dm_common_event_manager.h" + +namespace OHOS { +namespace DistributedHardware { +class DmCommonEventManagerTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + virtual void SetUp() override; + virtual void TearDown() override; +}; +} // namespace DistributedHardware +} // namespace OHOS + +#endif // OHOS_DM_COMMON_EVENT_MANAGER_TEST_H \ No newline at end of file diff --git a/test/unittest/UTTest_dm_device_state_manager.cpp b/test/unittest/UTTest_dm_device_state_manager.cpp index af0a2addaf096b8bf9b6444cee400e0810685ef2..57ed176217742bde399186f05d695b14da1cf462 100644 --- a/test/unittest/UTTest_dm_device_state_manager.cpp +++ b/test/unittest/UTTest_dm_device_state_manager.cpp @@ -77,6 +77,17 @@ HWTEST_F(DmDeviceStateManagerTest, DmDeviceStateManager_002, testing::ext::TestS EXPECT_EQ(p, nullptr); } +/** + * @tc.name: DestructDmDeviceStateManager_001 + * @tc.desc: set DmDeviceStateManager to tne new pointer,and it's not nullptr + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDeviceStateManagerTest, DestructDmDeviceStateManager_001, testing::ext::TestSize.Level0) +{ + dmDeviceStateManager->~DmDeviceStateManager(); +} + /** * @tc.name: OnDeviceOnline_001 * @tc.desc: set info.deviceId to some para, and return it @@ -203,6 +214,147 @@ HWTEST_F(DmDeviceStateManagerTest, RegisterSoftbusStateCallback_001, testing::ex int ret = dmDeviceStateManager->RegisterSoftbusStateCallback(); EXPECT_EQ(ret, DM_OK); } + +/** + * @tc.name: RegisterProfileListener_001 + * @tc.desc: call RegisterProfileListener and return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDeviceStateManagerTest, RegisterProfileListener_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "123"; + DmDeviceInfo info = { + .deviceId = "123", + .deviceName = "asda", + .deviceTypeId = 1, + }; + dmDeviceStateManager->RegisterOffLineTimer(info); + int ret = dmDeviceStateManager->RegisterProfileListener(pkgName, info); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: UnRegisterProfileListener_001 + * @tc.desc: call UnRegisterProfileListener and return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDeviceStateManagerTest, UnRegisterProfileListener_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "123"; + DmDeviceInfo info = { + .deviceId = "123", + .deviceName = "asda", + .deviceTypeId = 1, + }; + dmDeviceStateManager->RegisterOffLineTimer(info); + int ret = dmDeviceStateManager->UnRegisterProfileListener(pkgName, info); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: PostDeviceOnline_001 + * @tc.desc: call PostDeviceOnline + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDeviceStateManagerTest, PostDeviceOnline_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "123"; + DmDeviceInfo info = { + .deviceId = "123", + .deviceName = "asda", + .deviceTypeId = 1, + }; + dmDeviceStateManager->PostDeviceOnline(pkgName, info); +} + +/** + * @tc.name: PostDeviceOffline_001 + * @tc.desc: call PostDeviceOffline + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDeviceStateManagerTest, PostDeviceOffline_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "123"; + DmDeviceInfo info = { + .deviceId = "123", + .deviceName = "asda", + .deviceTypeId = 1, + }; + dmDeviceStateManager->PostDeviceOffline(pkgName, info); +} + +/** + * @tc.name: RegisterDevStateCallback_001 + * @tc.desc: call RegisterDevStateCallback + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDeviceStateManagerTest, RegisterDevStateCallback_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "123"; + std::string extra = "ahaha"; + dmDeviceStateManager->RegisterDevStateCallback(pkgName, extra); +} + +/** + * @tc.name: UnRegisterDevStateCallback_001 + * @tc.desc: call UnRegisterDevStateCallback + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDeviceStateManagerTest, UnRegisterDevStateCallback_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "123"; + std::string extra; + dmDeviceStateManager->UnRegisterDevStateCallback(pkgName, extra); +} + +/** + * @tc.name: RegisterOffLineTimer_001 + * @tc.desc: call RegisterOffLineTimer + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDeviceStateManagerTest, RegisterOffLineTimer_001, testing::ext::TestSize.Level0) +{ + DmDeviceInfo info = { + .deviceId = "123", + .deviceName = "asda", + .deviceTypeId = 1, + }; + dmDeviceStateManager->RegisterOffLineTimer(info); +} + +/** + * @tc.name: StartOffLineTimer_001 + * @tc.desc: call StartOffLineTimer + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDeviceStateManagerTest, StartOffLineTimer_001, testing::ext::TestSize.Level0) +{ + DmDeviceInfo info = { + .deviceId = "123", + .deviceName = "asda", + .deviceTypeId = 1, + }; + dmDeviceStateManager->StartOffLineTimer(info); +} + +/** + * @tc.name: DeleteTimeOutGroup_001 + * @tc.desc: call DeleteTimeOutGroup + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDeviceStateManagerTest, DeleteTimeOutGroup_001, testing::ext::TestSize.Level0) +{ + dmDeviceStateManager->DeleteTimeOutGroup("123"); +} } // namespace } // namespace DistributedHardware -} // namespace OHOS +} // namespace OHOS \ No newline at end of file