From 04a01ba6f42ddf954001344eae05716c47506a65 Mon Sep 17 00:00:00 2001 From: xinxin13 Date: Fri, 16 Dec 2022 13:08:51 +0800 Subject: [PATCH 1/2] =?UTF-8?q?TDD=20=E6=B5=8B=E8=AF=95=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E8=A1=A5=E5=85=85=20=E6=8C=91=E5=8D=95monthly?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: xinxin13 --- test/unittest/BUILD.gn | 2 + test/unittest/ability_manager_test/BUILD.gn | 65 ++ .../ability_manager_stub_mock.h | 351 +++++++-- .../ability_manager_test.cpp | 139 ++++ test/unittest/continuation_test/BUILD.gn | 2 + .../BUILD.gn | 70 ++ ...ontinuation_device_callback_proxy_test.cpp | 139 ++++ .../BUILD.gn | 108 +++ ...ntinuation_register_manager_proxy_test.cpp | 675 ++++++++++++++++++ 9 files changed, 1476 insertions(+), 75 deletions(-) create mode 100644 test/unittest/ability_manager_test/BUILD.gn create mode 100644 test/unittest/ability_manager_test/ability_manager_test.cpp create mode 100644 test/unittest/continuation_test/remote_register_service_test/continuation_device_callback_proxy_test/BUILD.gn create mode 100644 test/unittest/continuation_test/remote_register_service_test/continuation_device_callback_proxy_test/continuation_device_callback_proxy_test.cpp create mode 100644 test/unittest/continuation_test/remote_register_service_test/continuation_register_manager_proxy_test/BUILD.gn create mode 100644 test/unittest/continuation_test/remote_register_service_test/continuation_register_manager_proxy_test/continuation_register_manager_proxy_test.cpp diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 6165bec17a9..bf0be615839 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -64,6 +64,7 @@ ohos_source_set("appmgr_test_source") { "//third_party/googletest:gmock_main", "//third_party/googletest:gtest_main", ] + cflags = [] if (target_cpu == "arm") { cflags += [ "-DBINDER_IPC_32BIT" ] @@ -278,6 +279,7 @@ group("unittest") { "ability_manager_service_dialog_test:unittest", "ability_manager_service_test:unittest", "ability_manager_stub_test:unittest", + "ability_manager_test:unittest", "ability_record_dump_test:unittest", "ability_record_test:unittest", "ability_running_info_test:unittest", diff --git a/test/unittest/ability_manager_test/BUILD.gn b/test/unittest/ability_manager_test/BUILD.gn new file mode 100644 index 00000000000..ee9bc7c718d --- /dev/null +++ b/test/unittest/ability_manager_test/BUILD.gn @@ -0,0 +1,65 @@ +# Copyright (c) 2022 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. + +import("//build/ohos.gni") +import("//build/test.gni") +import("//foundation/ability/ability_runtime/ability_runtime.gni") + +module_output_path = "ability_runtime/appkit" +config("coverage_flags") { + if (ability_runtime_feature_coverage) { + cflags = [ "--coverage" ] + ldflags = [ "--coverage" ] + } +} + +ohos_unittest("ability_manager_test") { + module_out_path = module_output_path + + include_dirs = [] + + sources = [ + "${ability_runtime_native_path}/appkit/app/ability_manager.cpp", + "ability_manager_test.cpp", + ] + + configs = [ + ":coverage_flags", + "${ability_runtime_services_path}/abilitymgr:abilityms_config", + "${ability_runtime_test_path}/mock/services_abilitymgr_test:aafwk_mock_config", + ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + deps = [ "//third_party/googletest:gmock_main" ] + + external_deps = [ + "ability_base:want", + "ability_runtime:ability_manager", + "ability_runtime:abilitykit_native", + "c_utils:utils", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] + + if (background_task_mgr_continuous_task_enable) { + external_deps += [ "background_task_mgr:bgtaskmgr_innerkits" ] + } +} + +group("unittest") { + testonly = true + + deps = [ ":ability_manager_test" ] +} diff --git a/test/unittest/ability_manager_test/ability_manager_stub_mock.h b/test/unittest/ability_manager_test/ability_manager_stub_mock.h index ef07d68472b..2849c278a4d 100644 --- a/test/unittest/ability_manager_test/ability_manager_stub_mock.h +++ b/test/unittest/ability_manager_test/ability_manager_stub_mock.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021-2022 Huawei Device Co., Ltd. + * Copyright (c) 2022 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 @@ -13,110 +13,196 @@ * limitations under the License. */ -#ifndef UNITTEST_OHOS_ABILITY_RUNTIME_ABILITY_MANAGER_STUB_MOCK_H -#define UNITTEST_OHOS_ABILITY_RUNTIME_ABILITY_MANAGER_STUB_MOCK_H +#ifndef UNITTEST_OHOS_ABILITY_RUNTIME_ABILITY_MANAGER_STUB_MOCK_TEST_H +#define UNITTEST_OHOS_ABILITY_RUNTIME_ABILITY_MANAGER_STUB_MOCK_TEST_H #include #include #include -#include "hilog_wrapper.h" #include "ability_manager_interface.h" namespace OHOS { namespace AAFwk { -class AbilityManagerStubMock : public IRemoteStub { +class AbilityManagerStubTestMock : public IRemoteStub { public: DECLARE_INTERFACE_DESCRIPTOR(u"IAbilityManagerMock"); - AbilityManagerStubMock() + AbilityManagerStubTestMock() : code_(0) {} - virtual ~AbilityManagerStubMock() + virtual ~AbilityManagerStubTestMock() {} - MOCK_METHOD4(SendRequest, int(uint32_t, MessageParcel &, MessageParcel &, MessageOption &)); - MOCK_METHOD2(StartAbility, int(const Want &, int)); - MOCK_METHOD3(TerminateAbility, int(const sptr &, int, const Want *)); - virtual int CloseAbility(const sptr &token, int resultCode = DEFAULT_INVAL_VALUE, - const Want *resultWant = nullptr) override + MOCK_METHOD4(SendRequest, int(uint32_t, MessageParcel&, MessageParcel&, MessageOption&)); + + int InvokeSendRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) { + code_ = code; + return 0; } - virtual int MinimizeAbility(const sptr &token, bool fromUser = false) override + + int InvokeErrorSendRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) + { + code_ = code; + return UNKNOWN_ERROR; + } + + int code_ = 0; + + virtual int StartAbility(const Want& want, int32_t userId = DEFAULT_INVAL_VALUE, int requestCode = -1) { return 0; } - MOCK_METHOD3(ConnectAbility, int(const Want &, const sptr &, const sptr &)); - MOCK_METHOD1(DisconnectAbility, int(const sptr &)); - MOCK_METHOD3(AcquireDataAbility, sptr(const Uri &, bool, const sptr &)); - MOCK_METHOD2(ReleaseDataAbility, int(sptr, const sptr &)); - MOCK_METHOD2(AttachAbilityThread, int(const sptr &, const sptr &)); - MOCK_METHOD3(AbilityTransitionDone, int(const sptr &, int, const PacMap &)); - MOCK_METHOD2(ScheduleConnectAbilityDone, int(const sptr &, const sptr &)); - MOCK_METHOD1(ScheduleDisconnectAbilityDone, int(const sptr &)); - MOCK_METHOD1(ScheduleCommandAbilityDone, int(const sptr &)); - MOCK_METHOD2(DumpState, void(const std::string &, std::vector &)); - MOCK_METHOD2(TerminateAbilityResult, int(const sptr &, int)); - MOCK_METHOD1(StopServiceAbility, int(const Want &)); - MOCK_METHOD1(KillProcess, int(const std::string &)); - MOCK_METHOD2(UninstallApp, int(const std::string &, int32_t)); - MOCK_METHOD1(GetMissionIdByToken, int32_t(const sptr &token)); - MOCK_METHOD2(TerminateAbilityByCaller, int(const sptr &callerToken, int requestCode)); - MOCK_METHOD3(StartAbility, int(const Want &want, const sptr &callerToken, int requestCode)); - MOCK_METHOD2( - GetWantSender, sptr(const WantSenderInfo &wantSenderInfo, const sptr &callerToken)); - MOCK_METHOD2(SendWantSender, int(const sptr &target, const SenderInfo &senderInfo)); - MOCK_METHOD1(CancelWantSender, void(const sptr &sender)); - MOCK_METHOD1(GetPendingWantUid, int(const sptr &target)); - MOCK_METHOD1(GetPendingWantUserId, int(const sptr &target)); - MOCK_METHOD1(GetPendingWantBundleName, std::string(const sptr &target)); - MOCK_METHOD1(GetPendingWantCode, int(const sptr &target)); - MOCK_METHOD1(GetPendingWantType, int(const sptr &target)); - MOCK_METHOD2(RegisterCancelListener, void(const sptr &sender, const sptr &receiver)); - MOCK_METHOD2(UnregisterCancelListener, void(const sptr &sender, const sptr &receiver)); - MOCK_METHOD2(GetPendingRequestWant, int(const sptr &target, std::shared_ptr &want)); + virtual int StartAbility(const Want& want, + const AbilityStartSetting& abilityStartSetting, + const sptr& callerToken, + int32_t userId = DEFAULT_INVAL_VALUE, + int requestCode = DEFAULT_INVAL_VALUE) + { + return 0; + } - MOCK_METHOD4(StartAbility, int(const Want &want, const AbilityStartSetting &abilityStartSetting, - const sptr &callerToken, int requestCode)); - MOCK_METHOD1(ChangeFocusTest, void(const std::vector missionId)); - MOCK_METHOD1(TerminateAbilityTest, void(int id)); - MOCK_METHOD2(GetWantSenderInfo, int(const sptr &target, std::shared_ptr &info)); - MOCK_METHOD2(SetMissionIcon, int(const sptr &token, - const std::shared_ptr &icon)); - MOCK_METHOD2(SetMissionLabel, int(const sptr &token, const std::string &label)); + virtual int StartAbility( + const Want& want, + const StartOptions& startOptions, + const sptr& callerToken, + int32_t userId = DEFAULT_INVAL_VALUE, + int requestCode = DEFAULT_INVAL_VALUE) + { + return 0; + } - MOCK_METHOD1(GetAbilityRunningInfos, int(std::vector &info)); - MOCK_METHOD2(GetExtensionRunningInfos, int(int upperLimit, std::vector &info)); - MOCK_METHOD1(GetProcessRunningInfos, int(std::vector &info)); + virtual int TerminateAbility(const sptr& token, int resultCode, const Want* resultWant = nullptr) + { + return 0; + } - virtual int StartUser(int userId) override + int CloseAbility(const sptr& token, int resultCode = DEFAULT_INVAL_VALUE, + const Want* resultWant = nullptr) override { return 0; } - virtual int StopUser(int userId, const sptr &callback) override + int MinimizeAbility(const sptr& token, bool fromUser) override { return 0; } - virtual int StartSyncRemoteMissions(const std::string& devId, bool fixConflict, int64_t tag) override + + virtual int ConnectAbility( + const Want& want, + const sptr& connect, + const sptr& callerToken, + int32_t userId = DEFAULT_INVAL_VALUE) { return 0; } - virtual int StopSyncRemoteMissions(const std::string& devId) override + + sptr AcquireDataAbility( + const Uri& uri, bool tryBind, const sptr& callerToken) override + { + return nullptr; + } + + virtual int ReleaseDataAbility(sptr dataAbilityScheduler, const sptr& callerToken) { return 0; } - MOCK_METHOD3(StartContinuation, int(const Want &want, const sptr &abilityToken, int32_t status)); - MOCK_METHOD2(NotifyContinuationResult, int(int32_t missionId, int32_t result)); - MOCK_METHOD5(ContinueMission, int(const std::string &srcDeviceId, const std::string &dstDeviceId, - int32_t missionId, const sptr &callBack, AAFwk::WantParams &wantParams)); - MOCK_METHOD3(ContinueAbility, int(const std::string &deviceId, int32_t missionId, uint32_t versionCode)); - MOCK_METHOD3(NotifyCompleteContinuation, void(const std::string &deviceId, int32_t sessionId, bool isSuccess)); - virtual int RegisterMissionListener(const std::string &deviceId, - const sptr &listener) override + + virtual int DisconnectAbility(const sptr& connect) + { + return 0; + } + + virtual int AttachAbilityThread(const sptr& scheduler, const sptr& token) { return 0; } - virtual int UnRegisterMissionListener(const std::string &deviceId, - const sptr &listener) override + + virtual int AbilityTransitionDone(const sptr& token, int state, const PacMap& saveData) + { + return 0; + } + + virtual int ScheduleConnectAbilityDone(const sptr& token, const sptr& remoteObject) + { + return 0; + } + + virtual int ScheduleDisconnectAbilityDone(const sptr& token) + { + return 0; + } + + virtual int ScheduleCommandAbilityDone(const sptr& token) + { + return 0; + } + + virtual void DumpState(const std::string& args, std::vector& state) + {} + + virtual void DumpSysState( + const std::string& args, std::vector& info, bool isClient, bool isUserID, int UserID) + {} + + virtual int TerminateAbilityResult(const sptr& token, int startId) + { + return 0; + } + + virtual int StopServiceAbility(const Want& want, int32_t userId = DEFAULT_INVAL_VALUE) + { + return 0; + } + + virtual int KillProcess(const std::string& bundleName) + { + return 0; + } + + virtual int UninstallApp(const std::string& bundleName, int32_t uid) + { + return 0; + } + + int32_t GetMissionIdByToken(const sptr& token) override + { + return 0; + } + + int ClearUpApplicationData(const std::string& bundleName) override + { + return 0; + } + + int StartUser(int userId) override + { + return 0; + } + + int StopUser(int userId, const sptr& callback) override + { + return 0; + } + int StartSyncRemoteMissions(const std::string& devId, bool fixConflict, int64_t tag) override + { + return 0; + } + int StopSyncRemoteMissions(const std::string& devId) override + { + return 0; + } + int RegisterMissionListener(const std::string& deviceId, + const sptr& listener) override + { + return 0; + } + int UnRegisterMissionListener(const std::string& deviceId, + const sptr& listener) override + { + return 0; + } + int ReleaseCall(const sptr& connect, + const AppExecFwk::ElementName& element) override { return 0; } @@ -130,33 +216,148 @@ public: { return; } - + virtual int RegisterSnapshotHandler(const sptr& handler) { return 0; } - virtual int RegisterWindowManagerServiceHandler(const sptr& handler) override + int RegisterWindowManagerServiceHandler(const sptr& handler) override { return 0; } - virtual void CompleteFirstFrameDrawing(const sptr &abilityToken) override {} + void CompleteFirstFrameDrawing(const sptr& abilityToken) override {} - virtual int SetAbilityController(const sptr &abilityController, + int SetAbilityController(const sptr& abilityController, bool imAStabilityTest) override { return 0; } - virtual bool IsRunningInStabilityTest() override + bool IsRunningInStabilityTest() override { return true; } - void CallRequestDone(const sptr& token, const sptr& callStub) override {} + int SendANRProcessID(int pid) override + { + return 0; + } + + int SetMissionIcon(const sptr& token, + const std::shared_ptr& icon) override + { + if (!token || !icon) { + return -1; + } + + return 0; + } + + MOCK_METHOD2(TerminateAbilityByCaller, int(const sptr& callerToken, int requestCode)); + MOCK_METHOD4(StartAbility, int(const Want& want, const sptr& callerToken, + int32_t userId, int requestCode)); + MOCK_METHOD2( + GetWantSender, sptr(const WantSenderInfo& wantSenderInfo, const sptr& callerToken)); + MOCK_METHOD2(SendWantSender, int(const sptr& target, const SenderInfo& senderInfo)); + MOCK_METHOD1(CancelWantSender, void(const sptr& sender)); + MOCK_METHOD1(GetPendingWantUid, int(const sptr& target)); + MOCK_METHOD1(GetPendingWantUserId, int(const sptr& target)); + MOCK_METHOD1(GetPendingWantBundleName, std::string(const sptr& target)); + MOCK_METHOD1(GetPendingWantCode, int(const sptr& target)); + MOCK_METHOD1(GetPendingWantType, int(const sptr& target)); + MOCK_METHOD2(RegisterCancelListener, void(const sptr& sender, const sptr& receiver)); + MOCK_METHOD2(UnregisterCancelListener, void(const sptr& sender, const sptr& receiver)); + MOCK_METHOD2(GetPendingRequestWant, int(const sptr& target, std::shared_ptr& want)); + MOCK_METHOD3(StartContinuation, int(const Want& want, const sptr& abilityToken, int32_t status)); + MOCK_METHOD2(NotifyContinuationResult, int(int32_t missionId, int32_t result)); + MOCK_METHOD5(ContinueMission, int(const std::string& srcDeviceId, const std::string& dstDeviceId, + int32_t missionId, const sptr& callBack, AAFwk::WantParams& wantParams)); + MOCK_METHOD3(ContinueAbility, int(const std::string& deviceId, int32_t missionId, uint32_t versionCode)); + MOCK_METHOD3(NotifyCompleteContinuation, void(const std::string& deviceId, int32_t sessionId, bool isSuccess)); + + MOCK_METHOD1(LockMissionForCleanup, int(int32_t missionId)); + MOCK_METHOD1(UnlockMissionForCleanup, int(int32_t missionId)); + MOCK_METHOD1(RegisterMissionListener, int(const sptr& listener)); + MOCK_METHOD1(UnRegisterMissionListener, int(const sptr& listener)); + MOCK_METHOD3( + GetMissionInfos, int(const std::string& deviceId, int32_t numMax, std::vector& missionInfos)); + MOCK_METHOD3(GetMissionInfo, int(const std::string& deviceId, int32_t missionId, MissionInfo& missionInfo)); + MOCK_METHOD1(CleanMission, int(int32_t missionId)); + MOCK_METHOD0(CleanAllMissions, int()); + MOCK_METHOD1(MoveMissionToFront, int(int32_t missionId)); + MOCK_METHOD2(MoveMissionToFront, int(int32_t missionId, const StartOptions& startOptions)); + MOCK_METHOD2(SetMissionLabel, int(const sptr& token, const std::string& label)); + MOCK_METHOD2(GetWantSenderInfo, int(const sptr& target, std::shared_ptr& info)); + MOCK_METHOD1(GetAbilityRunningInfos, int(std::vector& info)); + MOCK_METHOD2(GetExtensionRunningInfos, int(int upperLimit, std::vector& info)); + MOCK_METHOD1(GetProcessRunningInfos, int(std::vector& info)); +#ifdef ABILITY_COMMAND_FOR_TEST + MOCK_METHOD0(BlockAppService, int()); + MOCK_METHOD0(BlockAmsService, int()); + MOCK_METHOD1(BlockAbility, int(int32_t abilityRecordId)); +#endif + + int SendResultToAbility(int requestCode, int resultCode, Want& resultWant) override + { + return 0; + } + + int StartAbilityByCall( + const Want& want, const sptr& connect, const sptr& callerToken) override + { + return 0; + } + + void CallRequestDone(const sptr &token, const sptr &callStub) override + { + return; + } + + int StartUserTest(const Want &want, const sptr &observer) override + { + return 0; + } + + int FinishUserTest( + const std::string& msg, const int64_t& resultCode, const std::string& bundleName) override + { + return 0; + } + + int GetTopAbility(sptr& token) override + { + return 0; + } + + int DelegatorDoAbilityForeground(const sptr& token) override + { + return 0; + } + + int DelegatorDoAbilityBackground(const sptr& token) override + { + return 0; + } + + int DoAbilityForeground(const sptr& token, uint32_t flag) override + { + return 0; + } + + int DoAbilityBackground(const sptr& token, uint32_t flag) override + { + return 0; + } + +#ifdef ABILITY_COMMAND_FOR_TEST + int ForceTimeoutForTest(const std::string& abilityName, const std::string& state) override + { + return 0; + } +#endif }; } // namespace AAFwk } // namespace OHOS - -#endif +#endif \ No newline at end of file diff --git a/test/unittest/ability_manager_test/ability_manager_test.cpp b/test/unittest/ability_manager_test/ability_manager_test.cpp new file mode 100644 index 00000000000..96fb638cae3 --- /dev/null +++ b/test/unittest/ability_manager_test/ability_manager_test.cpp @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2022 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 +#define private public +#define protected public +#include "ability_manager.h" +#include "ability_manager_stub_mock.h" +#undef private +#undef protected +#include "hilog_wrapper.h" +using namespace testing::ext; +using namespace testing; +namespace OHOS { +namespace AAFwk { +namespace +{ + constexpr int32_t ONE = 1; + constexpr int32_t NEGATIVE = -1; +} +using namespace OHOS::AppExecFwk; +class AbilityManagerTest : public testing::Test { +public: + static void SetUpTestCase(void) {}; + static void TearDownTestCase(void) {}; + void SetUp() {}; + void TearDown() {}; +}; + +/* + * @tc.number : AbilityManagerTest_0100 + * @tc.name : AbilityManager + * @tc.desc : Test Function AbilityManager::GetInstance() and AbilityManager::StartAbility + */ +HWTEST_F(AbilityManagerTest, AbilityManagerTest_0100, TestSize.Level1) +{ + HILOG_INFO("AbilityManagerTest_0100 is start"); + int32_t requestCode = NEGATIVE; + Want want; + ElementName element("device", "com.ix.hiMusic", "MusicSAbility"); + want.SetElement(element); + sptr mock = new AAFwk::AbilityManagerStubTestMock(); + AAFwk::AbilityManagerClient::GetInstance()->proxy_ = mock; + ErrCode error = AAFwk::AbilityManagerClient::GetInstance()->StartAbility(want, requestCode); + EXPECT_EQ(error, ERR_OK); + AbilityManager::GetInstance().StartAbility(want, requestCode); + AAFwk::AbilityManagerClient::GetInstance()->proxy_ = nullptr; + HILOG_INFO("AbilityManagerTest_0100 is end"); +} + +/* + * @tc.number : AbilityManagerTest_0200 + * @tc.name : AbilityManager + * @tc.desc : Test Function AbilityManager::GetInstance() and AbilityManager::StartAbility + */ +HWTEST_F(AbilityManagerTest, AbilityManagerTest_0200, TestSize.Level1) +{ + HILOG_INFO("AbilityManagerTest_0200 is start"); + int32_t requestCode = NEGATIVE; + Want want; + ElementName element("device", "com.ix.hiMusic", "MusicSAbility"); + want.SetElement(element); + ErrCode error = AAFwk::AbilityManagerClient::GetInstance()->StartAbility(want, requestCode); + EXPECT_NE(error, ERR_OK); + AbilityManager::GetInstance().StartAbility(want, requestCode); + HILOG_INFO("AbilityManagerTest_0200 is end"); +} + +/* + * @tc.number : AbilityManagerTest_0300 + * @tc.name : AbilityManager + * @tc.desc : Test Function AbilityManager::ClearUpApplicationData + */ +HWTEST_F(AbilityManagerTest, AbilityManagerTest_0300, TestSize.Level1) +{ + HILOG_INFO("AbilityManagerTest_0300 is start"); + const std::string bundleName = "test"; + auto res = AbilityManager::GetInstance().ClearUpApplicationData(bundleName); + EXPECT_EQ(res, ONE); + HILOG_INFO("AbilityManagerTest_0300 is end"); +} + +/* + * @tc.number : AbilityManagerTest_0400 + * @tc.name : AbilityManager + * @tc.desc : Test Function AbilityManager::GetAllRunningProcesses + */ +HWTEST_F(AbilityManagerTest, AbilityManagerTest_0400, TestSize.Level1) +{ + HILOG_INFO("AbilityManagerTest_0400 is start"); + auto res = AbilityManager::GetInstance().GetAllRunningProcesses(); + EXPECT_TRUE(res.empty()); + HILOG_INFO("AbilityManagerTest_0400 is end"); +} + +/* + * @tc.number : AbilityManagerTest_0500 + * @tc.name : AbilityManager + * @tc.desc : Test Function AbilityManager::KillProcessesByBundleName + */ +HWTEST_F(AbilityManagerTest, AbilityManagerTest_0500, TestSize.Level1) +{ + HILOG_INFO("AbilityManagerTest_0500 is start"); + const std::string bundleName = "test"; + auto res = AbilityManager::GetInstance().KillProcessesByBundleName(bundleName); + EXPECT_NE(res, ERR_OK); + HILOG_INFO("AbilityManagerTest_0500 is end"); +} + +/* + * @tc.number : AbilityManagerTest_0600 + * @tc.name : AbilityManager + * @tc.desc : Test Function AbilityManager::KillProcessesByBundleName + */ +HWTEST_F(AbilityManagerTest, AbilityManagerTest_0600, TestSize.Level1) +{ + HILOG_INFO("AbilityManagerTest_0600 is start"); + const std::string bundleName = "test"; + sptr mock = new AAFwk::AbilityManagerStubTestMock(); + AAFwk::AbilityManagerClient::GetInstance()->proxy_ = mock; + auto res = AbilityManager::GetInstance().KillProcessesByBundleName(bundleName); + EXPECT_EQ(res, ERR_OK); + AAFwk::AbilityManagerClient::GetInstance()->proxy_ = nullptr; + HILOG_INFO("AbilityManagerTest_0600 is end"); +} +} // namespace AAFwk +} // namespace OHOS \ No newline at end of file diff --git a/test/unittest/continuation_test/BUILD.gn b/test/unittest/continuation_test/BUILD.gn index 23e644265f1..f1eb586e6c9 100644 --- a/test/unittest/continuation_test/BUILD.gn +++ b/test/unittest/continuation_test/BUILD.gn @@ -20,6 +20,8 @@ group("unittest") { "remote_register_service_test/connect_callback_proxy_test:unittest", "remote_register_service_test/connect_callback_stub_test:unittest", "remote_register_service_test/continuation_connector_test:unittest", + "remote_register_service_test/continuation_device_callback_proxy_test:unittest", + "remote_register_service_test/continuation_register_manager_proxy_test:unittest", "remote_register_service_test/continuation_register_manager_test:unittest", "remote_register_service_test/remote_register_service_proxy_test:unittest", "remote_register_service_test/remote_register_service_stub_test:unittest", diff --git a/test/unittest/continuation_test/remote_register_service_test/continuation_device_callback_proxy_test/BUILD.gn b/test/unittest/continuation_test/remote_register_service_test/continuation_device_callback_proxy_test/BUILD.gn new file mode 100644 index 00000000000..6d870cc712b --- /dev/null +++ b/test/unittest/continuation_test/remote_register_service_test/continuation_device_callback_proxy_test/BUILD.gn @@ -0,0 +1,70 @@ +# Copyright (c) 2022 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. + +import("//build/test.gni") +import("//foundation/ability/ability_runtime/ability_runtime.gni") + +module_output_path = "ability_runtime/abilitymgr" + +remote_register_path = "${ability_runtime_path}/frameworks/native/ability/native/continuation/remote_register_service" + +config("coverage_flags") { + if (ability_runtime_feature_coverage) { + cflags = [ "--coverage" ] + ldflags = [ "--coverage" ] + } +} + +ohos_unittest("continuation_device_callback_proxy_test") { + module_out_path = module_output_path + + include_dirs = [ + "${ability_runtime_path}/interfaces/kits/native/ability/native/continuation/remote_register_service", + "${ability_runtime_path}/test/unittest/continuation_test/common_mock", + "${ability_runtime_innerkits_path}/ability_manager/include/continuation", + "${ability_runtime_services_path}/common/include", + ] + + sources = [ + "${remote_register_path}/continuation_device_callback_proxy.cpp", + "continuation_device_callback_proxy_test.cpp", + ] + + configs = [ ":coverage_flags" ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + deps = [ + "//foundation/ability/ability_runtime/frameworks/native/ability/native:continuation_ipc", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + + external_deps = [ + "ability_base:want", + "ability_runtime:ability_manager", + "c_utils:utils", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] + + if (background_task_mgr_continuous_task_enable) { + external_deps += [ "background_task_mgr:bgtaskmgr_innerkits" ] + } +} + +group("unittest") { + testonly = true + deps = [ ":continuation_device_callback_proxy_test" ] +} diff --git a/test/unittest/continuation_test/remote_register_service_test/continuation_device_callback_proxy_test/continuation_device_callback_proxy_test.cpp b/test/unittest/continuation_test/remote_register_service_test/continuation_device_callback_proxy_test/continuation_device_callback_proxy_test.cpp new file mode 100644 index 00000000000..612dbd1a15e --- /dev/null +++ b/test/unittest/continuation_test/remote_register_service_test/continuation_device_callback_proxy_test/continuation_device_callback_proxy_test.cpp @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2022 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 +#include + +#define private public +#define protected public +#include "continuation_device_callback_proxy.h" +#undef private +#undef protected + +using namespace testing::ext; +using namespace testing; +using namespace std::chrono; + +namespace OHOS{ +namespace AppExecFwk{ +class ContinuationDeviceCallbackProxyTest : public testing::Test{ +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void ContinuationDeviceCallbackProxyTest::SetUpTestCase(void) +{ +} + +void ContinuationDeviceCallbackProxyTest::TearDownTestCase(void) +{ +} + +void ContinuationDeviceCallbackProxyTest::SetUp(void) +{ +} + +void ContinuationDeviceCallbackProxyTest::TearDown(void) +{ +} + +class MoclCallback : public IContinuationDeviceCallback +{ +public: + MoclCallback() {}; + virtual ~MoclCallback() {}; + virtual void OnDeviceConnectDone(const std::string &deviceId, const std::string &deviceType) {}; + virtual void OnDeviceDisconnectDone(const std::string &deviceId) {}; +}; + +/* +* @tc.number: AppExecFwk_ContinuationDeviceCallbackProxy_Connect_001 +* @tc.name: Connect +* @tc.desc: Verify function Connect pointer callback normal +*/ +HWTEST_F(ContinuationDeviceCallbackProxyTest, AppExecFwk_ContinuationDeviceCallbackProxy_Connect_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_ContinuationDeviceCallbackProxy_Connect_001 start."; + std::shared_ptr callback = std::make_shared(); + std::shared_ptr connectCallback = callback; + sptr continuationDeviceCallbackProxy = new (std::nothrow) + ContinuationDeviceCallbackProxy(connectCallback); + EXPECT_TRUE(continuationDeviceCallbackProxy != nullptr); + const std::string deviceId = "7001005458323933328a592135733900"; + const std::string deviceType = "rk3568"; + continuationDeviceCallbackProxy->Connect(deviceId, deviceType); + GTEST_LOG_(INFO) << "AppExecFwk_ContinuationDeviceCallbackProxy_Connect_001 end."; +} + +/* +* @tc.number: AppExecFwk_ContinuationDeviceCallbackProxy_Connect_002 +* @tc.name: Connect +* @tc.desc: Verify function Connect pointer callback empty +*/ +HWTEST_F(ContinuationDeviceCallbackProxyTest, AppExecFwk_ContinuationDeviceCallbackProxy_Connect_002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_ContinuationDeviceCallbackProxy_Connect_002 start."; + std::shared_ptr callback = nullptr; + std::shared_ptr connectCallback = callback; + sptr continuationDeviceCallbackProxy = new (std::nothrow) + ContinuationDeviceCallbackProxy(connectCallback); + EXPECT_FALSE(continuationDeviceCallbackProxy == nullptr); + const std::string deviceId = "7001005458323933328a592135733900"; + const std::string deviceType = "rk3568"; + continuationDeviceCallbackProxy->Connect(deviceId, deviceType); + GTEST_LOG_(INFO) << "AppExecFwk_ContinuationDeviceCallbackProxy_Connect_002 end."; +} + +/* +* @tc.number: AppExecFwk_ContinuationDeviceCallbackProxy_Disconnect_001 +* @tc.name: Disconnect +* @tc.desc: Verify function Disconnect pointer callback normal +*/ +HWTEST_F(ContinuationDeviceCallbackProxyTest, AppExecFwk_ContinuationDeviceCallbackProxy_Disconnect_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_ContinuationDeviceCallbackProxy_Disconnect_001 start."; + std::shared_ptr callback = std::make_shared(); + std::shared_ptr connectCallback = callback; + sptr continuationDeviceCallbackProxy = new (std::nothrow) + ContinuationDeviceCallbackProxy(connectCallback); + EXPECT_TRUE(continuationDeviceCallbackProxy != nullptr); + const std::string deviceId = "7001005458323933328a592135733900"; + continuationDeviceCallbackProxy->Disconnect(deviceId); + GTEST_LOG_(INFO) << "AppExecFwk_ContinuationDeviceCallbackProxy_Disconnect_001 end."; +} + +/* +* @tc.number: AppExecFwk_ContinuationDeviceCallbackProxy_Disconnect_002 +* @tc.name: Disconnect +* @tc.desc: Verify function Disconnect pointer callback empty +*/ +HWTEST_F(ContinuationDeviceCallbackProxyTest, AppExecFwk_ContinuationDeviceCallbackProxy_Disconnect_002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_ContinuationDeviceCallbackProxy_Disconnect_002 start."; + std::shared_ptr callback = nullptr; + std::shared_ptr connectCallback = callback; + sptr continuationDeviceCallbackProxy = new (std::nothrow) + ContinuationDeviceCallbackProxy(connectCallback); + EXPECT_FALSE(continuationDeviceCallbackProxy == nullptr); + const std::string deviceId = "7001005458323933328a592135733900"; + continuationDeviceCallbackProxy->Disconnect(deviceId); + GTEST_LOG_(INFO) << "AppExecFwk_ContinuationDeviceCallbackProxy_Disconnect_002 end."; +} +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/test/unittest/continuation_test/remote_register_service_test/continuation_register_manager_proxy_test/BUILD.gn b/test/unittest/continuation_test/remote_register_service_test/continuation_register_manager_proxy_test/BUILD.gn new file mode 100644 index 00000000000..4a2bb4a6378 --- /dev/null +++ b/test/unittest/continuation_test/remote_register_service_test/continuation_register_manager_proxy_test/BUILD.gn @@ -0,0 +1,108 @@ +# Copyright (c) 2022 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. + +import("//build/test.gni") +import("//foundation/ability/ability_runtime/ability_runtime.gni") + +module_output_path = "ability_runtime/abilitymgr" + +remote_register_path = "${ability_runtime_path}/frameworks/native/ability/native/continuation/remote_register_service" + +config("coverage_flags") { + if (ability_runtime_feature_coverage) { + cflags = [ "--coverage" ] + ldflags = [ "--coverage" ] + } +} + +config("ability_config") { + visibility = [ ":*" ] + include_dirs = [ + "${ability_runtime_path}/interfaces/kits/native/ability/native", + "${ability_runtime_path}/interfaces/kits/native/ability/native/continuation/distributed", + "${ability_runtime_path}/interfaces/kits/native/ability/native/continuation/kits", + "${ability_runtime_path}/interfaces/kits/native/ability/native/continuation/remote_register_service", + "${ability_runtime_path}/interfaces/kits/native/ability/native/distributed_ability_runtime", + "${ability_runtime_path}/interfaces/kits/native/appkit/app", + "${ability_runtime_innerkits_path}/app_manager/include/appmgr", + "${ability_runtime_innerkits_path}/uri/include", + "${ability_runtime_services_path}/abilitymgr/include", + "${ability_runtime_path}/interfaces/kits/native/appkit/ability_runtime/app", + "${ability_runtime_path}/interfaces/kits/native/appkit/app", + "${form_fwk_path}/interfaces/kits/native/include", + "${ability_runtime_path}/interfaces/kits/native/appkit/app", + "//third_party/node/src", + "${ability_runtime_innerkits_path}/ability_manager/include/continuation", + "${ability_runtime_path}/interfaces/kits/native/appkit/app/task", + "${ability_runtime_napi_path}/inner/napi_common", + "${ability_runtime_napi_path}/featureAbility", + "//foundation/ability/ability_runtime/interfaces/kits/native/ability/native/continuation/kits", + ] + + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + defines = [ "AMS_LOG_TAG = \"Ability\"" ] + if (target_cpu == "arm64") { + defines += [ "_ARM64_" ] + } + + if (ability_runtime_graphics) { + include_dirs += [ "${form_fwk_path}/interfaces/inner_api/include" ] + defines += [ "SUPPORT_GRAPHICS" ] + } +} + +ohos_unittest("continuation_register_manager_proxy_test") { + module_out_path = module_output_path + + sources = [ + "${remote_register_path}/continuation_register_manager_proxy.cpp", + "continuation_register_manager_proxy_test.cpp", + ] + + configs = [ + ":ability_config", + ":coverage_flags", + ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + deps = [ + "${ability_runtime_innerkits_path}/ability_manager:ability_manager", + "${ability_runtime_native_path}/ability/native:abilitykit_native", + "//foundation/ability/ability_runtime/frameworks/native/ability/native:continuation_ipc", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + + external_deps = [ + "ability_base:want", + "ability_runtime:ability_manager", + "c_utils:utils", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "resource_management:global_resmgr", + ] + + if (background_task_mgr_continuous_task_enable) { + external_deps += [ "background_task_mgr:bgtaskmgr_innerkits" ] + } +} + +group("unittest") { + testonly = true + deps = [ ":continuation_register_manager_proxy_test" ] +} diff --git a/test/unittest/continuation_test/remote_register_service_test/continuation_register_manager_proxy_test/continuation_register_manager_proxy_test.cpp b/test/unittest/continuation_test/remote_register_service_test/continuation_register_manager_proxy_test/continuation_register_manager_proxy_test.cpp new file mode 100644 index 00000000000..89476a76b9a --- /dev/null +++ b/test/unittest/continuation_test/remote_register_service_test/continuation_register_manager_proxy_test/continuation_register_manager_proxy_test.cpp @@ -0,0 +1,675 @@ +/* + * Copyright (c) 2022 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 +#include + +#define private public +#define protected public +#include "continuation_register_manager_proxy.h" +#include "continuation_register_manager.h" +#include "connect_callback_stub.h" +#include "continuation_connector.h" +#undef private +#undef protected +#include "bundle_mgr_interface.h" +#include "ability_manager_interface.h" +#include "iability_controller.h" +#include "pixel_map.h" +#include "ability_info.h" +#include "ability.h" +#include "request_callback.h" + +using namespace testing::ext; +using namespace testing; +using namespace std::chrono; + +namespace OHOS { +namespace AppExecFwk { +class ContinuationRegisterManagerProxyTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void ContinuationRegisterManagerProxyTest::SetUpTestCase(void) +{} + +void ContinuationRegisterManagerProxyTest::TearDownTestCase(void) +{} + +void ContinuationRegisterManagerProxyTest::SetUp(void) +{} + +void ContinuationRegisterManagerProxyTest::TearDown(void) +{} + +class MoclConnectCallback : public RequestCallback { +public: + MoclConnectCallback() {}; + virtual ~MoclConnectCallback() {}; + + virtual void OnResult(int result) override + { + onresult_ = true; + }; + + bool onresult_ = false; +}; + +class MoclRequest : public ContinuationRequest { +public: + MoclRequest() {}; + virtual ~MoclRequest() {}; + + virtual void Execute() override + { + execute_ = true; + }; + + bool execute_ = false; +}; + +class MockRequestCallback : public RequestCallback { +public: + MockRequestCallback() {}; + virtual ~MockRequestCallback() {}; + + virtual void OnResult(int result) + { + onResult_ = true; + }; + + bool onResult_ = false; +}; + +/* + * @tc.number : ContinuationRegisterManagerProxy_Execute_001 + * @tc.name : Register_Execute + * @tc.desc : Verify that the Execute interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_Execute_001, TestSize.Level1) +{ + const std::string bundleName = ""; + ExtraParams parameter; + std::shared_ptr deviceCallback = nullptr; + auto pContinuationRequestRegister = + std::make_shared(bundleName, parameter, deviceCallback); + std::shared_ptr requestCallback = std::make_shared(); + pContinuationRequestRegister->SetContinuationConnector(nullptr); + pContinuationRequestRegister->SetRequestCallback(requestCallback); + EXPECT_TRUE(!requestCallback->onresult_); + pContinuationRequestRegister->Execute(); + EXPECT_TRUE(!requestCallback->onresult_); +} + +/* + * @tc.number : ContinuationRegisterManagerProxy_Execute_002 + * @tc.name : Register_Execute + * @tc.desc : Verify that the Execute interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_Execute_002, TestSize.Level1) +{ + const std::string bundleName = ""; + ExtraParams parameter; + std::shared_ptr context; + sptr continuatinConnector = new (std::nothrow) ContinuationConnector(context); + std::shared_ptr deviceCallback = nullptr; + auto pContinuationRequestRegister = + std::make_shared(bundleName, parameter, deviceCallback); + pContinuationRequestRegister->SetContinuationConnector(continuatinConnector); + std::shared_ptr requestCallback = std::make_shared(); + pContinuationRequestRegister->SetRequestCallback(nullptr); + EXPECT_TRUE(!requestCallback->onresult_); + pContinuationRequestRegister->Execute(); + EXPECT_TRUE(!requestCallback->onresult_); +} + +/* + * @tc.number : ContinuationRegisterManagerProxy_Execute_003 + * @tc.name : Register_Execute + * @tc.desc : Verify that the Execute interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_Execute_003, TestSize.Level1) +{ + const std::string bundleName = ""; + ExtraParams parameter; + std::shared_ptr context; + sptr continuatinConnector = new (std::nothrow) ContinuationConnector(context); + std::shared_ptr requestCallback = std::make_shared(); + std::shared_ptr deviceCallback = nullptr; + auto pContinuationRequestRegister = + std::make_shared(bundleName, parameter, deviceCallback); + pContinuationRequestRegister->SetContinuationConnector(continuatinConnector); + pContinuationRequestRegister->SetRequestCallback(requestCallback); + EXPECT_TRUE(!requestCallback->onresult_); + pContinuationRequestRegister->Execute(); + EXPECT_TRUE(requestCallback->onresult_); +} + +/* + * @tc.number : ContinuationRequestUnRegister_Execute_001 + * @tc.name : UnRegister_Execute + * @tc.desc : Verify that the Execute interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestUnRegister_Execute_001, TestSize.Level1) +{ + constexpr int32_t token_ = 0; + auto pContinuationRequestUnRegister = std::make_shared(token_); + std::shared_ptr requestCallback = std::make_shared(); + pContinuationRequestUnRegister->SetContinuationConnector(nullptr); + pContinuationRequestUnRegister->SetRequestCallback(requestCallback); + EXPECT_TRUE(!requestCallback->onresult_); + pContinuationRequestUnRegister->Execute(); + EXPECT_TRUE(!requestCallback->onresult_); +} + +/* + * @tc.number : ContinuationRequestUnRegister_Execute_002 + * @tc.name : UnRegister_Execute + * @tc.desc : Verify that the Execute interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestUnRegister_Execute_002, TestSize.Level1) +{ + constexpr int32_t token_ = 0; + std::shared_ptr context; + sptr continuatinConnector = new (std::nothrow) ContinuationConnector(context); + auto pContinuationRequestUnRegister = std::make_shared(token_); + pContinuationRequestUnRegister->SetContinuationConnector(continuatinConnector); + std::shared_ptr requestCallback = std::make_shared(); + pContinuationRequestUnRegister->SetRequestCallback(nullptr); + EXPECT_TRUE(!requestCallback->onresult_); + pContinuationRequestUnRegister->Execute(); + EXPECT_TRUE(!requestCallback->onresult_); +} + +/* + * @tc.number : ContinuationRequestUnRegister_Execute_003 + * @tc.name : UnRegister_Execute + * @tc.desc : Verify that the Execute interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestUnRegister_Execute_003, TestSize.Level1) +{ + constexpr int32_t token_ = 0; + std::shared_ptr context; + sptr continuatinConnector = new (std::nothrow) ContinuationConnector(context); + auto pContinuationRequestUnRegister = std::make_shared(token_); + std::shared_ptr requestCallback = std::make_shared(); + pContinuationRequestUnRegister->SetContinuationConnector(continuatinConnector); + pContinuationRequestUnRegister->SetRequestCallback(requestCallback); + EXPECT_TRUE(!requestCallback->onresult_); + pContinuationRequestUnRegister->Execute(); + EXPECT_TRUE(requestCallback->onresult_); +} + +/* + * @tc.number : ContinuationRequestUpdateConnectStatus_Execute_001 + * @tc.name : UpdateConnectStatus_Execute + * @tc.desc : Verify that the Execute interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestUpdateConnectStatus_Execute_001, TestSize.Level1) +{ + constexpr int32_t token_ = 0; + const std::string deviceId_ = ""; + constexpr int32_t status_ = 0; + auto pContinuationRequestUpdateConnectStatus = + std::make_shared(token_, deviceId_, status_); + pContinuationRequestUpdateConnectStatus->SetContinuationConnector(nullptr); + std::shared_ptr requestCallback = std::make_shared(); + pContinuationRequestUpdateConnectStatus->SetRequestCallback(requestCallback); + EXPECT_TRUE(!requestCallback->onresult_); + pContinuationRequestUpdateConnectStatus->Execute(); + EXPECT_TRUE(!requestCallback->onresult_); +} + +/* + * @tc.number : ContinuationRequestUpdateConnectStatus_Execute_002 + * @tc.name : UpdateConnectStatus_Execute + * @tc.desc : Verify that the Execute interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestUpdateConnectStatus_Execute_002, TestSize.Level1) +{ + constexpr int32_t token_ = 0; + const std::string deviceId_ = ""; + constexpr int32_t status_ = 0; + std::shared_ptr context; + sptr continuatinConnector = new (std::nothrow) ContinuationConnector(context); + auto pContinuationRequestUpdateConnectStatus = + std::make_shared(token_, deviceId_, status_); + pContinuationRequestUpdateConnectStatus->SetContinuationConnector(continuatinConnector); + std::shared_ptr requestCallback = std::make_shared(); + pContinuationRequestUpdateConnectStatus->SetRequestCallback(nullptr); + EXPECT_TRUE(!requestCallback->onresult_); + pContinuationRequestUpdateConnectStatus->Execute(); + EXPECT_TRUE(!requestCallback->onresult_); +} + +/* + * @tc.number : ContinuationRequestUpdateConnectStatus_Execute_003 + * @tc.name : UpdateConnectStatus_Execute + * @tc.desc : Verify that the Execute interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestUpdateConnectStatus_Execute_003, TestSize.Level1) +{ + constexpr int32_t token_ = 0; + const std::string deviceId_ = ""; + constexpr int32_t status_ = 0; + std::shared_ptr context; + sptr continuatinConnector = new (std::nothrow) ContinuationConnector(context); + auto pContinuationRequestUpdateConnectStatus = + std::make_shared(token_, deviceId_, status_); + std::shared_ptr requestCallback = std::make_shared(); + pContinuationRequestUpdateConnectStatus->SetContinuationConnector(continuatinConnector); + pContinuationRequestUpdateConnectStatus->SetRequestCallback(requestCallback); + EXPECT_TRUE(!requestCallback->onresult_); + pContinuationRequestUpdateConnectStatus->Execute(); + EXPECT_TRUE(requestCallback->onresult_); +} + +/* + * @tc.number : ContinuationRequestShowDeviceList_Execute_001 + * @tc.name : ShowDeviceList_Execute + * @tc.desc : Verify that the Execute interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestShowDeviceList_Execute_001, TestSize.Level1) +{ + constexpr int32_t token_ = 0; + ExtraParams parameter_; + auto pContinuationRequestShowDeviceList = std::make_shared(token_, parameter_); + std::shared_ptr requestCallback = std::make_shared(); + pContinuationRequestShowDeviceList->SetContinuationConnector(nullptr); + pContinuationRequestShowDeviceList->SetRequestCallback(requestCallback); + EXPECT_TRUE(!requestCallback->onresult_); + pContinuationRequestShowDeviceList->Execute(); + EXPECT_TRUE(!requestCallback->onresult_); +} + +/* + * @tc.number : ContinuationRequestShowDeviceList_Execute_002 + * @tc.name : ShowDeviceList_Execute + * @tc.desc : Verify that the Execute interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestShowDeviceList_Execute_002, TestSize.Level1) +{ + constexpr int32_t token_ = 0; + ExtraParams parameter_; + std::shared_ptr context; + sptr continuatinConnector = new (std::nothrow) ContinuationConnector(context); + std::shared_ptr requestCallback = std::make_shared(); + auto pContinuationRequestShowDeviceList = + std::make_shared(token_, parameter_); + pContinuationRequestShowDeviceList->SetContinuationConnector(continuatinConnector); + pContinuationRequestShowDeviceList->SetRequestCallback(nullptr); + EXPECT_TRUE(!requestCallback->onresult_); + pContinuationRequestShowDeviceList->Execute(); + EXPECT_TRUE(!requestCallback->onresult_); +} + +/* + * @tc.number : ContinuationRequestShowDeviceList_Execute_003 + * @tc.name : ShowDeviceList_Execute + * @tc.desc : Verify that the Execute interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestShowDeviceList_Execute_003, TestSize.Level1) +{ + constexpr int32_t token_ = 0; + ExtraParams parameter_; + std::shared_ptr context; + sptr continuatinConnector = new (std::nothrow) ContinuationConnector(context); + auto pContinuationRequestShowDeviceList = + std::make_shared(token_, parameter_); + std::shared_ptr requestCallback = std::make_shared(); + pContinuationRequestShowDeviceList->SetContinuationConnector(continuatinConnector); + pContinuationRequestShowDeviceList->SetRequestCallback(requestCallback); + EXPECT_TRUE(!requestCallback->onresult_); + pContinuationRequestShowDeviceList->Execute(); + EXPECT_TRUE(requestCallback->onresult_); +} + +/* + * @tc.number : ContinuationRegisterManagerProxy_Constructor_001 + * @tc.name : Constructor + * @tc.desc : Verify that the Constructor is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_Constructor_001, TestSize.Level1) +{ + std::weak_ptr context ; + auto continuatinConnector = std::make_shared(context); + std::shared_ptr applicationContext = continuatinConnector->applicationContext_.lock(); + EXPECT_TRUE(applicationContext == nullptr); +} + +/* + * @tc.number : ContinuationRegisterManagerProxy_Register_001 + * @tc.name : Register + * @tc.desc : Verify that the Register interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_Register_001, TestSize.Level1) +{ + const std::string bundleName = ""; + ExtraParams parameter; + std::shared_ptr deviceCallback; + std::shared_ptr requestCallback = std::make_shared(); + std::shared_ptr context; + auto continuationRegisterManagerProxy = std::make_shared(context); + continuationRegisterManagerProxy->context_.lock() = nullptr; + continuationRegisterManagerProxy->continuatinConnector_ = new (std::nothrow) ContinuationConnector(context); + continuationRegisterManagerProxy->continuatinConnector_->isConnected_.store(true); + + EXPECT_FALSE(requestCallback->onResult_); + continuationRegisterManagerProxy->Register(bundleName, parameter, deviceCallback, requestCallback); + EXPECT_FALSE(requestCallback->onResult_); +} + +/* + * @tc.number : ContinuationRegisterManagerProxy_Register_002 + * @tc.name : Register + * @tc.desc : Verify that the Register interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_Register_002, TestSize.Level1) +{ + const std::string bundleName = ""; + ExtraParams parameter; + std::shared_ptr deviceCallback; + std::shared_ptr requestCallback = std::make_shared(); + std::shared_ptr context = std::make_shared(); + auto continuationRegisterManagerProxy = std::make_shared(context); + continuationRegisterManagerProxy->context_ = context; + continuationRegisterManagerProxy->applicationContext_.lock() = nullptr; + continuationRegisterManagerProxy->continuatinConnector_ = new (std::nothrow) ContinuationConnector(context); + continuationRegisterManagerProxy->continuatinConnector_->isConnected_.store(true); + + EXPECT_FALSE(requestCallback->onResult_); + continuationRegisterManagerProxy->Register(bundleName, parameter, deviceCallback, requestCallback); + EXPECT_FALSE(requestCallback->onResult_); +} + +/* + * @tc.number : ContinuationRegisterManagerProxy_Register_003 + * @tc.name : Register + * @tc.desc : Verify that the Register interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_Register_003, TestSize.Level1) +{ + const std::string bundleName = ""; + ExtraParams parameter; + std::shared_ptr deviceCallback; + std::shared_ptr requestCallback = std::make_shared(); + std::shared_ptr context = std::make_shared(); + auto continuationRegisterManagerProxy = std::make_shared(context); + continuationRegisterManagerProxy->context_ = context; + continuationRegisterManagerProxy->applicationContext_ = context; + continuationRegisterManagerProxy->continuatinConnector_ = new (std::nothrow) ContinuationConnector(context); + continuationRegisterManagerProxy->continuatinConnector_->isConnected_.store(true); + + EXPECT_FALSE(requestCallback->onResult_); + continuationRegisterManagerProxy->Register(bundleName, parameter, deviceCallback, requestCallback); + EXPECT_TRUE(requestCallback->onResult_); +} + +/* + * @tc.number : ContinuationRegisterManagerProxy_Unregister_001 + * @tc.name : Unregister + * @tc.desc : Verify that the Unregister interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_Unregister_001, TestSize.Level1) +{ + constexpr int32_t token = 0; + std::shared_ptr requestCallback = std::make_shared(); + std::shared_ptr context = std::make_shared(); + auto continuationRegisterManagerProxy = std::make_shared(context); + std::weak_ptr applicationContext; + continuationRegisterManagerProxy->applicationContext_ = applicationContext; + continuationRegisterManagerProxy->continuatinConnector_ = new (std::nothrow) ContinuationConnector(context); + continuationRegisterManagerProxy->continuatinConnector_->isConnected_.store(true); + + EXPECT_FALSE(requestCallback->onResult_); + continuationRegisterManagerProxy->Unregister(token, requestCallback); + EXPECT_FALSE(requestCallback->onResult_); +} + +/* + * @tc.number : ContinuationRegisterManagerProxy_Unregister_002 + * @tc.name : Unregister + * @tc.desc : Verify that the Unregister interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_Unregister_002, TestSize.Level1) +{ + constexpr int32_t token = 0; + std::shared_ptr requestCallback = std::make_shared(); + std::shared_ptr context = std::make_shared(); + auto continuationRegisterManagerProxy = std::make_shared(context); + continuationRegisterManagerProxy->applicationContext_ = context; + continuationRegisterManagerProxy->continuatinConnector_ = new (std::nothrow) ContinuationConnector(context); + continuationRegisterManagerProxy->continuatinConnector_->isConnected_.store(true); + + EXPECT_FALSE(requestCallback->onResult_); + continuationRegisterManagerProxy->Unregister(token, requestCallback); + EXPECT_TRUE(requestCallback->onResult_); +} + +/* + * @tc.number : ContinuationRegisterManagerProxy_UpdateConnect_001 + * @tc.name : UpdateConnectStatus + * @tc.desc : Verify that the UpdateConnectStatus interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_UpdateConnect_001, TestSize.Level1) +{ + constexpr int32_t token = 0; + const std::string deviceId = ""; + constexpr int32_t status = 0; + std::shared_ptr requestCallback = std::make_shared(); + std::shared_ptr context = std::make_shared(); + auto continuationRegisterManagerProxy = std::make_shared(context); + std::weak_ptr applicationContext; + continuationRegisterManagerProxy->applicationContext_ = applicationContext; + continuationRegisterManagerProxy->continuatinConnector_ = new (std::nothrow) ContinuationConnector(context); + continuationRegisterManagerProxy->continuatinConnector_->isConnected_.store(true); + + EXPECT_FALSE(requestCallback->onResult_); + continuationRegisterManagerProxy->UpdateConnectStatus(token, deviceId, status, requestCallback); + EXPECT_FALSE(requestCallback->onResult_); +} + +/* + * @tc.number : ContinuationRegisterManagerProxy_UpdateConnect_002 + * @tc.name : UpdateConnectStatus + * @tc.desc : Verify that the UpdateConnectStatus interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_UpdateConnect_002, TestSize.Level1) +{ + constexpr int32_t token = 0; + const std::string deviceId = ""; + constexpr int32_t status = 0; + std::shared_ptr requestCallback = std::make_shared(); + std::shared_ptr context = std::make_shared(); + auto continuationRegisterManagerProxy = std::make_shared(context); + continuationRegisterManagerProxy->applicationContext_ = context; + continuationRegisterManagerProxy->continuatinConnector_ = new (std::nothrow) ContinuationConnector(context); + continuationRegisterManagerProxy->continuatinConnector_->isConnected_.store(true); + + EXPECT_FALSE(requestCallback->onResult_); + continuationRegisterManagerProxy->UpdateConnectStatus(token, deviceId, status, requestCallback); + EXPECT_TRUE(requestCallback->onResult_); +} + +/* + * @tc.number : ContinuationRegisterManagerProxy_ShowDeviceList_001 + * @tc.name : ShowDeviceList + * @tc.desc : Verify that the ShowDeviceList interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_ShowDeviceList_001, TestSize.Level1) +{ + constexpr int32_t token = 0; + ExtraParams parameter; + std::shared_ptr requestCallback = std::make_shared(); + std::shared_ptr context = std::make_shared(); + auto continuationRegisterManagerProxy = std::make_shared(context); + std::weak_ptr applicationContext; + continuationRegisterManagerProxy->applicationContext_ = applicationContext; + continuationRegisterManagerProxy->continuatinConnector_ = new (std::nothrow) ContinuationConnector(context); + continuationRegisterManagerProxy->continuatinConnector_->isConnected_.store(true); + + EXPECT_FALSE(requestCallback->onResult_); + continuationRegisterManagerProxy->ShowDeviceList(token, parameter, requestCallback); + EXPECT_FALSE(requestCallback->onResult_); +} + +/* + * @tc.number : ContinuationRegisterManagerProxy_ShowDeviceList_002 + * @tc.name : ShowDeviceList + * @tc.desc : Verify that the ShowDeviceList interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_ShowDeviceList_002, TestSize.Level1) +{ + constexpr int32_t token = 0; + ExtraParams parameter; + std::shared_ptr requestCallback = std::make_shared(); + std::shared_ptr context = std::make_shared(); + auto continuationRegisterManagerProxy = std::make_shared(context); + continuationRegisterManagerProxy->applicationContext_ = context; + continuationRegisterManagerProxy->continuatinConnector_ = new (std::nothrow) ContinuationConnector(context); + continuationRegisterManagerProxy->continuatinConnector_->isConnected_.store(true); + + EXPECT_FALSE(requestCallback->onResult_); + continuationRegisterManagerProxy->ShowDeviceList(token, parameter, requestCallback); + EXPECT_TRUE(requestCallback->onResult_); +} + +/* + * @tc.number : ContinuationRegisterManagerProxy_Disconnect_001 + * @tc.name : Disconnect + * @tc.desc : Verify that the Disconnect interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_Disconnect_001, TestSize.Level1) +{ + std::shared_ptr context = std::make_shared(); + auto continuationRegisterManagerProxy = std::make_shared(context); + continuationRegisterManagerProxy->continuatinConnector_ = nullptr; + + continuationRegisterManagerProxy->Disconnect(); + EXPECT_TRUE(true); +} + +/* + * @tc.number : ContinuationRegisterManagerProxy_Disconnect_002 + * @tc.name : Disconnect + * @tc.desc : Verify that the Disconnect interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_Disconnect_002, TestSize.Level1) +{ + std::shared_ptr context = std::make_shared(); + auto continuationRegisterManagerProxy = std::make_shared(context); + continuationRegisterManagerProxy->continuatinConnector_ = new (std::nothrow) ContinuationConnector(context); + + EXPECT_FALSE(continuationRegisterManagerProxy->continuatinConnector_->isConnected_.load()); + continuationRegisterManagerProxy->continuatinConnector_->isConnected_.store(false); + + continuationRegisterManagerProxy->Disconnect(); + EXPECT_FALSE(continuationRegisterManagerProxy->continuatinConnector_->isConnected_.load()); +} + +/* + * @tc.number : ContinuationRegisterManagerProxy_Disconnect_003 + * @tc.name : Disconnect + * @tc.desc : Verify that the Disconnect interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_Disconnect_003, TestSize.Level1) +{ + std::shared_ptr context = std::make_shared(); + auto continuationRegisterManagerProxy = std::make_shared(context); + continuationRegisterManagerProxy->continuatinConnector_ = new (std::nothrow) ContinuationConnector(context); + EXPECT_TRUE(continuationRegisterManagerProxy->continuatinConnector_ != nullptr); + continuationRegisterManagerProxy->continuatinConnector_->isConnected_.store(true); + EXPECT_TRUE(continuationRegisterManagerProxy->continuatinConnector_->isConnected_.load()); + + continuationRegisterManagerProxy->Disconnect(); + EXPECT_FALSE(continuationRegisterManagerProxy->continuatinConnector_->isConnected_.load()); +} + +/* + * @tc.number : ContinuationRegisterManagerProxy_SendRequest_001 + * @tc.name : SendRequest + * @tc.desc : Verify that the SendRequest interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_SendRequest_001, TestSize.Level1) +{ + std::shared_ptr context = std::make_shared(); + auto continuationRegisterManagerProxy = std::make_shared(context); + std::shared_ptr request = std::make_shared(); + continuationRegisterManagerProxy->SendRequest(context, nullptr); + + EXPECT_TRUE(!request->execute_); +} + +/* + * @tc.number : ContinuationRegisterManagerProxy_SendRequest_002 + * @tc.name : SendRequest + * @tc.desc : Verify that the SendRequest interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_SendRequest_002, TestSize.Level1) +{ + std::shared_ptr context = std::make_shared(); + std::shared_ptr request = std::make_shared(); + auto continuationRegisterManagerProxy = std::make_shared(context); + continuationRegisterManagerProxy->continuatinConnector_ = nullptr; + EXPECT_TRUE(continuationRegisterManagerProxy->continuatinConnector_ == nullptr); + continuationRegisterManagerProxy->SendRequest(context, request); + + EXPECT_TRUE(continuationRegisterManagerProxy->continuatinConnector_ != nullptr); +} + +/* + * @tc.number : ContinuationRegisterManagerProxy_SendRequest_003 + * @tc.name : SendRequest + * @tc.desc : Verify that the SendRequest interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_SendRequest_003, TestSize.Level1) +{ + std::shared_ptr context = std::make_shared(); + std::shared_ptr request = std::make_shared(); + auto continuationRegisterManagerProxy = std::make_shared(context); + continuationRegisterManagerProxy->continuatinConnector_ = new (std::nothrow) ContinuationConnector(context); + EXPECT_TRUE(continuationRegisterManagerProxy->continuatinConnector_ != nullptr); + EXPECT_FALSE(continuationRegisterManagerProxy->continuatinConnector_->isConnected_.load()); + continuationRegisterManagerProxy->SendRequest(context, request); + + EXPECT_TRUE(!request->execute_); +} + +/* + * @tc.number : ContinuationRegisterManagerProxy_SendRequest_004 + * @tc.name : SendRequest + * @tc.desc : Verify that the SendRequest interface is called normally + */ +HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_SendRequest_004, TestSize.Level1) +{ + std::shared_ptr context = std::make_shared(); + std::shared_ptr request = std::make_shared(); + auto continuationRegisterManagerProxy = std::make_shared(context); + continuationRegisterManagerProxy->continuatinConnector_ = new (std::nothrow) ContinuationConnector(context); + EXPECT_TRUE(continuationRegisterManagerProxy->continuatinConnector_ != nullptr); + EXPECT_FALSE(continuationRegisterManagerProxy->continuatinConnector_->isConnected_.load()); + continuationRegisterManagerProxy->continuatinConnector_->isConnected_.store(true); + EXPECT_TRUE(continuationRegisterManagerProxy->continuatinConnector_->isConnected_.load()); + EXPECT_TRUE(!request->execute_); + continuationRegisterManagerProxy->SendRequest(context, request); + EXPECT_TRUE(request->execute_); +} +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file -- Gitee From 91c42104374708ead86ffe6e01dc72d4ea63ec91 Mon Sep 17 00:00:00 2001 From: xinxin13 Date: Fri, 16 Dec 2022 15:09:34 +0800 Subject: [PATCH 2/2] fix code Signed-off-by: xinxin13 --- .../ability_manager_test.cpp | 3 +- ...ontinuation_device_callback_proxy_test.cpp | 15 ++-- ...ntinuation_register_manager_proxy_test.cpp | 74 +++++++++---------- 3 files changed, 46 insertions(+), 46 deletions(-) diff --git a/test/unittest/ability_manager_test/ability_manager_test.cpp b/test/unittest/ability_manager_test/ability_manager_test.cpp index 96fb638cae3..fd1dce38dc3 100644 --- a/test/unittest/ability_manager_test/ability_manager_test.cpp +++ b/test/unittest/ability_manager_test/ability_manager_test.cpp @@ -25,8 +25,7 @@ using namespace testing::ext; using namespace testing; namespace OHOS { namespace AAFwk { -namespace -{ +namespace { constexpr int32_t ONE = 1; constexpr int32_t NEGATIVE = -1; } diff --git a/test/unittest/continuation_test/remote_register_service_test/continuation_device_callback_proxy_test/continuation_device_callback_proxy_test.cpp b/test/unittest/continuation_test/remote_register_service_test/continuation_device_callback_proxy_test/continuation_device_callback_proxy_test.cpp index 612dbd1a15e..f8984142cc8 100644 --- a/test/unittest/continuation_test/remote_register_service_test/continuation_device_callback_proxy_test/continuation_device_callback_proxy_test.cpp +++ b/test/unittest/continuation_test/remote_register_service_test/continuation_device_callback_proxy_test/continuation_device_callback_proxy_test.cpp @@ -27,9 +27,9 @@ using namespace testing::ext; using namespace testing; using namespace std::chrono; -namespace OHOS{ -namespace AppExecFwk{ -class ContinuationDeviceCallbackProxyTest : public testing::Test{ +namespace OHOS { +namespace AppExecFwk { +class ContinuationDeviceCallbackProxyTest : public testing::Test { public: static void SetUpTestCase(void); static void TearDownTestCase(void); @@ -53,8 +53,7 @@ void ContinuationDeviceCallbackProxyTest::TearDown(void) { } -class MoclCallback : public IContinuationDeviceCallback -{ +class MoclCallback : public IContinuationDeviceCallback { public: MoclCallback() {}; virtual ~MoclCallback() {}; @@ -105,7 +104,8 @@ HWTEST_F(ContinuationDeviceCallbackProxyTest, AppExecFwk_ContinuationDeviceCallb * @tc.name: Disconnect * @tc.desc: Verify function Disconnect pointer callback normal */ -HWTEST_F(ContinuationDeviceCallbackProxyTest, AppExecFwk_ContinuationDeviceCallbackProxy_Disconnect_001, TestSize.Level1) +HWTEST_F( + ContinuationDeviceCallbackProxyTest, AppExecFwk_ContinuationDeviceCallbackProxy_Disconnect_001, TestSize.Level1) { GTEST_LOG_(INFO) << "AppExecFwk_ContinuationDeviceCallbackProxy_Disconnect_001 start."; std::shared_ptr callback = std::make_shared(); @@ -123,7 +123,8 @@ HWTEST_F(ContinuationDeviceCallbackProxyTest, AppExecFwk_ContinuationDeviceCallb * @tc.name: Disconnect * @tc.desc: Verify function Disconnect pointer callback empty */ -HWTEST_F(ContinuationDeviceCallbackProxyTest, AppExecFwk_ContinuationDeviceCallbackProxy_Disconnect_002, TestSize.Level1) +HWTEST_F( + ContinuationDeviceCallbackProxyTest, AppExecFwk_ContinuationDeviceCallbackProxy_Disconnect_002, TestSize.Level1) { GTEST_LOG_(INFO) << "AppExecFwk_ContinuationDeviceCallbackProxy_Disconnect_002 start."; std::shared_ptr callback = nullptr; diff --git a/test/unittest/continuation_test/remote_register_service_test/continuation_register_manager_proxy_test/continuation_register_manager_proxy_test.cpp b/test/unittest/continuation_test/remote_register_service_test/continuation_register_manager_proxy_test/continuation_register_manager_proxy_test.cpp index 89476a76b9a..ce2b74edcbf 100644 --- a/test/unittest/continuation_test/remote_register_service_test/continuation_register_manager_proxy_test/continuation_register_manager_proxy_test.cpp +++ b/test/unittest/continuation_test/remote_register_service_test/continuation_register_manager_proxy_test/continuation_register_manager_proxy_test.cpp @@ -64,7 +64,7 @@ public: MoclConnectCallback() {}; virtual ~MoclConnectCallback() {}; - virtual void OnResult(int result) override + void OnResult(int result) override { onresult_ = true; }; @@ -77,7 +77,7 @@ public: MoclRequest() {}; virtual ~MoclRequest() {}; - virtual void Execute() override + void Execute() override { execute_ = true; }; @@ -108,7 +108,7 @@ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_ const std::string bundleName = ""; ExtraParams parameter; std::shared_ptr deviceCallback = nullptr; - auto pContinuationRequestRegister = + auto pContinuationRequestRegister = std::make_shared(bundleName, parameter, deviceCallback); std::shared_ptr requestCallback = std::make_shared(); pContinuationRequestRegister->SetContinuationConnector(nullptr); @@ -130,7 +130,7 @@ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_ std::shared_ptr context; sptr continuatinConnector = new (std::nothrow) ContinuationConnector(context); std::shared_ptr deviceCallback = nullptr; - auto pContinuationRequestRegister = + auto pContinuationRequestRegister = std::make_shared(bundleName, parameter, deviceCallback); pContinuationRequestRegister->SetContinuationConnector(continuatinConnector); std::shared_ptr requestCallback = std::make_shared(); @@ -153,7 +153,7 @@ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_ sptr continuatinConnector = new (std::nothrow) ContinuationConnector(context); std::shared_ptr requestCallback = std::make_shared(); std::shared_ptr deviceCallback = nullptr; - auto pContinuationRequestRegister = + auto pContinuationRequestRegister = std::make_shared(bundleName, parameter, deviceCallback); pContinuationRequestRegister->SetContinuationConnector(continuatinConnector); pContinuationRequestRegister->SetRequestCallback(requestCallback); @@ -169,8 +169,8 @@ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRegisterManagerProxy_ */ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestUnRegister_Execute_001, TestSize.Level1) { - constexpr int32_t token_ = 0; - auto pContinuationRequestUnRegister = std::make_shared(token_); + constexpr int32_t token = 0; + auto pContinuationRequestUnRegister = std::make_shared(token); std::shared_ptr requestCallback = std::make_shared(); pContinuationRequestUnRegister->SetContinuationConnector(nullptr); pContinuationRequestUnRegister->SetRequestCallback(requestCallback); @@ -186,10 +186,10 @@ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestUnRegister_Exe */ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestUnRegister_Execute_002, TestSize.Level1) { - constexpr int32_t token_ = 0; + constexpr int32_t token = 0; std::shared_ptr context; sptr continuatinConnector = new (std::nothrow) ContinuationConnector(context); - auto pContinuationRequestUnRegister = std::make_shared(token_); + auto pContinuationRequestUnRegister = std::make_shared(token); pContinuationRequestUnRegister->SetContinuationConnector(continuatinConnector); std::shared_ptr requestCallback = std::make_shared(); pContinuationRequestUnRegister->SetRequestCallback(nullptr); @@ -205,10 +205,10 @@ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestUnRegister_Exe */ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestUnRegister_Execute_003, TestSize.Level1) { - constexpr int32_t token_ = 0; + constexpr int32_t token = 0; std::shared_ptr context; sptr continuatinConnector = new (std::nothrow) ContinuationConnector(context); - auto pContinuationRequestUnRegister = std::make_shared(token_); + auto pContinuationRequestUnRegister = std::make_shared(token); std::shared_ptr requestCallback = std::make_shared(); pContinuationRequestUnRegister->SetContinuationConnector(continuatinConnector); pContinuationRequestUnRegister->SetRequestCallback(requestCallback); @@ -224,11 +224,11 @@ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestUnRegister_Exe */ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestUpdateConnectStatus_Execute_001, TestSize.Level1) { - constexpr int32_t token_ = 0; - const std::string deviceId_ = ""; - constexpr int32_t status_ = 0; - auto pContinuationRequestUpdateConnectStatus = - std::make_shared(token_, deviceId_, status_); + constexpr int32_t token = 0; + const std::string deviceId = ""; + constexpr int32_t status = 0; + auto pContinuationRequestUpdateConnectStatus = + std::make_shared(token, deviceId, status); pContinuationRequestUpdateConnectStatus->SetContinuationConnector(nullptr); std::shared_ptr requestCallback = std::make_shared(); pContinuationRequestUpdateConnectStatus->SetRequestCallback(requestCallback); @@ -244,13 +244,13 @@ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestUpdateConnectS */ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestUpdateConnectStatus_Execute_002, TestSize.Level1) { - constexpr int32_t token_ = 0; - const std::string deviceId_ = ""; - constexpr int32_t status_ = 0; + constexpr int32_t token = 0; + const std::string deviceId = ""; + constexpr int32_t status = 0; std::shared_ptr context; sptr continuatinConnector = new (std::nothrow) ContinuationConnector(context); - auto pContinuationRequestUpdateConnectStatus = - std::make_shared(token_, deviceId_, status_); + auto pContinuationRequestUpdateConnectStatus = + std::make_shared(token, deviceId, status); pContinuationRequestUpdateConnectStatus->SetContinuationConnector(continuatinConnector); std::shared_ptr requestCallback = std::make_shared(); pContinuationRequestUpdateConnectStatus->SetRequestCallback(nullptr); @@ -266,13 +266,13 @@ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestUpdateConnectS */ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestUpdateConnectStatus_Execute_003, TestSize.Level1) { - constexpr int32_t token_ = 0; - const std::string deviceId_ = ""; - constexpr int32_t status_ = 0; + constexpr int32_t token = 0; + const std::string deviceId = ""; + constexpr int32_t status = 0; std::shared_ptr context; sptr continuatinConnector = new (std::nothrow) ContinuationConnector(context); - auto pContinuationRequestUpdateConnectStatus = - std::make_shared(token_, deviceId_, status_); + auto pContinuationRequestUpdateConnectStatus = + std::make_shared(token, deviceId, status); std::shared_ptr requestCallback = std::make_shared(); pContinuationRequestUpdateConnectStatus->SetContinuationConnector(continuatinConnector); pContinuationRequestUpdateConnectStatus->SetRequestCallback(requestCallback); @@ -288,9 +288,9 @@ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestUpdateConnectS */ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestShowDeviceList_Execute_001, TestSize.Level1) { - constexpr int32_t token_ = 0; - ExtraParams parameter_; - auto pContinuationRequestShowDeviceList = std::make_shared(token_, parameter_); + constexpr int32_t token = 0; + ExtraParams parameter; + auto pContinuationRequestShowDeviceList = std::make_shared(token, parameter); std::shared_ptr requestCallback = std::make_shared(); pContinuationRequestShowDeviceList->SetContinuationConnector(nullptr); pContinuationRequestShowDeviceList->SetRequestCallback(requestCallback); @@ -306,13 +306,13 @@ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestShowDeviceList */ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestShowDeviceList_Execute_002, TestSize.Level1) { - constexpr int32_t token_ = 0; - ExtraParams parameter_; + constexpr int32_t token = 0; + ExtraParams parameter; std::shared_ptr context; sptr continuatinConnector = new (std::nothrow) ContinuationConnector(context); std::shared_ptr requestCallback = std::make_shared(); - auto pContinuationRequestShowDeviceList = - std::make_shared(token_, parameter_); + auto pContinuationRequestShowDeviceList = + std::make_shared(token, parameter); pContinuationRequestShowDeviceList->SetContinuationConnector(continuatinConnector); pContinuationRequestShowDeviceList->SetRequestCallback(nullptr); EXPECT_TRUE(!requestCallback->onresult_); @@ -327,12 +327,12 @@ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestShowDeviceList */ HWTEST_F(ContinuationRegisterManagerProxyTest, ContinuationRequestShowDeviceList_Execute_003, TestSize.Level1) { - constexpr int32_t token_ = 0; - ExtraParams parameter_; + constexpr int32_t token = 0; + ExtraParams parameter; std::shared_ptr context; sptr continuatinConnector = new (std::nothrow) ContinuationConnector(context); - auto pContinuationRequestShowDeviceList = - std::make_shared(token_, parameter_); + auto pContinuationRequestShowDeviceList = + std::make_shared(token, parameter); std::shared_ptr requestCallback = std::make_shared(); pContinuationRequestShowDeviceList->SetContinuationConnector(continuatinConnector); pContinuationRequestShowDeviceList->SetRequestCallback(requestCallback); -- Gitee