From 5b1f2d8817e392803dd16e36208f9359cf6026ea Mon Sep 17 00:00:00 2001 From: xinxin13 Date: Sat, 31 Dec 2022 12:11:23 +0800 Subject: [PATCH 1/2] add data ability helper impl tdd test code Signed-off-by: xinxin13 --- .../include/mock_ability_manager_service.h | 6 +- .../BUILD.gn | 54 + .../data_ability_helper_impl_test.cpp | 1928 +++++++++++++++++ 3 files changed, 1986 insertions(+), 2 deletions(-) create mode 100644 test/unittest/frameworks_kits_ability_native_test/data_ability_helper_impl_test.cpp diff --git a/test/mock/frameworks_kits_ability_native_test/include/mock_ability_manager_service.h b/test/mock/frameworks_kits_ability_native_test/include/mock_ability_manager_service.h index 47dd3e50b3b..521972bd058 100644 --- a/test/mock/frameworks_kits_ability_native_test/include/mock_ability_manager_service.h +++ b/test/mock/frameworks_kits_ability_native_test/include/mock_ability_manager_service.h @@ -139,13 +139,13 @@ public: sptr AcquireDataAbility( const Uri& uri, bool tryBind, const sptr& callerToken) override { - return nullptr; + return acquireDataAbility_; } int ReleaseDataAbility( sptr dataAbilityScheduler, const sptr& callerToken) override { - return 0; + return releaseDataAbility_; } int KillProcess(const std::string& bundleName) override; @@ -279,6 +279,8 @@ public: sptr abilityScheduler_; // kit interface used to schedule ability life Want want_; + sptr acquireDataAbility_; + int releaseDataAbility_ = 0; }; } // namespace AAFwk } // namespace OHOS diff --git a/test/unittest/frameworks_kits_ability_native_test/BUILD.gn b/test/unittest/frameworks_kits_ability_native_test/BUILD.gn index 8f132a9e221..5ac64080158 100644 --- a/test/unittest/frameworks_kits_ability_native_test/BUILD.gn +++ b/test/unittest/frameworks_kits_ability_native_test/BUILD.gn @@ -405,6 +405,60 @@ ohos_unittest("data_ability_helper_test") { } } +ohos_unittest("data_ability_helper_impl_test") { + module_out_path = module_output_path + include_dirs = [ + "${ability_runtime_services_path}/abilitymgr/include", + "${ability_runtime_path}/interfaces/kits/native/ability/native", + "${ability_runtime_path}/interfaces/kits/native/appkit/ability_runtime/context", + "//foundation/ability/ability_runtime/interfaces/kits/native/ability/native", + "${ability_runtime_innerkits_path}/dataobs_manager/include", + "//foundation/ability/ability_runtime/test/mock/frameworks_kits_ability_native_test/include", + "//foundation/ability/ability_runtime/interfaces/inner_api/dataobs_manager/include", + "//foundation/ability/ability_runtime/services/dataobsmgr/include", + ] + sources = [ + "${ability_runtime_path}/frameworks/native/ability/native/data_ability_helper_impl.cpp", + "${ability_runtime_path}/test/mock/frameworks_kits_ability_native_test/include/mock_ability_manager_service.cpp", + "//foundation/ability/ability_runtime/services/dataobsmgr/src/data_ability_observer_stub.cpp", + "data_ability_helper_impl_test.cpp", + "mock_ability_runtime_context.cpp", + ] + configs = [ + ":module_ability_context_config", + ":coverage_flags", + ] + deps = [ + "${ability_runtime_innerkits_path}/ability_manager:ability_manager", + "${ability_runtime_innerkits_path}/dataobs_manager:dataobs_manager", + "${ability_runtime_native_path}/ability/native:abilitykit_native", + "${ability_runtime_native_path}/ability/native:data_ability_helper", + "${ability_runtime_native_path}/appkit:app_context", + "${ability_runtime_services_path}/abilitymgr:abilityms", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] + external_deps = [ + "ability_base:base", + "ability_base:want", + "ability_base:zuri", + "c_utils:utils", + "data_share:datashare_common", + "data_share:datashare_consumer", + "eventhandler:libeventhandler", + "hitrace_native:hitrace_meter", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "relational_store:native_appdatafwk", + "relational_store:native_dataability", + "relational_store:native_rdb", + "relational_store:rdb_data_ability_adapter", + ] + if (ability_runtime_graphics) { + external_deps += [ "input:libmmi-client" ] + } +} + ohos_unittest("data_ability_operation_test") { module_out_path = module_output_path sources = [ "data_ability_operation_test.cpp" ] diff --git a/test/unittest/frameworks_kits_ability_native_test/data_ability_helper_impl_test.cpp b/test/unittest/frameworks_kits_ability_native_test/data_ability_helper_impl_test.cpp new file mode 100644 index 00000000000..34903b3bc9e --- /dev/null +++ b/test/unittest/frameworks_kits_ability_native_test/data_ability_helper_impl_test.cpp @@ -0,0 +1,1928 @@ +/* + * 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 "gtest/gtest.h" + +#define private public +#define protected public + +#include "ability_connect_manager.h" +#include "ability_context.h" +#include "ability_manager_client.h" +#include "ability_scheduler_proxy.h" +#include "ability_thread.h" +#include "abs_shared_result_set.h" +#include "context.h" +#include "datashare_helper.h" +#include "data_ability_helper.h" +#include "data_ability_helper_impl.h" +#include "data_ability_predicates.h" +#include "data_ability_observer_interface.h" +#include "data_ability_observer_stub.h" +#include "data_ability_observer_proxy.h" +#include "mock_ability_manager_client.h" +#include "mock_ability_manager_service.h" +#include "mock_ability_runtime_context.h" +#include "mock_ability_scheduler_for_observer.h" +#include "values_bucket.h" + +#undef private +#undef protected + +namespace OHOS { +namespace AppExecFwk { +using namespace testing::ext; + +class DataAbilityHelperImplForObserverTest : public testing::Test { +public: + DataAbilityHelperImplForObserverTest() {} + virtual ~DataAbilityHelperImplForObserverTest() {} + static void SetUpTestCase(void) {}; + static void TearDownTestCase(void) {}; + void SetUp() {}; + void TearDown() {}; +}; + +class MolDataAbilityObserver : public AAFwk::DataAbilityObserverStub { +public: + MolDataAbilityObserver() {}; + virtual ~MolDataAbilityObserver() {}; + void OnChange() override {}; +}; + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_OnRemoteDied_0100 + * @tc.name: OnRemoteDied + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_OnRemoteDied_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_OnRemoteDied_0100 start"; + DataAbilityDeathRecipient::RemoteDiedHandler handler; + const wptr remote; + DataAbilityDeathRecipient dataAbilityDeathRecipient(handler); + dataAbilityDeathRecipient.OnRemoteDied(remote); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_OnRemoteDied_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_OnRemoteDied_0200 + * @tc.name: OnRemoteDied + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_OnRemoteDied_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_OnRemoteDied_0200 start"; + DataAbilityDeathRecipient::RemoteDiedHandler handler = nullptr; + const wptr remote; + DataAbilityDeathRecipient dataAbilityDeathRecipient(handler); + dataAbilityDeathRecipient.OnRemoteDied(remote); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_OnRemoteDied_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Creator_0100 + * @tc.name: Creator + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Creator_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_0100 start"; + std::shared_ptr context; + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + EXPECT_TRUE(dataAbilityHelperImpl == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Creator_0200 + * @tc.name: Creator + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Creator_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_0200 start"; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + EXPECT_TRUE(dataAbilityHelperImpl != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Creator_0300 + * @tc.name: Creator + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Creator_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_0300 start"; + std::shared_ptr context; + std::shared_ptr uri = nullptr; + bool tryBind = false; + auto dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context, uri, tryBind); + EXPECT_TRUE(dataAbilityHelperImpl == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_0300 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Creator_0400 + * @tc.name: Creator + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Creator_0400, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_0400 start"; + std::shared_ptr context = std::make_shared(); + std::shared_ptr uri = nullptr; + bool tryBind = false; + auto dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context, uri, tryBind); + EXPECT_TRUE(dataAbilityHelperImpl == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_0400 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Creator_0500 + * @tc.name: Creator + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Creator_0500, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_0500 start"; + std::shared_ptr context = std::make_shared(); + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + bool tryBind = false; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + auto dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context, uri, tryBind); + EXPECT_TRUE(dataAbilityHelperImpl != nullptr); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_0500 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Creator_0600 + * @tc.name: Creator + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Creator_0600, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_0600 start"; + std::shared_ptr context = nullptr; + std::shared_ptr uri = nullptr; + bool tryBind = false; + auto dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context, uri, tryBind); + EXPECT_TRUE(dataAbilityHelperImpl == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_0600 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Creator_0700 + * @tc.name: Creator + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Creator_0700, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_0700 start"; + std::shared_ptr context = + std::make_shared(); + std::shared_ptr uri = nullptr; + bool tryBind = false; + auto dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context, uri, tryBind); + EXPECT_TRUE(dataAbilityHelperImpl == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_0700 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Creator_0800 + * @tc.name: Creator + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Creator_0800, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_0800 start"; + std::shared_ptr context = + std::make_shared(); + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + bool tryBind = false; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + auto dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context, uri, tryBind); + porxyNew->acquireDataAbility_ = nullptr; + EXPECT_TRUE(dataAbilityHelperImpl != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_0800 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Creator_0900 + * @tc.name: Creator + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Creator_0900, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_0900 start"; + sptr token; + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token); + EXPECT_TRUE(dataAbilityHelperImpl == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_0900 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Creator_1000 + * @tc.name: Creator + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Creator_1000, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_1000 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token); + EXPECT_TRUE(dataAbilityHelperImpl != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_1000 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Creator_1100 + * @tc.name: Creator + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Creator_1100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_1100 start"; + sptr token; + std::shared_ptr uri = nullptr; + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_TRUE(dataAbilityHelperImpl == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_1100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Creator_1200 + * @tc.name: Creator + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Creator_1200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_1200 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + std::shared_ptr uri = nullptr; + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_TRUE(dataAbilityHelperImpl == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_1200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Creator_1300 + * @tc.name: Creator + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Creator_1300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_1300 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + porxyNew->acquireDataAbility_ = nullptr; + EXPECT_TRUE(dataAbilityHelperImpl != nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_1300 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Creator_1400 + * @tc.name: Creator + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Creator_1400, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_1400 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + sptr proxy = AbilityManagerClient::GetInstance()->proxy_; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_TRUE(dataAbilityHelperImpl == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_1400 end"; + AbilityManagerClient::GetInstance()->proxy_ = proxy; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Creator_1500 + * @tc.name: Creator + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Creator_1500, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_1500 start"; + std::weak_ptr abilityRecord; + std::shared_ptr context = std::make_shared(); + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + bool tryBind = true; + sptr proxy = AbilityManagerClient::GetInstance()->proxy_; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + auto dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context, uri, tryBind); + EXPECT_TRUE(dataAbilityHelperImpl == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_1500 end"; + AbilityManagerClient::GetInstance()->proxy_ = proxy; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Creator_1600 + * @tc.name: Creator + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Creator_1600, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_1600 start"; + std::weak_ptr abilityRecord; + std::shared_ptr context = + std::make_shared(); + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + bool tryBind = true; + sptr proxy = AbilityManagerClient::GetInstance()->proxy_; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + auto dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context, uri, tryBind); + EXPECT_TRUE(dataAbilityHelperImpl == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Creator_1600 end"; + AbilityManagerClient::GetInstance()->proxy_ = proxy; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_CheckUri_0100 + * @tc.name: CheckUri + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_CheckUri_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckUri_0100 start"; + std::shared_ptr context; + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + EXPECT_TRUE(dataAbilityHelperImpl == nullptr); + std::shared_ptr uri = nullptr; + bool ret = true; + ret = dataAbilityHelperImpl->CheckUri(uri); + EXPECT_FALSE(ret); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckUri_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_CheckUri_0200 + * @tc.name: CheckUri + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_CheckUri_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckUri_0200 start"; + std::shared_ptr context; + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + EXPECT_TRUE(dataAbilityHelperImpl == nullptr); + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + bool ret = false; + ret = dataAbilityHelperImpl->CheckUri(uri); + EXPECT_TRUE(ret); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckUri_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_CheckUri_0300 + * @tc.name: CheckUri + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_CheckUri_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckUri_0300 start"; + std::shared_ptr context; + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + EXPECT_TRUE(dataAbilityHelperImpl == nullptr); + std::shared_ptr uri = + std::make_shared("datashare://device_id/com.domainname.dataability.persondata/person/10"); + bool ret = true; + ret = dataAbilityHelperImpl->CheckUri(uri); + EXPECT_FALSE(ret); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckUri_0300 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Release_0100 + * @tc.name: Release + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Release_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Release_0100 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + dataAbilityHelperImpl->uri_ = nullptr; + porxyNew->acquireDataAbility_ = nullptr; + bool ret = true; + ret = dataAbilityHelperImpl->Release(); + EXPECT_FALSE(ret); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Release_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Release_0200 + * @tc.name: Release + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Release_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Release_0200 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + dataAbilityHelperImpl->uri_ = uri; + porxyNew->acquireDataAbility_ = nullptr; + bool ret = false; + ret = dataAbilityHelperImpl->Release(); + EXPECT_TRUE(ret); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Release_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Release_0300 + * @tc.name: Release + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Release_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Release_0300 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + porxyNew->releaseDataAbility_ = 1; + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + dataAbilityHelperImpl->uri_ = uri; + porxyNew->acquireDataAbility_ = nullptr; + bool ret = true; + ret = dataAbilityHelperImpl->Release(); + EXPECT_FALSE(ret); + porxyNew->releaseDataAbility_ = 0; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Release_0300 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_GetFileTypes_0100 + * @tc.name: GetFileTypes + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_GetFileTypes_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_GetFileTypes_0100 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + const std::string mimeTypeFilter = "abc"; + std::vector matchedMIMEs; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("\nullptr"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_TRUE(dataAbilityHelperImpl->GetFileTypes(urivalue, mimeTypeFilter) == matchedMIMEs); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_GetFileTypes_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_GetFileTypes_0200 + * @tc.name: GetFileTypes + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_GetFileTypes_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_GetFileTypes_0200 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + const std::string mimeTypeFilter = "mimeTypeFiltertest"; + std::vector matchedMIMEs; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_TRUE(dataAbilityHelperImpl->GetFileTypes(urivalue, mimeTypeFilter) == matchedMIMEs); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_GetFileTypes_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_OpenFile_0100 + * @tc.name: OpenFile + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_OpenFile_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_OpenFile_0100 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + const std::string mode = "abc"; + constexpr int32_t number = -1; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("\nullptr"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_TRUE(dataAbilityHelperImpl->OpenFile(urivalue, mode) == number); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_OpenFile_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_OpenFile_0200 + * @tc.name: OpenFile + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_OpenFile_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_OpenFile_0200 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + const std::string mode = "modetest"; + constexpr int32_t number = 0; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_EQ(dataAbilityHelperImpl->OpenFile(urivalue, mode), number); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_OpenFile_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_OpenRawFile_0100 + * @tc.name: OpenRawFile + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_OpenRawFile_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_OpenRawFile_0100 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + const std::string mode = "abc"; + constexpr int32_t number = -1; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("\nullptr"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_TRUE(dataAbilityHelperImpl->OpenRawFile(urivalue, mode) == number); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_OpenRawFile_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_OpenRawFile_0200 + * @tc.name: OpenRawFile + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_OpenRawFile_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_OpenRawFile_0200 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + const std::string mode = "modetest"; + constexpr int32_t number = 0; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_EQ(dataAbilityHelperImpl->OpenRawFile(urivalue, mode), number); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_OpenRawFile_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Insert_0100 + * @tc.name: Insert + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Insert_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Insert_0100 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + NativeRdb::ValuesBucket val; + val.PutInt("valtest", 20); + constexpr int32_t number = -1; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("\nullptr"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_TRUE(dataAbilityHelperImpl->Insert(urivalue, val) == number); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Insert_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Insert_0200 + * @tc.name: Insert + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Insert_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Insert_0200 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + NativeRdb::ValuesBucket val; + val.PutInt("valtest", 20); + constexpr int32_t number = 0; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_EQ(dataAbilityHelperImpl->Insert(urivalue, val), number); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Insert_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Call_0100 + * @tc.name: Call + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Call_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Call_0100 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + const std::string method; + const std::string arg; + AppExecFwk::PacMap pacMap; + std::shared_ptr result = nullptr; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("\nullptr"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_TRUE(dataAbilityHelperImpl->Call(urivalue, method, arg, pacMap) == result); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Call_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Call_0200 + * @tc.name: Call + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Call_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Call_0200 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + const std::string method; + const std::string arg; + AppExecFwk::PacMap pacMap; + std::shared_ptr result = nullptr; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_TRUE(dataAbilityHelperImpl->Call(urivalue, method, arg, pacMap) == result); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Call_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Update_0100 + * @tc.name: Update + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Update_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Update_0100 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + NativeRdb::ValuesBucket val; + val.PutInt("valtest", 20); + NativeRdb::DataAbilityPredicates predicates("predicatestest"); + constexpr int32_t number = -1; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("\nullptr"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_EQ(dataAbilityHelperImpl->Update(urivalue, val, predicates), number); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Update_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Update_0200 + * @tc.name: Update + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Update_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Update_0200 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + NativeRdb::ValuesBucket val; + val.PutInt("valtest", 20); + NativeRdb::DataAbilityPredicates predicates("predicatestest"); + constexpr int32_t number = 0; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_EQ(dataAbilityHelperImpl->Update(urivalue, val, predicates), number); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Update_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Delete_0100 + * @tc.name: Delete + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Delete_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Delete_0100 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + NativeRdb::DataAbilityPredicates predicates("predicatestest"); + constexpr int32_t number = -1; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("\nullptr"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_EQ(dataAbilityHelperImpl->Delete(urivalue, predicates), number); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Delete_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Delete_0200 + * @tc.name: Delete + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Delete_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Delete_0200 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + NativeRdb::DataAbilityPredicates predicates("predicatestest"); + constexpr int32_t number = 0; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_EQ(dataAbilityHelperImpl->Delete(urivalue, predicates), number); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Delete_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Query_0100 + * @tc.name: Query + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Query_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Query_0100 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + std::vector columns; + NativeRdb::DataAbilityPredicates predicates("predicatestest"); + std::shared_ptr resultset = nullptr; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("\nullptr"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_EQ(dataAbilityHelperImpl->Query(urivalue, columns, predicates), resultset); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Query_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Query_0200 + * @tc.name: Query + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Query_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Query_0200 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + std::vector columns; + NativeRdb::DataAbilityPredicates predicates("predicatestest"); + std::shared_ptr resultset = nullptr; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_EQ(dataAbilityHelperImpl->Query(urivalue, columns, predicates), resultset); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Query_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_GetType_0100 + * @tc.name: GetType + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_GetType_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_GetType_0100 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + const std::string type; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("\nullptr"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_EQ(dataAbilityHelperImpl->GetType(urivalue), type); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_GetType_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_GetType_0200 + * @tc.name: GetType + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_GetType_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_GetType_0200 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + const std::string type; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_EQ(dataAbilityHelperImpl->GetType(urivalue), type); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_GetType_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Reload_0100 + * @tc.name: Reload + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Reload_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Reload_0100 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + PacMap extras; + bool ret = false; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("\nullptr"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_EQ(dataAbilityHelperImpl->Reload(urivalue, extras), ret); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Reload_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_Reload_0200 + * @tc.name: Reload + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_Reload_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Reload_0200 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + PacMap extras; + bool ret = false; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_EQ(dataAbilityHelperImpl->Reload(urivalue, extras), ret); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_Reload_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_BatchInsert_0100 + * @tc.name: BatchInsert + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_BatchInsert_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_BatchInsert_0100 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + std::vector values; + constexpr int32_t ret = -1; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("\nullptr"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_EQ(dataAbilityHelperImpl->BatchInsert(urivalue, values), ret); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_BatchInsert_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_BatchInsert_0200 + * @tc.name: BatchInsert + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_BatchInsert_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_BatchInsert_0200 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + constexpr int32_t ret = 0; + std::vector values; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_EQ(dataAbilityHelperImpl->BatchInsert(urivalue, values), ret); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_BatchInsert_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_NotifyChange_0100 + * @tc.name: NotifyChange + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_NotifyChange_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_NotifyChange_0100 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("\nullptr"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + dataAbilityHelperImpl->NotifyChange(urivalue); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_NotifyChange_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_NotifyChange_0200 + * @tc.name: NotifyChange + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_NotifyChange_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_NotifyChange_0200 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + dataAbilityHelperImpl->NotifyChange(urivalue); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_NotifyChange_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_NormalizeUri_0100 + * @tc.name: NormalizeUri + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_NormalizeUri_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_NormalizeUri_0100 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + Uri urivalue_(""); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("\nullptr"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_TRUE(dataAbilityHelperImpl->NormalizeUri(urivalue) == urivalue_); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_NormalizeUri_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_NormalizeUri_0200 + * @tc.name: NormalizeUri + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_NormalizeUri_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_NormalizeUri_0200 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + Uri urivalue_(""); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("dataability://device_id/com.domainname.dataability."); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + dataAbilityHelperImpl->NormalizeUri(urivalue); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_NormalizeUri_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_DenormalizeUri_0100 + * @tc.name: DenormalizeUri + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_DenormalizeUri_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_DenormalizeUri_0100 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + Uri urivalue_(""); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("\nullptr"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_TRUE(dataAbilityHelperImpl->DenormalizeUri(urivalue) == urivalue_); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_DenormalizeUri_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_DenormalizeUri_0200 + * @tc.name: DenormalizeUri + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_DenormalizeUri_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_DenormalizeUri_0200 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + Uri urivalue_(""); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("dataability://device_id/com.domainname.dataability."); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_TRUE(dataAbilityHelperImpl->DenormalizeUri(urivalue) == urivalue_); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_DenormalizeUri_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_ExecuteBatch_0100 + * @tc.name: ExecuteBatch + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_ExecuteBatch_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_ExecuteBatch_0100 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + std::vector> results; + std::vector> operations; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("\nullptr"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_TRUE(dataAbilityHelperImpl->ExecuteBatch(urivalue, operations) == results); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_ExecuteBatch_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_ExecuteBatch_0200 + * @tc.name: ExecuteBatch + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_ExecuteBatch_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_ExecuteBatch_0200 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + std::vector> results; + std::vector> operations; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_TRUE(dataAbilityHelperImpl->ExecuteBatch(urivalue, operations) == results); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_ExecuteBatch_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_CheckOhosUri_0100 + * @tc.name: CheckOhosUri + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_CheckOhosUri_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckOhosUri_0100 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + Uri urivalue("\nullptr"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_FALSE(dataAbilityHelperImpl->CheckOhosUri(urivalue)); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckOhosUri_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_CheckOhosUri_0200 + * @tc.name: CheckOhosUri + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_CheckOhosUri_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckOhosUri_0200 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(token, uri); + EXPECT_TRUE(dataAbilityHelperImpl->CheckOhosUri(*uri)); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckOhosUri_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_ReleaseDataAbility_0100 + * @tc.name: ReleaseDataAbility + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_ReleaseDataAbility_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_ReleaseDataAbility_0100 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + sptr dataAbilityProxy = dataAbilityHelperImpl->GetDataAbilityProxy(*uri); + dataAbilityHelperImpl->ReleaseDataAbility(dataAbilityProxy); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_ReleaseDataAbility_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_ReleaseDataAbility_0200 + * @tc.name: ReleaseDataAbility + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_ReleaseDataAbility_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_ReleaseDataAbility_0200 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + dataAbilityHelperImpl->token_ = token; + sptr dataAbilityProxy = dataAbilityHelperImpl->GetDataAbilityProxy(*uri); + dataAbilityHelperImpl->ReleaseDataAbility(dataAbilityProxy); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_ReleaseDataAbility_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_ReleaseDataAbility_0300 + * @tc.name: ReleaseDataAbility + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_ReleaseDataAbility_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_ReleaseDataAbility_0300 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + dataAbilityHelperImpl->uri_ = uri; + dataAbilityHelperImpl->token_ = token; + sptr dataAbilityProxy; + dataAbilityHelperImpl->ReleaseDataAbility(dataAbilityProxy); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_ReleaseDataAbility_0300 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_ReleaseDataAbility_0400 + * @tc.name: ReleaseDataAbility + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_ReleaseDataAbility_0400, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_ReleaseDataAbility_0400 start"; + std::weak_ptr abilityRecord; + sptr token; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + dataAbilityHelperImpl->token_ = token; + dataAbilityHelperImpl->uri_ = uri; + sptr dataAbilityProxy = dataAbilityHelperImpl->GetDataAbilityProxy(*uri); + dataAbilityHelperImpl->ReleaseDataAbility(dataAbilityProxy); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_ReleaseDataAbility_0400 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_OnSchedulerDied_0100 + * @tc.name: OnSchedulerDied + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_OnSchedulerDied_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_OnSchedulerDied_0100 start"; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + const wptr remote; + dataAbilityHelperImpl->OnSchedulerDied(remote); + porxyNew->acquireDataAbility_ = nullptr; + EXPECT_TRUE(dataAbilityHelperImpl->uri_ == nullptr); + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_OnSchedulerDied_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_AddDataAbilityDeathRecipient_0100 + * @tc.name: AddDataAbilityDeathRecipient + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_AddDataAbilityDeathRecipient_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_AddDataAbilityDeathRecipient_0100 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + DataAbilityDeathRecipient::RemoteDiedHandler handler; + sptr callerDeathRecipient = new (std::nothrow) DataAbilityDeathRecipient(handler); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + dataAbilityHelperImpl->callerDeathRecipient_ = callerDeathRecipient; + dataAbilityHelperImpl->AddDataAbilityDeathRecipient(token); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_AddDataAbilityDeathRecipient_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_AddDataAbilityDeathRecipient_0200 + * @tc.name: AddDataAbilityDeathRecipient + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_AddDataAbilityDeathRecipient_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_AddDataAbilityDeathRecipient_0200 start"; + std::weak_ptr abilityRecord; + sptr token; + DataAbilityDeathRecipient::RemoteDiedHandler handler; + sptr callerDeathRecipient = new (std::nothrow) DataAbilityDeathRecipient(handler); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + dataAbilityHelperImpl->callerDeathRecipient_ = callerDeathRecipient; + dataAbilityHelperImpl->AddDataAbilityDeathRecipient(token); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_AddDataAbilityDeathRecipient_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_AddDataAbilityDeathRecipient_0300 + * @tc.name: AddDataAbilityDeathRecipient + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_AddDataAbilityDeathRecipient_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_AddDataAbilityDeathRecipient_0300 start"; + std::weak_ptr abilityRecord; + sptr token = new OHOS::AAFwk::Token(abilityRecord); + sptr callerDeathRecipient = nullptr; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + dataAbilityHelperImpl->callerDeathRecipient_ = callerDeathRecipient; + dataAbilityHelperImpl->AddDataAbilityDeathRecipient(token); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_AddDataAbilityDeathRecipient_0300 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_CheckUriAndDataObserver_0100 + * @tc.name: CheckUriAndDataObserver + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_CheckUriAndDataObserver_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckUriAndDataObserver_0100 start"; + std::shared_ptr uri = std::make_shared("\nullptr"); + const sptr dataObserver; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + EXPECT_FALSE(dataAbilityHelperImpl->CheckUriAndDataObserver(*uri, dataObserver)); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckUriAndDataObserver_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_CheckUriAndDataObserver_0200 + * @tc.name: CheckUriAndDataObserver + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_CheckUriAndDataObserver_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckUriAndDataObserver_0200 start"; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + const sptr dataObserver; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + EXPECT_FALSE(dataAbilityHelperImpl->CheckUriAndDataObserver(*uri, dataObserver)); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckUriAndDataObserver_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_CheckUriAndDataObserver_0300 + * @tc.name: CheckUriAndDataObserver + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_CheckUriAndDataObserver_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckUriAndDataObserver_0300 start"; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + const sptr dataObserver = new (std::nothrow) MolDataAbilityObserver(); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + EXPECT_TRUE(dataAbilityHelperImpl->CheckUriAndDataObserver(*uri, dataObserver)); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckUriAndDataObserver_0300 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_CheckUriParam_0100 + * @tc.name: CheckUriParam + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_CheckUriParam_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckUriParam_0100 start"; + std::shared_ptr uri = std::make_shared("\nullptr"); + const sptr dataObserver; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + EXPECT_FALSE(dataAbilityHelperImpl->CheckUriParam(*uri)); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckUriParam_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_CheckUriParam_0200 + * @tc.name: CheckUriParam + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_CheckUriParam_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckUriParam_0200 start"; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + const sptr dataObserver; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + EXPECT_TRUE(dataAbilityHelperImpl->CheckUriParam(*uri)); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_CheckUriParam_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_GetDataAbilityProxy_0100 + * @tc.name: GetDataAbilityProxy + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_GetDataAbilityProxy_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_GetDataAbilityProxy_0100 start"; + std::shared_ptr uri = std::make_shared("\nullptr"); + const sptr dataObserver; + bool addDeathRecipient = true; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + EXPECT_TRUE(dataAbilityHelperImpl->GetDataAbilityProxy(*uri, addDeathRecipient) == nullptr); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_GetDataAbilityProxy_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_GetDataAbilityProxy_0200 + * @tc.name: GetDataAbilityProxy + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_GetDataAbilityProxy_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_GetDataAbilityProxy_0200 start"; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + const sptr dataObserver; + bool addDeathRecipient = true; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + EXPECT_TRUE(dataAbilityHelperImpl->GetDataAbilityProxy(*uri, addDeathRecipient) != nullptr); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_GetDataAbilityProxy_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_GetDataAbilityProxy_0300 + * @tc.name: GetDataAbilityProxy + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_GetDataAbilityProxy_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_GetDataAbilityProxy_0300 start"; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + const sptr dataObserver; + bool addDeathRecipient = true; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + dataAbilityHelperImpl->uri_ = nullptr; + dataAbilityHelperImpl->isSystemCaller_ = true; + EXPECT_TRUE(dataAbilityHelperImpl->GetDataAbilityProxy(*uri, addDeathRecipient) != nullptr); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_GetDataAbilityProxy_0300 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0100 + * @tc.name: RegisterObserver + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0100 start"; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + const sptr dataObserver; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + dataAbilityHelperImpl->RegisterObserver(*uri, dataObserver); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0200 + * @tc.name: RegisterObserver + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0200 start"; + std::shared_ptr uri = std::make_shared("\nullptr"); + const sptr dataObserver; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + dataAbilityHelperImpl->RegisterObserver(*uri, dataObserver); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0300 + * @tc.name: RegisterObserver + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0300 start"; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + const sptr dataObserver = new (std::nothrow) MolDataAbilityObserver(); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + dataAbilityHelperImpl->uri_ = nullptr; + dataAbilityHelperImpl->RegisterObserver(*uri, dataObserver); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0300 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0400 + * @tc.name: RegisterObserver + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0400, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0400 start"; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + const sptr dataObserver = new (std::nothrow) MolDataAbilityObserver(); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + dataAbilityHelperImpl->uri_ = uri; + dataAbilityHelperImpl->RegisterObserver(*uri, dataObserver); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0400 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0500 + * @tc.name: RegisterObserver + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0500, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0500 start"; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + const sptr dataObserver = new (std::nothrow) MolDataAbilityObserver(); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + dataAbilityHelperImpl->uri_ = uri; + sptr dataAbilityProxy = dataAbilityHelperImpl->GetDataAbilityProxy(*uri); + dataAbilityHelperImpl->dataAbilityProxy_ = dataAbilityProxy; + dataAbilityHelperImpl->RegisterObserver(*uri, dataObserver); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_RegisterObserver_0500 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0100 + * @tc.name: UnregisterObserver + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0100 start"; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + const sptr dataObserver; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + dataAbilityHelperImpl->UnregisterObserver(*uri, dataObserver); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0100 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0200 + * @tc.name: UnregisterObserver + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0200, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0200 start"; + std::shared_ptr uri = std::make_shared("\nullptr"); + const sptr dataObserver; + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + dataAbilityHelperImpl->UnregisterObserver(*uri, dataObserver); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0200 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0300 + * @tc.name: UnregisterObserver + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0300, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0300 start"; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + const sptr dataObserver = new (std::nothrow) MolDataAbilityObserver(); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + dataAbilityHelperImpl->uri_ = nullptr; + dataAbilityHelperImpl->UnregisterObserver(*uri, dataObserver); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0300 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0400 + * @tc.name: UnregisterObserver + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0400, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0400 start"; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + const sptr dataObserver = new (std::nothrow) MolDataAbilityObserver(); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + dataAbilityHelperImpl->uri_ = uri; + dataAbilityHelperImpl->UnregisterObserver(*uri, dataObserver); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0400 end"; +} + +/** + * @tc.number: AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0500 + * @tc.name: UnregisterObserver + * @tc.desc: Simulate successful test cases + */ +HWTEST_F(DataAbilityHelperImplForObserverTest, + AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0500, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0500 start"; + std::shared_ptr uri = + std::make_shared("dataability://device_id/com.domainname.dataability.persondata/person/10"); + const sptr dataObserver = new (std::nothrow) MolDataAbilityObserver(); + sptr porxyNew = new (std::nothrow) AAFwk::MockAbilityManagerService(); + porxyNew->acquireDataAbility_ = new (std::nothrow) MockAbilitySchedulerStub(); + AbilityManagerClient::GetInstance()->proxy_ = porxyNew; + std::shared_ptr context = std::make_shared(); + std::shared_ptr dataAbilityHelperImpl = DataAbilityHelperImpl::Creator(context); + dataAbilityHelperImpl->uri_ = uri; + sptr dataAbilityProxy = dataAbilityHelperImpl->GetDataAbilityProxy(*uri); + dataAbilityHelperImpl->dataAbilityProxy_ = dataAbilityProxy; + dataAbilityHelperImpl->UnregisterObserver(*uri, dataObserver); + porxyNew->acquireDataAbility_ = nullptr; + GTEST_LOG_(INFO) << "AppExecFwk_DataAbilityHelperImpl_UnregisterObserver_0500 end"; +} +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file -- Gitee From 64e0fb7cfa5c5f83aec769fdcf973658ff49232f Mon Sep 17 00:00:00 2001 From: xinxin13 Date: Sat, 31 Dec 2022 14:33:05 +0800 Subject: [PATCH 2/2] fix tdd code build Signed-off-by: xinxin13 --- test/unittest/frameworks_kits_ability_native_test/BUILD.gn | 1 + 1 file changed, 1 insertion(+) diff --git a/test/unittest/frameworks_kits_ability_native_test/BUILD.gn b/test/unittest/frameworks_kits_ability_native_test/BUILD.gn index 5ac64080158..4c16e154f1d 100644 --- a/test/unittest/frameworks_kits_ability_native_test/BUILD.gn +++ b/test/unittest/frameworks_kits_ability_native_test/BUILD.gn @@ -1774,6 +1774,7 @@ group("unittest") { ":ability_transaction_callback_info_test", ":ability_window_test", ":continuation_test", + ":data_ability_helper_impl_test", ":data_ability_helper_test", ":data_ability_impl_file_secondpart_test", ":data_ability_impl_file_test", -- Gitee