From 70691d09adf48bddc2f499ba5c214b4115f8e98a Mon Sep 17 00:00:00 2001 From: yangxuguang-huawei Date: Sat, 14 Jun 2025 18:03:30 +0800 Subject: [PATCH] tdd: coverage Signed-off-by: yangxuguang-huawei --- .../include/utils/ability_permission_util.h | 2 +- .../src/utils/ability_permission_util.cpp | 10 +- .../ability_permission_util_test/BUILD.gn | 22 +- .../ability_permission_util_test.cpp | 789 ++++++++++++++++-- .../mock/include/ability_record.h | 84 ++ .../mock/include/ability_util.h | 97 +++ .../mock/include/app_mgr_interface.h | 44 + .../mock/include/app_mgr_stub.h | 40 + .../mock/include/app_mgr_util.h | 47 ++ .../mock/include/app_scheduler.h | 39 + .../mock/include/app_utils.h | 103 +++ .../mock/include/bundle_mgr_helper.h | 60 ++ .../mock/include/mock_app_mgr_impl.h | 47 ++ .../include/mock_permission_verification.h | 100 --- .../mock/include/multi_instance_utils.h | 98 +++ .../mock/include/permission_verification.h | 52 ++ .../mock/include/start_ability_utils.h | 37 + .../mock/src/ability_record.cpp | 59 ++ .../mock/src/app_scheduler.cpp | 31 + .../mock/src/mock_app_mgr_impl.cpp | 36 + .../mock/src/mock_permission_verification.cpp | 133 --- .../mock/src/permission_verification.cpp | 66 ++ 22 files changed, 1695 insertions(+), 301 deletions(-) create mode 100644 test/unittest/ability_permission_util_test/mock/include/ability_record.h create mode 100644 test/unittest/ability_permission_util_test/mock/include/ability_util.h create mode 100644 test/unittest/ability_permission_util_test/mock/include/app_mgr_interface.h create mode 100644 test/unittest/ability_permission_util_test/mock/include/app_mgr_stub.h create mode 100644 test/unittest/ability_permission_util_test/mock/include/app_mgr_util.h create mode 100644 test/unittest/ability_permission_util_test/mock/include/app_scheduler.h create mode 100644 test/unittest/ability_permission_util_test/mock/include/app_utils.h create mode 100644 test/unittest/ability_permission_util_test/mock/include/bundle_mgr_helper.h create mode 100644 test/unittest/ability_permission_util_test/mock/include/mock_app_mgr_impl.h delete mode 100644 test/unittest/ability_permission_util_test/mock/include/mock_permission_verification.h create mode 100644 test/unittest/ability_permission_util_test/mock/include/multi_instance_utils.h create mode 100644 test/unittest/ability_permission_util_test/mock/include/permission_verification.h create mode 100644 test/unittest/ability_permission_util_test/mock/include/start_ability_utils.h create mode 100644 test/unittest/ability_permission_util_test/mock/src/ability_record.cpp create mode 100644 test/unittest/ability_permission_util_test/mock/src/app_scheduler.cpp create mode 100644 test/unittest/ability_permission_util_test/mock/src/mock_app_mgr_impl.cpp delete mode 100644 test/unittest/ability_permission_util_test/mock/src/mock_permission_verification.cpp create mode 100644 test/unittest/ability_permission_util_test/mock/src/permission_verification.cpp diff --git a/services/abilitymgr/include/utils/ability_permission_util.h b/services/abilitymgr/include/utils/ability_permission_util.h index 1edb8a2cabe..1332fb39b97 100644 --- a/services/abilitymgr/include/utils/ability_permission_util.h +++ b/services/abilitymgr/include/utils/ability_permission_util.h @@ -111,7 +111,7 @@ public: bool IsStartSelfUIAbility(); - int32_t CheckPrepareTerminateEnable(const std::shared_ptr &abilityRecord); + int32_t CheckPrepareTerminateEnable(std::shared_ptr abilityRecord); private: /** diff --git a/services/abilitymgr/src/utils/ability_permission_util.cpp b/services/abilitymgr/src/utils/ability_permission_util.cpp index e27a1305ab3..fe194f33e88 100644 --- a/services/abilitymgr/src/utils/ability_permission_util.cpp +++ b/services/abilitymgr/src/utils/ability_permission_util.cpp @@ -15,8 +15,8 @@ #include "utils/ability_permission_util.h" -#include "ability_connect_manager.h" #include "ability_info.h" +#include "ability_manager_errors.h" #include "ability_util.h" #include "app_utils.h" #include "accesstoken_kit.h" @@ -85,7 +85,7 @@ bool AbilityPermissionUtil::IsDominateScreen(const Want &want, bool isPendingWan AppExecFwk::RunningProcessInfo processInfo; DelayedSingleton::GetInstance()->GetRunningProcessInfoByPid(callerPid, processInfo); bool isDelegatorCall = processInfo.isTestProcess && want.GetBoolParam(IS_DELEGATOR_CALL, false); - if (isDelegatorCall || InsightIntentExecuteParam::IsInsightIntentExecute(want)) { + if (isDelegatorCall || AppExecFwk::InsightIntentExecuteParam::IsInsightIntentExecute(want)) { TAG_LOGD(AAFwkTag::ABILITYMGR, "not dominate screen."); return false; } @@ -171,14 +171,14 @@ int32_t AbilityPermissionUtil::CheckMultiInstance(Want &want, sptr instanceKeyArray; auto result = IN_PROCESS_CALL(appMgr->GetAllRunningInstanceKeysByBundleName(want.GetBundle(), instanceKeyArray)); if (result != ERR_OK) { - TAG_LOGE(AAFwkTag::FREE_INSTALL, "Failed to get instance key"); + TAG_LOGE(AAFwkTag::ABILITYMGR, "Failed to get instance key"); return ERR_INVALID_VALUE; } // in-app launch @@ -363,7 +363,7 @@ bool AbilityPermissionUtil::IsStartSelfUIAbility() return PermissionVerification::GetInstance()->VerifyStartSelfUIAbility(tokenId); } -int32_t AbilityPermissionUtil::CheckPrepareTerminateEnable(const std::shared_ptr &abilityRecord) +int32_t AbilityPermissionUtil::CheckPrepareTerminateEnable(std::shared_ptr abilityRecord) { if (!AppUtils::GetInstance().IsPrepareTerminateEnabled()) { TAG_LOGE(AAFwkTag::ABILITYMGR, "prepare terminate not supported"); diff --git a/test/unittest/ability_permission_util_test/BUILD.gn b/test/unittest/ability_permission_util_test/BUILD.gn index c095171d094..18b48634047 100644 --- a/test/unittest/ability_permission_util_test/BUILD.gn +++ b/test/unittest/ability_permission_util_test/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2024 Huawei Device Co., Ltd. +# Copyright (c) 2024-2025 Huawei Device Co., Ltd. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -20,6 +20,7 @@ ohos_unittest("ability_permission_util_test") { module_out_path = module_output_path include_dirs = [ + "mock/include", "${ability_runtime_path}/interfaces/kits/native/ability/ability_runtime/", "${ability_runtime_path}/interfaces/inner_api/ability_manager/include", "${ability_runtime_test_path}/mock/ability_manager_collaborator", @@ -28,7 +29,6 @@ ohos_unittest("ability_permission_util_test") { "${ability_runtime_test_path}/mock/prepare_terminate_callback", "${ability_runtime_test_path}/mock/services_abilitymgr_test/libs/aakit/include", "${ability_runtime_test_path}/unittest/app_debug_listener_stub_test", - "mock/include", ] cflags = [ @@ -41,14 +41,19 @@ ohos_unittest("ability_permission_util_test") { configs = [ "${ability_runtime_services_path}/abilitymgr:abilityms_config" ] sources = [ + "${ability_runtime_services_path}/abilitymgr/src/ability_token_stub.cpp", + "${ability_runtime_services_path}/abilitymgr/src/utils/ability_permission_util.cpp", "ability_permission_util_test.cpp", + "mock/src/ability_record.cpp", + "mock/src/app_scheduler.cpp", + "mock/src/mock_app_mgr_impl.cpp", "mock/src/mock_my_flag.cpp", - "mock/src/mock_permission_verification.cpp", + "mock/src/permission_verification.cpp", ] deps = [ + "${ability_runtime_innerkits_path}/ability_manager:ability_manager", "${ability_runtime_innerkits_path}/app_manager:app_manager", - "${ability_runtime_services_path}/abilitymgr:abilityms", "${ability_runtime_services_path}/common:app_util", ] @@ -82,6 +87,15 @@ ohos_unittest("ability_permission_util_test") { "safwk:system_ability_fwk", "samgr:samgr_proxy", ] + + if (ability_runtime_graphics) { + defines = [ "SUPPORT_SCREEN" ] + external_deps += [ + "window_manager:libwsutils", + "window_manager:session_manager_lite", + ] + } + } group("unittest") { diff --git a/test/unittest/ability_permission_util_test/ability_permission_util_test.cpp b/test/unittest/ability_permission_util_test/ability_permission_util_test.cpp index 5a5c379644e..4cc77a0c1f8 100644 --- a/test/unittest/ability_permission_util_test/ability_permission_util_test.cpp +++ b/test/unittest/ability_permission_util_test/ability_permission_util_test.cpp @@ -14,22 +14,29 @@ */ #include +#include -#include "mock_permission_verification.h" #define private public #include "utils/ability_permission_util.h" +#undef private #include "ability_info.h" +#include "ability_manager_errors.h" #include "ability_record.h" #include "ability_util.h" #include "accesstoken_kit.h" #include "app_utils.h" +#include "app_mgr_util.h" +#include "bundle_mgr_helper.h" +#include "hilog_tag_wrapper.h" #include "ipc_skeleton.h" -#include "running_process_info.h" +#include "mock_app_mgr_impl.h" +#include "mock_my_flag.h" +#include "multi_instance_utils.h" #include "permission_constants.h" #include "permission_verification.h" -#undef private -#include "hilog_tag_wrapper.h" #include "parameters.h" +#include "running_process_info.h" +#include "start_ability_utils.h" using namespace testing; using namespace testing::ext; @@ -37,9 +44,44 @@ using namespace OHOS::AppExecFwk; using AbilityRequest = OHOS::AAFwk::AbilityRequest; using OHOS::AppExecFwk::AbilityType; using OHOS::AAFwk::AbilityPermissionUtil; +using OHOS::AppExecFwk::MockAppMgrImpl; namespace OHOS { +namespace AAFwk { +bool AppUtils::isAllowStartAbilityWithoutCallerToken = false; +bool AppUtils::isSupportMultiInstance = false; +bool AppUtils::isStartOptionsWithAnimation = false; +bool AppUtils::isPrepareTerminateEnabled = false; + +std::string MultiInstanceUtils::retInstanceKey; +bool MultiInstanceUtils::isMultiInstanceApp = false; +bool MultiInstanceUtils::isDefaultInstanceKey = false; +bool MultiInstanceUtils::isSupportedExtensionType = false; +bool MultiInstanceUtils::isInstanceKeyExist = false; + +bool StartAbilityUtils::retGetApplicationInfo = false; +AppExecFwk::ApplicationInfo StartAbilityUtils::retApplicationInfo; + +bool AppMgrUtil::isNullAppMgr = false; +sptr AppMgrUtil::mockAppMgr = sptr::MakeSptr(); +} // namespace AAFwk + +namespace AppExecFwk { +bool BundleMgrHelper::isNullBundleMgrInstance = false; +int32_t BundleMgrHelper::retGetNameForUid = 0; +BundleInfo BundleMgrHelper::retBundleInfo; +bool BundleMgrHelper::retGetBundleInfo = 0; +} // namespace AppExecFwk + namespace AbilityRuntime { +using namespace AAFwk; + +namespace { +constexpr const char* IS_DELEGATOR_CALL = "isDelegatorCall"; +constexpr const char* SETTINGS = "settings"; +constexpr char INSIGHT_INTENT_EXECUTE_PARAM_NAME[] = "ohos.insightIntent.executeParam.name"; +} // namespace + class AbilityPermissionUtilTest : public testing::Test { public: static void SetUpTestCase(); @@ -48,7 +90,21 @@ public: void TearDown() override; }; -void AbilityPermissionUtilTest::SetUpTestCase(void) {} +void AbilityPermissionUtilTest::SetUpTestCase(void) +{ + MyFlag::flag_ = 0; + AppUtils::isAllowStartAbilityWithoutCallerToken = false; + BundleMgrHelper::isNullBundleMgrInstance = false; + BundleMgrHelper::retGetNameForUid = 0; + BundleMgrHelper::retGetBundleInfo = 0; + AppUtils::isStartOptionsWithAnimation = false; + MultiInstanceUtils::isMultiInstanceApp = false; + MultiInstanceUtils::isDefaultInstanceKey = false; + MultiInstanceUtils::isSupportedExtensionType = false; + MultiInstanceUtils::isInstanceKeyExist = false; + AppMgrUtil::isNullAppMgr = false; +} + void AbilityPermissionUtilTest::TearDownTestCase(void) {} void AbilityPermissionUtilTest::SetUp() {} void AbilityPermissionUtilTest::TearDown() {} @@ -78,19 +134,12 @@ HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstanceAndA HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0200, TestSize.Level1) { TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0200 start"); + AppUtils::isSupportMultiInstance = false; Want want; std::string instanceKey = "app_instance_0"; want.SetParam(Want::APP_INSTANCE_KEY, instanceKey); auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstanceAndAppClone(want, 100, 0, nullptr); - - bool isSupportMultiInstance = AppUtils::GetInstance().IsSupportMultiInstance(); - std::string deviceType = OHOS::system::GetDeviceType(); - TAG_LOGI(AAFwkTag::TEST, "current deviceType is %{public}s", deviceType.c_str()); - if (deviceType == "2in1") { - EXPECT_EQ(result, ERR_OK); - } else { - EXPECT_EQ(result, ERR_MULTI_INSTANCE_NOT_SUPPORTED); - } + EXPECT_EQ(result, ERR_MULTI_INSTANCE_NOT_SUPPORTED); TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0200 end"); } @@ -104,22 +153,114 @@ HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstanceAndA HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0300, TestSize.Level1) { TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0300 start"); + AppUtils::isSupportMultiInstance = false; Want want; want.SetParam(Want::CREATE_APP_INSTANCE_KEY, true); auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstanceAndAppClone(want, 100, 0, nullptr); - - bool isSupportMultiInstance = AppUtils::GetInstance().IsSupportMultiInstance(); - std::string deviceType = OHOS::system::GetDeviceType(); - TAG_LOGI(AAFwkTag::TEST, "current deviceType is %{public}s", deviceType.c_str()); - if (deviceType == "2in1") { - EXPECT_EQ(result, ERR_OK); - } else { - EXPECT_EQ(result, ERR_MULTI_INSTANCE_NOT_SUPPORTED); - } + EXPECT_EQ(result, ERR_MULTI_INSTANCE_NOT_SUPPORTED); TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0300 end"); } +/** + * @tc.name: AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0400 + * @tc.desc: CheckMultiInstanceAndAppClone + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0400, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0400 start"); + AppUtils::isSupportMultiInstance = true; + StartAbilityUtils::retGetApplicationInfo = false; + Want want; + want.SetParam(Want::CREATE_APP_INSTANCE_KEY, true); + auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstanceAndAppClone(want, 100, 0, nullptr); + EXPECT_EQ(result, ERR_OK); + + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0400 end"); +} + +/** + * @tc.name: AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0500 + * @tc.desc: CheckMultiInstanceAndAppClone + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0500, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0500 start"); + AppUtils::isSupportMultiInstance = true; + StartAbilityUtils::retGetApplicationInfo = true; + StartAbilityUtils::retApplicationInfo.multiAppMode.multiAppModeType = AppExecFwk::MultiAppModeType::UNSPECIFIED; + Want want; + want.SetParam(Want::CREATE_APP_INSTANCE_KEY, true); + auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstanceAndAppClone(want, 100, 0, nullptr); + EXPECT_EQ(result, ERR_MULTI_APP_NOT_SUPPORTED); + + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0500 end"); +} + +/** + * @tc.name: AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0600 + * @tc.desc: CheckMultiInstanceAndAppClone + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0600, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0600 start"); + AppUtils::isSupportMultiInstance = true; + StartAbilityUtils::retGetApplicationInfo = true; + StartAbilityUtils::retApplicationInfo.multiAppMode.multiAppModeType = AppExecFwk::MultiAppModeType::UNSPECIFIED; + Want want; + auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstanceAndAppClone(want, 100, 1, nullptr); + EXPECT_EQ(result, ERR_MULTI_APP_NOT_SUPPORTED); + + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0600 end"); +} + +/** + * @tc.name: AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0700 + * @tc.desc: CheckMultiInstanceAndAppClone + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0700, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0700 start"); + AppUtils::isSupportMultiInstance = true; + StartAbilityUtils::retGetApplicationInfo = true; + StartAbilityUtils::retApplicationInfo.multiAppMode.multiAppModeType = AppExecFwk::MultiAppModeType::MULTI_INSTANCE; + Want want; + auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstanceAndAppClone(want, 100, 1, nullptr); + EXPECT_EQ(result, ERR_NOT_SUPPORT_APP_CLONE); + + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0700 end"); +} + +/** + * @tc.name: AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0800 + * @tc.desc: CheckMultiInstanceAndAppClone + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0800, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0800 start"); + AppUtils::isSupportMultiInstance = true; + StartAbilityUtils::retGetApplicationInfo = true; + int32_t maxCount = 5; + StartAbilityUtils::retApplicationInfo.multiAppMode.multiAppModeType = AppExecFwk::MultiAppModeType::MULTI_INSTANCE; + StartAbilityUtils::retApplicationInfo.multiAppMode.maxCount = maxCount; + Want want; + want.SetParam(Want::CREATE_APP_INSTANCE_KEY, true); + auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstanceAndAppClone(want, 100, 0, nullptr); + EXPECT_EQ(result, AbilityPermissionUtil::GetInstance().CheckMultiInstance(want, nullptr, true, "", maxCount)); + + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceAndAppClone_0800 end"); +} + /** * @tc.name: AbilityPermissionUtil_CheckMultiInstance_0100 * @tc.desc: CheckMultiInstance @@ -130,6 +271,7 @@ HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstance_010 { TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0100 start"); + AppMgrUtil::isNullAppMgr = true; Want want; auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstance(want, nullptr, true, "", 0); EXPECT_EQ(result, ERR_INVALID_VALUE); @@ -146,16 +288,9 @@ HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstance_020 { TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0200 start"); - std::string bundleName = "com.ohos.test"; + MockAppMgrImpl::retGetAllRunningInstanceKeysByBundleName = -1; Want want; - want.SetBundle(bundleName); - OHOS::AppExecFwk::AbilityInfo abilityInfo; - abilityInfo.bundleName = bundleName; - OHOS::AppExecFwk::ApplicationInfo applicationInfo; - auto abilityRecord = std::make_shared(want, abilityInfo, applicationInfo); - auto isInitial = abilityRecord->Init(); - EXPECT_TRUE(isInitial); - auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstance(want, abilityRecord->GetToken(), true, "", 1); + auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstance(want, nullptr, true, "", 0); EXPECT_EQ(result, ERR_INVALID_VALUE); TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0200 end"); } @@ -170,19 +305,20 @@ HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstance_030 { TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0300 start"); + AppMgrUtil::isNullAppMgr = false; + MockAppMgrImpl::retGetAllRunningInstanceKeysByBundleName = 0; + sptr callerToken = sptr::MakeSptr(); std::string bundleName = "com.ohos.test"; + std::shared_ptr abilityRecord = std::make_shared(); + abilityRecord->abilityInfo.bundleName = bundleName; + Token::abilityRecord = abilityRecord; + Want want; want.SetBundle(bundleName); - OHOS::AppExecFwk::AbilityInfo abilityInfo; - abilityInfo.bundleName = bundleName; - OHOS::AppExecFwk::ApplicationInfo applicationInfo; - auto abilityRecord = std::make_shared(want, abilityInfo, applicationInfo); - auto isInitial = abilityRecord->Init(); - EXPECT_TRUE(isInitial); std::string instanceKey = "app_instance_0"; - auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstance(want, abilityRecord->GetToken(), true, - instanceKey, 1); - EXPECT_EQ(result, ERR_INVALID_VALUE); + want.SetParam(Want::APP_INSTANCE_KEY, instanceKey); + auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstance(want, callerToken, true, instanceKey, 1); + EXPECT_EQ(result, ERR_APP_INSTANCE_KEY_NOT_SUPPORT); TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0300 end"); } @@ -196,20 +332,164 @@ HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstance_040 { TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0400 start"); + AppMgrUtil::isNullAppMgr = false; + MockAppMgrImpl::retGetAllRunningInstanceKeysByBundleName = 0; + sptr callerToken = sptr::MakeSptr(); std::string bundleName = "com.ohos.test"; + std::shared_ptr abilityRecord = std::make_shared(); + abilityRecord->abilityInfo.bundleName = bundleName; + Token::abilityRecord = abilityRecord; + MockAppMgrImpl::retInstanceKeys = { "app_instance_0" }; + Want want; want.SetBundle(bundleName); - OHOS::AppExecFwk::AbilityInfo abilityInfo; - abilityInfo.bundleName = bundleName; - OHOS::AppExecFwk::ApplicationInfo applicationInfo; - auto abilityRecord = std::make_shared(want, abilityInfo, applicationInfo); - auto isInitial = abilityRecord->Init(); - EXPECT_TRUE(isInitial); - auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstance(want, abilityRecord->GetToken(), true, "", 0); - EXPECT_EQ(result, ERR_INVALID_VALUE); + auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstance(want, callerToken, true, "", 1); + EXPECT_EQ(result, ERR_UPPER_LIMIT); TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0400 end"); } +/** + * @tc.name: AbilityPermissionUtil_CheckMultiInstance_0500 + * @tc.desc: CheckMultiInstance + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstance_0500, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0500 start"); + + AppMgrUtil::isNullAppMgr = false; + MockAppMgrImpl::retGetAllRunningInstanceKeysByBundleName = 0; + sptr callerToken = sptr::MakeSptr(); + std::string bundleName = "com.ohos.test"; + std::shared_ptr abilityRecord = std::make_shared(); + abilityRecord->abilityInfo.bundleName = bundleName; + Token::abilityRecord = abilityRecord; + MockAppMgrImpl::retInstanceKeys = { "app_instance_0" }; + + Want want; + want.SetBundle(bundleName); + auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstance(want, callerToken, true, "", 2); + EXPECT_EQ(result, ERR_OK); + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0500 end"); +} + +/** + * @tc.name: AbilityPermissionUtil_CheckMultiInstance_0600 + * @tc.desc: CheckMultiInstance + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstance_0600, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0600 start"); + + AppMgrUtil::isNullAppMgr = false; + MockAppMgrImpl::retGetAllRunningInstanceKeysByBundleName = 0; + sptr callerToken = sptr::MakeSptr(); + std::string bundleName = "com.ohos.test"; + std::string instanceKey = "app_instance_0"; + std::shared_ptr abilityRecord = std::make_shared(); + abilityRecord->abilityInfo.bundleName = bundleName; + abilityRecord->instanceKey = instanceKey; + Token::abilityRecord = abilityRecord; + std::vector instanceKeys = { instanceKey }; + MockAppMgrImpl::retInstanceKeys = instanceKeys; + + Want want; + want.SetBundle("com.ohos.diff"); + auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstance(want, callerToken, false, instanceKey, 1); + EXPECT_EQ(result, AbilityPermissionUtil::GetInstance().UpdateInstanceKey( + want, instanceKey, instanceKeys, instanceKey)); + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0600 end"); +} + +/** + * @tc.name: AbilityPermissionUtil_CheckMultiInstance_0700 + * @tc.desc: CheckMultiInstance + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstance_0700, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0700 start"); + + AppMgrUtil::isNullAppMgr = false; + MockAppMgrImpl::retGetAllRunningInstanceKeysByBundleName = 0; + sptr callerToken = nullptr; + std::string bundleName = "com.ohos.test"; + std::string instanceKey = "app_instance_0"; + Token::abilityRecord = nullptr; + std::vector instanceKeys = { instanceKey }; + MockAppMgrImpl::retInstanceKeys = instanceKeys; + AppUtils::isStartOptionsWithAnimation = true; + AbilityPermissionUtil instance; + instance.startSelfUIAbilityRecords_.push_back({getprocpid(), 1000, 1}); + PermissionVerification::retVerifyStartSelfUIAbility = true; + + Want want; + want.SetBundle(bundleName); + auto result = instance.CheckMultiInstance(want, callerToken, false, instanceKey, 1); + EXPECT_EQ(result, instance.UpdateInstanceKey( + want, instanceKey, instanceKeys, instanceKey)); + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0700 end"); +} + +/** + * @tc.name: AbilityPermissionUtil_CheckMultiInstance_0800 + * @tc.desc: CheckMultiInstance + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstance_0800, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0800 start"); + + AppMgrUtil::isNullAppMgr = false; + MockAppMgrImpl::retGetAllRunningInstanceKeysByBundleName = 0; + sptr callerToken = nullptr; + std::string bundleName = "com.ohos.test"; + std::string instanceKey = "app_instance_0"; + Token::abilityRecord = nullptr; + std::vector instanceKeys = { instanceKey }; + MockAppMgrImpl::retInstanceKeys = instanceKeys; + AppUtils::isStartOptionsWithAnimation = false; + + Want want; + want.SetBundle(bundleName); + auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstance(want, callerToken, true, instanceKey, 1); + EXPECT_EQ(result, ERR_CREATE_NEW_INSTANCE_NOT_SUPPORT); + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0800 end"); +} + +/** + * @tc.name: AbilityPermissionUtil_CheckMultiInstance_0900 + * @tc.desc: CheckMultiInstance + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstance_0900, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0900 start"); + + AppMgrUtil::isNullAppMgr = false; + MockAppMgrImpl::retGetAllRunningInstanceKeysByBundleName = 0; + sptr callerToken = nullptr; + std::string bundleName = "com.ohos.test"; + std::string instanceKey = "app_instance_0"; + Token::abilityRecord = nullptr; + std::vector instanceKeys = { instanceKey }; + MockAppMgrImpl::retInstanceKeys = instanceKeys; + AppUtils::isStartOptionsWithAnimation = false; + + Want want; + want.SetBundle(bundleName); + auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstance(want, callerToken, false, instanceKey, 1); + EXPECT_EQ(result, AbilityPermissionUtil::GetInstance().UpdateInstanceKey( + want, instanceKey, instanceKeys, instanceKey)); + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstance_0900 end"); +} + /** * @tc.name: AbilityPermissionUtil_UpdateInstanceKey_0100 * @tc.desc: UpdateInstanceKey @@ -290,8 +570,9 @@ HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstanceKeyF { TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0200 start"); + AppUtils::isSupportMultiInstance = false; + MultiInstanceUtils::retInstanceKey = "app_instance_0"; AbilityRequest abilityRequest; - abilityRequest.want.SetParam(Want::APP_INSTANCE_KEY, std::string("app_instance_0")); auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstanceKeyForExtension(abilityRequest); EXPECT_EQ(result, ERR_CAPABILITY_NOT_SUPPORT); TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0200 end"); @@ -307,15 +588,100 @@ HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstanceKeyF { TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0300 start"); + AppUtils::isSupportMultiInstance = true; + MultiInstanceUtils::isMultiInstanceApp = false; + MultiInstanceUtils::retInstanceKey = "app_instance_0"; AbilityRequest abilityRequest; - abilityRequest.want.SetParam(Want::APP_INSTANCE_KEY, std::string("app_instance_0")); - (void)AppUtils::GetInstance().IsSupportMultiInstance(); - AppUtils::GetInstance().isSupportMultiInstance_.value = true; auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstanceKeyForExtension(abilityRequest); EXPECT_EQ(result, ERR_MULTI_INSTANCE_NOT_SUPPORTED); TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0300 end"); } +/** + * @tc.name: AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0400 + * @tc.desc: CheckMultiInstanceKeyForExtension + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0400, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0400 start"); + + MultiInstanceUtils::retInstanceKey = "app_instance_0"; + AppUtils::isSupportMultiInstance = true; + MultiInstanceUtils::isMultiInstanceApp = true; + MultiInstanceUtils::isDefaultInstanceKey = true; + AbilityRequest abilityRequest; + auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstanceKeyForExtension(abilityRequest); + EXPECT_EQ(result, ERR_OK); + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0400 end"); +} + +/** + * @tc.name: AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0500 + * @tc.desc: CheckMultiInstanceKeyForExtension + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0500, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0500 start"); + + MultiInstanceUtils::retInstanceKey = "app_instance_0"; + AppUtils::isSupportMultiInstance = true; + MultiInstanceUtils::isMultiInstanceApp = true; + MultiInstanceUtils::isDefaultInstanceKey = false; + MultiInstanceUtils::isSupportedExtensionType = false; + AbilityRequest abilityRequest; + auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstanceKeyForExtension(abilityRequest); + EXPECT_EQ(result, ERR_INVALID_EXTENSION_TYPE); + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0500 end"); +} + +/** + * @tc.name: AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0600 + * @tc.desc: CheckMultiInstanceKeyForExtension + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0600, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0600 start"); + + MultiInstanceUtils::retInstanceKey = "app_instance_0"; + AppUtils::isSupportMultiInstance = true; + MultiInstanceUtils::isMultiInstanceApp = true; + MultiInstanceUtils::isDefaultInstanceKey = false; + MultiInstanceUtils::isSupportedExtensionType = true; + MultiInstanceUtils::isInstanceKeyExist = false; + AbilityRequest abilityRequest; + auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstanceKeyForExtension(abilityRequest); + EXPECT_EQ(result, ERR_INVALID_APP_INSTANCE_KEY); + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0600 end"); +} + +/** + * @tc.name: AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0700 + * @tc.desc: CheckMultiInstanceKeyForExtension + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0700, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0700 start"); + + MultiInstanceUtils::retInstanceKey = "app_instance_0"; + AppUtils::isSupportMultiInstance = true; + MultiInstanceUtils::isMultiInstanceApp = true; + MultiInstanceUtils::isDefaultInstanceKey = false; + MultiInstanceUtils::isSupportedExtensionType = true; + MultiInstanceUtils::isInstanceKeyExist = true; + AbilityRequest abilityRequest; + auto result = AbilityPermissionUtil::GetInstance().CheckMultiInstanceKeyForExtension(abilityRequest); + EXPECT_EQ(result, ERR_OK); + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil_CheckMultiInstanceKeyForExtension_0700 end"); +} + /** * @tc.name: IsDominateScreen_0100 * @tc.desc: IsDominateScreen_0100 Test @@ -406,6 +772,177 @@ HWTEST_F(AbilityPermissionUtilTest, IsDominateScreen_0500, TestSize.Level2) TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil IsDominateScreen_0500 end"); } +/** + * @tc.name: IsDominateScreen_0600 + * @tc.desc: IsDominateScreen_0600 Test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, IsDominateScreen_0600, TestSize.Level2) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil IsDominateScreen_0600 start"); + + AppUtils::isAllowStartAbilityWithoutCallerToken = true; + Want want; + bool isPendingWantCaller = false; + bool ret = AbilityPermissionUtil::GetInstance().IsDominateScreen(want, isPendingWantCaller); + EXPECT_FALSE(ret); + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil IsDominateScreen_0600 end"); +} + +/** + * @tc.name: IsDominateScreen_0700 + * @tc.desc: IsDominateScreen_0700 Test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, IsDominateScreen_0700, TestSize.Level2) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil IsDominateScreen_0700 start"); + + Want want; + want.SetParam(IS_DELEGATOR_CALL, true); + bool isPendingWantCaller = false; + bool ret = AbilityPermissionUtil::GetInstance().IsDominateScreen(want, isPendingWantCaller); + EXPECT_FALSE(ret); + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil IsDominateScreen_0700 end"); +} + +/** + * @tc.name: IsDominateScreen_0800 + * @tc.desc: IsDominateScreen_0800 Test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, IsDominateScreen_0800, TestSize.Level2) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil IsDominateScreen_0800 start"); + + Want want; + want.SetParam(INSIGHT_INTENT_EXECUTE_PARAM_NAME, true); + bool isPendingWantCaller = false; + bool ret = AbilityPermissionUtil::GetInstance().IsDominateScreen(want, isPendingWantCaller); + EXPECT_FALSE(ret); + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil IsDominateScreen_0800 end"); +} + +/** + * @tc.name: IsDominateScreen_0900 + * @tc.desc: IsDominateScreen_0900 Test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, IsDominateScreen_0900, TestSize.Level2) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil IsDominateScreen_0900 start"); + + AppUtils::isAllowStartAbilityWithoutCallerToken = true; + BundleMgrHelper::isNullBundleMgrInstance = true; + Want want; + want.SetElementName(SETTINGS, SETTINGS); + bool isPendingWantCaller = false; + bool ret = AbilityPermissionUtil::GetInstance().IsDominateScreen(want, isPendingWantCaller); + EXPECT_FALSE(ret); + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil IsDominateScreen_0900 end"); +} + +/** + * @tc.name: IsDominateScreen_1000 + * @tc.desc: IsDominateScreen_1000 Test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, IsDominateScreen_1000, TestSize.Level2) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil IsDominateScreen_1000 start"); + + AppUtils::isAllowStartAbilityWithoutCallerToken = true; + BundleMgrHelper::retGetNameForUid = -1; + Want want; + want.SetElementName(SETTINGS, SETTINGS); + bool isPendingWantCaller = false; + bool ret = AbilityPermissionUtil::GetInstance().IsDominateScreen(want, isPendingWantCaller); + EXPECT_FALSE(ret); + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil IsDominateScreen_1000 end"); +} + +/** + * @tc.name: IsDominateScreen_1100 + * @tc.desc: IsDominateScreen_1100 Test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, IsDominateScreen_1100, TestSize.Level2) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil IsDominateScreen_1100 start"); + + AppUtils::isAllowStartAbilityWithoutCallerToken = true; + BundleMgrHelper::retBundleInfo.applicationInfo.needAppDetail = true; + Want want; + want.SetElementName(SETTINGS, SETTINGS); + bool isPendingWantCaller = false; + bool ret = AbilityPermissionUtil::GetInstance().IsDominateScreen(want, isPendingWantCaller); + EXPECT_FALSE(ret); + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil IsDominateScreen_1100 end"); +} + +/** + * @tc.name: IsDominateScreen_1200 + * @tc.desc: IsDominateScreen_1200 Test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, IsDominateScreen_1200, TestSize.Level2) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil IsDominateScreen_1200 start"); + + AppUtils::isStartOptionsWithAnimation = true; + PermissionVerification::retVerifyStartSelfUIAbility = true; + Want want; + bool isPendingWantCaller = false; + bool ret = AbilityPermissionUtil::GetInstance().IsDominateScreen(want, isPendingWantCaller); + EXPECT_FALSE(ret); + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil IsDominateScreen_1200 end"); +} + +/** + * @tc.name: IsDominateScreen_1300 + * @tc.desc: IsDominateScreen_1300 Test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, IsDominateScreen_1300, TestSize.Level2) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil IsDominateScreen_1300 start"); + + AppUtils::isStartOptionsWithAnimation = false; + Want want; + bool isPendingWantCaller = false; + bool ret = AbilityPermissionUtil::GetInstance().IsDominateScreen(want, isPendingWantCaller); + EXPECT_FALSE(ret); + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil IsDominateScreen_1300 end"); +} + +/** + * @tc.name: IsDominateScreen_1400 + * @tc.desc: IsDominateScreen_1400 Test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, IsDominateScreen_1400, TestSize.Level2) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil IsDominateScreen_1400 start"); + + AppUtils::isAllowStartAbilityWithoutCallerToken = true; + BundleMgrHelper::retGetBundleInfo = -1; + Want want; + want.SetElementName(SETTINGS, SETTINGS); + bool isPendingWantCaller = false; + bool ret = AbilityPermissionUtil::GetInstance().IsDominateScreen(want, isPendingWantCaller); + EXPECT_FALSE(ret); + TAG_LOGI(AAFwkTag::TEST, "AbilityPermissionUtil IsDominateScreen_1400 end"); +} + /** * @tc.name: StartSelfUIAbilityRecordGuard_0100 * @tc.desc: StartSelfUIAbilityRecordGuard_0100 Test @@ -427,6 +964,26 @@ HWTEST_F(AbilityPermissionUtilTest, StartSelfUIAbilityRecordGuard_0100, TestSize } } +/** + * @tc.name: AddStartSelfUIAbilityRecord_0100 + * @tc.desc: AddStartSelfUIAbilityRecord_0100 Test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, AddStartSelfUIAbilityRecord_0100, TestSize.Level2) +{ + pid_t pid = 8888; + int32_t tokenId = 1000; + + AbilityPermissionUtil instance; + EXPECT_TRUE(instance.startSelfUIAbilityRecords_.empty()); + instance.startSelfUIAbilityRecords_.push_back({pid, tokenId, 1}); + EXPECT_FALSE(instance.startSelfUIAbilityRecords_.empty()); + + instance.AddStartSelfUIAbilityRecord(pid, tokenId); + EXPECT_EQ(instance.startSelfUIAbilityRecords_[0][2], 2); +} + /** * @tc.name: RemoveStartSelfUIAbilityRecord_0100 * @tc.desc: RemoveStartSelfUIAbilityRecord_0100 Test @@ -434,6 +991,26 @@ HWTEST_F(AbilityPermissionUtilTest, StartSelfUIAbilityRecordGuard_0100, TestSize * @tc.require: NA */ HWTEST_F(AbilityPermissionUtilTest, RemoveStartSelfUIAbilityRecord_0100, TestSize.Level2) +{ + pid_t pid = 8888; + int32_t tokenId = 1000; + + AbilityPermissionUtil instance; + EXPECT_TRUE(instance.startSelfUIAbilityRecords_.empty()); + instance.startSelfUIAbilityRecords_.push_back({pid, tokenId, 1}); + EXPECT_FALSE(instance.startSelfUIAbilityRecords_.empty()); + + instance.RemoveStartSelfUIAbilityRecord(pid); + EXPECT_TRUE(instance.startSelfUIAbilityRecords_.empty()); +} + +/** + * @tc.name: RemoveStartSelfUIAbilityRecord_0200 + * @tc.desc: RemoveStartSelfUIAbilityRecord_0200 Test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, RemoveStartSelfUIAbilityRecord_0200, TestSize.Level2) { pid_t pid = 8888; AbilityPermissionUtil::GetInstance().startSelfUIAbilityRecords_.clear(); @@ -478,15 +1055,23 @@ HWTEST_F(AbilityPermissionUtilTest, GetTokenIdByPid_0100, TestSize.Level2) */ HWTEST_F(AbilityPermissionUtilTest, IsStartSelfUIAbility_0100, TestSize.Level2) { - AAFwk::AppUtils::GetInstance().isStartOptionsWithAnimation_.isLoaded = true; - AAFwk::AppUtils::GetInstance().isStartOptionsWithAnimation_.value = false; - + AppUtils::isStartOptionsWithAnimation = false; auto ret = AbilityPermissionUtil::GetInstance().IsStartSelfUIAbility(); EXPECT_EQ(ret, false); - AAFwk::AppUtils::GetInstance().isStartOptionsWithAnimation_.value = true; + AppUtils::isStartOptionsWithAnimation = true; ret = AbilityPermissionUtil::GetInstance().IsStartSelfUIAbility(); EXPECT_EQ(ret, false); + + AbilityPermissionUtil instance; + instance.startSelfUIAbilityRecords_.push_back({getprocpid(), 1000, 1}); + PermissionVerification::retVerifyStartSelfUIAbility = false; + ret = instance.IsStartSelfUIAbility(); + EXPECT_EQ(ret, false); + + PermissionVerification::retVerifyStartSelfUIAbility = true; + ret = instance.IsStartSelfUIAbility(); + EXPECT_EQ(ret, true); } /** @@ -499,7 +1084,7 @@ HWTEST_F(AbilityPermissionUtilTest, CheckStartRecentAbility_0100, TestSize.Level { Want want; AbilityRequest request; - want.SetParam(Want::PARAM_RESV_START_RECENT, true); + want.SetParam(Want::PARAM_RESV_START_RECENT, false); auto ret = AbilityPermissionUtil::GetInstance().CheckStartRecentAbility(want, request); EXPECT_EQ(ret, ERR_OK); } @@ -518,5 +1103,93 @@ HWTEST_F(AbilityPermissionUtilTest, CheckStartRecentAbility_0200, TestSize.Level auto ret = AbilityPermissionUtil::GetInstance().CheckStartRecentAbility(want, request); EXPECT_EQ(ret, ERR_OK); } + +/** + * @tc.name: CheckPrepareTerminateEnable_0100 + * @tc.desc: CheckPrepareTerminateEnable_0100 Test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, CheckPrepareTerminateEnable_0100, TestSize.Level1) +{ + AppUtils::isPrepareTerminateEnabled = false; + auto ret = AbilityPermissionUtil::GetInstance().CheckPrepareTerminateEnable(nullptr); + EXPECT_EQ(ret, ERR_INVALID_VALUE); +} + +/** + * @tc.name: CheckPrepareTerminateEnable_0200 + * @tc.desc: CheckPrepareTerminateEnable_0200 Test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, CheckPrepareTerminateEnable_0200, TestSize.Level1) +{ + AppUtils::isPrepareTerminateEnabled = true; + auto ret = AbilityPermissionUtil::GetInstance().CheckPrepareTerminateEnable(nullptr); + EXPECT_EQ(ret, ERR_INVALID_VALUE); + + std::shared_ptr abilityRecord = std::make_shared(); + abilityRecord->isTerminating = true; + ret = AbilityPermissionUtil::GetInstance().CheckPrepareTerminateEnable(abilityRecord); + EXPECT_EQ(ret, ERR_INVALID_VALUE); +} + +/** + * @tc.name: CheckPrepareTerminateEnable_0300 + * @tc.desc: CheckPrepareTerminateEnable_0300 Test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, CheckPrepareTerminateEnable_0300, TestSize.Level1) +{ + AppUtils::isPrepareTerminateEnabled = true; + std::shared_ptr abilityRecord = std::make_shared(); + abilityRecord->isTerminating = false; + abilityRecord->abilityInfo.isStageBasedModel = false; + auto ret = AbilityPermissionUtil::GetInstance().CheckPrepareTerminateEnable(abilityRecord); + EXPECT_EQ(ret, RESOLVE_CALL_ABILITY_TYPE_ERR); + + abilityRecord->abilityInfo.isStageBasedModel = true; + abilityRecord->abilityInfo.type = AppExecFwk::AbilityType::UNKNOWN; + ret = AbilityPermissionUtil::GetInstance().CheckPrepareTerminateEnable(abilityRecord); + EXPECT_EQ(ret, RESOLVE_CALL_ABILITY_TYPE_ERR); +} + +/** + * @tc.name: CheckPrepareTerminateEnable_0400 + * @tc.desc: CheckPrepareTerminateEnable_0400 Test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, CheckPrepareTerminateEnable_0400, TestSize.Level1) +{ + AppUtils::isPrepareTerminateEnabled = true; + std::shared_ptr abilityRecord = std::make_shared(); + abilityRecord->isTerminating = false; + abilityRecord->abilityInfo.isStageBasedModel = true; + abilityRecord->abilityInfo.type = AppExecFwk::AbilityType::PAGE; + PermissionVerification::retVerifyPrepareTerminatePermission = false; + auto ret = AbilityPermissionUtil::GetInstance().CheckPrepareTerminateEnable(abilityRecord); + EXPECT_EQ(ret, ERR_INVALID_VALUE); +} + +/** + * @tc.name: CheckPrepareTerminateEnable_0500 + * @tc.desc: CheckPrepareTerminateEnable_0500 Test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(AbilityPermissionUtilTest, CheckPrepareTerminateEnable_0500, TestSize.Level1) +{ + AppUtils::isPrepareTerminateEnabled = true; + std::shared_ptr abilityRecord = std::make_shared(); + abilityRecord->isTerminating = false; + abilityRecord->abilityInfo.isStageBasedModel = true; + abilityRecord->abilityInfo.type = AppExecFwk::AbilityType::PAGE; + PermissionVerification::retVerifyPrepareTerminatePermission = true; + auto ret = AbilityPermissionUtil::GetInstance().CheckPrepareTerminateEnable(abilityRecord); + EXPECT_EQ(ret, ERR_OK); +} } // namespace AAFwk } // namespace OHOS diff --git a/test/unittest/ability_permission_util_test/mock/include/ability_record.h b/test/unittest/ability_permission_util_test/mock/include/ability_record.h new file mode 100644 index 00000000000..e8ad9020e92 --- /dev/null +++ b/test/unittest/ability_permission_util_test/mock/include/ability_record.h @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ABILITY_RUNTIME_ABILITY_RECORD_H +#define OHOS_ABILITY_RUNTIME_ABILITY_RECORD_H + +#include + +#include "ability_info.h" +#include "ability_token_stub.h" +#include "ipc_skeleton.h" + +namespace OHOS { +namespace AAFwk { +class AbilityRecord; + +/** + * @class Token + * Token is identification of ability and used to interact with kit and wms. + */ +class Token : public AbilityTokenStub { +public: + Token(); + virtual ~Token(); + + static std::shared_ptr GetAbilityRecordByToken(sptr token); + +public: + static std::shared_ptr abilityRecord; +}; + + +/** + * @class AbilityRecord + * AbilityRecord records ability info and states and used to schedule ability life. + */ +class AbilityRecord : public std::enable_shared_from_this { +public: + AbilityRecord(); + + ~AbilityRecord(); + + /** + * get ability's info. + * + * @return ability info. + */ + const AppExecFwk::AbilityInfo &GetAbilityInfo() const; + + std::string GetInstanceKey(); + + bool IsTerminating(); + + const AppExecFwk::ApplicationInfo &GetApplicationInfo() const; + +public: + AppExecFwk::AbilityInfo abilityInfo; + AppExecFwk::ApplicationInfo appInfo; + std::string instanceKey; + bool isTerminating = false; +}; + +struct AbilityRequest { + Want want; + sptr callerToken; + AppExecFwk::AbilityInfo abilityInfo; + AppExecFwk::ApplicationInfo appInfo; + bool startRecent = false; +}; +} // namespace AAFwk +} // namespace OHOS +#endif // OHOS_ABILITY_RUNTIME_ABILITY_RECORD_H diff --git a/test/unittest/ability_permission_util_test/mock/include/ability_util.h b/test/unittest/ability_permission_util_test/mock/include/ability_util.h new file mode 100644 index 00000000000..fc9dc5112e6 --- /dev/null +++ b/test/unittest/ability_permission_util_test/mock/include/ability_util.h @@ -0,0 +1,97 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ABILITY_RUNTIME_ABILITY_UTIL_H +#define OHOS_ABILITY_RUNTIME_ABILITY_UTIL_H + +#include "ability_record.h" +#include "app_mgr_util.h" +#include "app_scheduler.h" +#include "bundle_mgr_helper.h" +#include "hilog_tag_wrapper.h" +#include "in_process_call_wrapper.h" + +namespace OHOS { +namespace AAFwk { +namespace AbilityUtil { +#define CHECK_POINTER_CONTINUE(object) \ + if (!object) { \ + TAG_LOGE(AAFwkTag::ABILITYMGR, "nullptr"); \ + continue; \ + } + +#define CHECK_POINTER_IS_NULLPTR(object) \ + if (object == nullptr) { \ + TAG_LOGE(AAFwkTag::ABILITYMGR, "nullptr"); \ + return; \ + } + +#define CHECK_POINTER(object) \ + if (!object) { \ + TAG_LOGE(AAFwkTag::ABILITYMGR, "nullptr"); \ + return; \ + } + +#define CHECK_POINTER_LOG(object, log) \ + if (!object) { \ + TAG_LOGE(AAFwkTag::ABILITYMGR, "%{public}s:", log); \ + return; \ + } + +#define CHECK_POINTER_TAG_LOG(object, tag, log) \ + if (!object) { \ + TAG_LOGE(tag, "%{public}s:", log); \ + return; \ + } + +#define CHECK_POINTER_AND_RETURN(object, value) \ + if (!object) { \ + TAG_LOGE(AAFwkTag::ABILITYMGR, "nullptr"); \ + return value; \ + } + +#define CHECK_POINTER_AND_RETURN_LOG(object, value, log) \ + if (!object) { \ + TAG_LOGE(AAFwkTag::ABILITYMGR, "%{public}s:", log); \ + return value; \ + } + +#define CHECK_POINTER_RETURN_BOOL(object) \ + if (!object) { \ + TAG_LOGE(AAFwkTag::ABILITYMGR, "nullptr"); \ + return false; \ + } + +#define CHECK_RET_RETURN_RET(object, log) \ + if (object != ERR_OK) { \ + TAG_LOGE(AAFwkTag::ABILITYMGR, "%{public}s, ret : %{public}d", log, object); \ + return object; \ + } + +#define CHECK_TRUE_RETURN_RET(object, value, log) \ + if (object) { \ + TAG_LOGW(AAFwkTag::ABILITYMGR, "%{public}s", log); \ + return value; \ + } + +[[maybe_unused]] static std::shared_ptr GetBundleManagerHelper() +{ + return AppExecFwk::BundleMgrHelper::GetInstance(); +} +} // namespace AbilityUtil +} // namespace AAFwk +} // namespace OHOS + +#endif // OHOS_ABILITY_RUNTIME_ABILITY_UTIL_H diff --git a/test/unittest/ability_permission_util_test/mock/include/app_mgr_interface.h b/test/unittest/ability_permission_util_test/mock/include/app_mgr_interface.h new file mode 100644 index 00000000000..d81b403c776 --- /dev/null +++ b/test/unittest/ability_permission_util_test/mock/include/app_mgr_interface.h @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ABILITY_RUNTIME_APP_MGR_INTERFACE_H +#define OHOS_ABILITY_RUNTIME_APP_MGR_INTERFACE_H + +#include + +#include "iremote_broker.h" + +namespace OHOS { +namespace AppExecFwk { +class IAppMgr : public IRemoteBroker { +public: + DECLARE_INTERFACE_DESCRIPTOR(u"ohos.appexecfwk.AppMgr"); + + /** + * GetAllRunningInstanceKeysByBundleName, call GetAllRunningInstanceKeysByBundleName() through proxy project. + * Obtains running instance keys of multi-instance app that are running on the device. + * + * @param bundlename, bundle name in Application record. + * @param instanceKeys, output instance keys of the multi-instance app. + * @param userId, user id. + * @return ERR_OK ,return back success，others fail. + */ + virtual int32_t GetAllRunningInstanceKeysByBundleName(const std::string &bundleName, + std::vector &instanceKeys, int32_t userId = -1) = 0; +}; +} // namespace AppExecFwk +} // namespace OHOS + +#endif // OHOS_ABILITY_RUNTIME_APP_MGR_INTERFACE_H diff --git a/test/unittest/ability_permission_util_test/mock/include/app_mgr_stub.h b/test/unittest/ability_permission_util_test/mock/include/app_mgr_stub.h new file mode 100644 index 00000000000..e8abf5a4726 --- /dev/null +++ b/test/unittest/ability_permission_util_test/mock/include/app_mgr_stub.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ABILITY_RUNTIME_APP_MGR_STUB_H +#define OHOS_ABILITY_RUNTIME_APP_MGR_STUB_H + +#include "app_mgr_interface.h" +#include "iremote_stub.h" + +namespace OHOS { +namespace AppExecFwk { +class AppMgrStub : public IRemoteStub { +public: + AppMgrStub() {} + ~AppMgrStub() {} + + virtual int OnRemoteRequest( + uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override + { + return 0; + } + +private: + DISALLOW_COPY_AND_MOVE(AppMgrStub); +}; +} // namespace AppExecFwk +} // namespace OHOS +#endif // OHOS_ABILITY_RUNTIME_APP_MGR_STUB_H diff --git a/test/unittest/ability_permission_util_test/mock/include/app_mgr_util.h b/test/unittest/ability_permission_util_test/mock/include/app_mgr_util.h new file mode 100644 index 00000000000..baeb6cbeb9f --- /dev/null +++ b/test/unittest/ability_permission_util_test/mock/include/app_mgr_util.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ABILITY_RUNTIME_APP_MGR_UTIL_H +#define OHOS_ABILITY_RUNTIME_APP_MGR_UTIL_H + +#include "app_mgr_interface.h" + +namespace OHOS { +namespace AAFwk { +/** + * @class AppMgrUtil + * provides appmgr utilities. + */ +class AppMgrUtil final { +public: + static bool isNullAppMgr; + static sptr mockAppMgr; + + /** + * GetAppMgr, get app mgr. + * + * @return AppMgr. + */ + static sptr GetAppMgr() + { + if (isNullAppMgr) { + return nullptr; + } + return mockAppMgr; + } +}; +} // namespace AAFwk +} // namespace OHOS +#endif // OHOS_ABILITY_RUNTIME_APP_MGR_UTIL_H diff --git a/test/unittest/ability_permission_util_test/mock/include/app_scheduler.h b/test/unittest/ability_permission_util_test/mock/include/app_scheduler.h new file mode 100644 index 00000000000..d24b16d2b1f --- /dev/null +++ b/test/unittest/ability_permission_util_test/mock/include/app_scheduler.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MODULETEST_OHOS_ABILITY_RUNTIME_MOCK_APP_SCHEDULER_H +#define MODULETEST_OHOS_ABILITY_RUNTIME_MOCK_APP_SCHEDULER_H + +#include "singleton.h" + +#include "running_process_info.h" + +namespace OHOS { +namespace AAFwk { +class AppScheduler { + DECLARE_DELAYED_SINGLETON(AppScheduler) +public: + /** + * Get running process information by pid. + * + * @param pid process id. + * @param info Output parameters, return runningProcessInfo. + * @return Returns ERR_OK on success, others on failure. + */ + void GetRunningProcessInfoByPid(const pid_t pid, OHOS::AppExecFwk::RunningProcessInfo &info) const; +}; +} // namespace AAFwk +} // namespace OHOS +#endif // MODULETEST_OHOS_ABILITY_RUNTIME_MOCK_APP_SCHEDULER_H diff --git a/test/unittest/ability_permission_util_test/mock/include/app_utils.h b/test/unittest/ability_permission_util_test/mock/include/app_utils.h new file mode 100644 index 00000000000..eb92ef49d0f --- /dev/null +++ b/test/unittest/ability_permission_util_test/mock/include/app_utils.h @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ABILITY_RUNTIME_APP_UTILS_H +#define OHOS_ABILITY_RUNTIME_APP_UTILS_H + +#include + +#include "nocopyable.h" + +namespace OHOS { +namespace AAFwk { +/** + * @class AppUtils + * provides app utils. + */ +class AppUtils { +public: + static bool isAllowStartAbilityWithoutCallerToken; + static bool isSupportMultiInstance; + static bool isStartOptionsWithAnimation; + static bool isPrepareTerminateEnabled; + +public: + /** + * GetInstance, get an instance of AppUtils. + * + * @return An instance of AppUtils. + */ + static AppUtils &GetInstance() + { + static AppUtils instance; + return instance; + } + + /** + * AppUtils, destructor. + * + */ + ~AppUtils() {} + + /** + * IsAllowStartAbilityWithoutCallerToken, check if it allows start ability without caller token. + * + * @param bundleName The bundle name. + * @param abilityName The ability name. + * @return Whether it allows start ability without caller token. + */ + bool IsAllowStartAbilityWithoutCallerToken(const std::string& bundleName, const std::string& abilityName) + { + return isAllowStartAbilityWithoutCallerToken; + } + + /** + * IsSupportMultiInstance, check if it supports multi-instance. + * + * @return Whether it supports multi-instance. + */ + bool IsSupportMultiInstance() + { + return isSupportMultiInstance; + } + + /** + * IsStartOptionsWithAnimation, check whether the start options have animation. + * + * @return Whether the start options have animation. + */ + bool IsStartOptionsWithAnimation() + { + return isStartOptionsWithAnimation; + } + + /** + * IsPrepareTerminateEnabled, check if it supports prepare terminate. + * + * @return Whether it supports prepare terminate. + */ + bool IsPrepareTerminateEnabled() + { + return isPrepareTerminateEnabled; + } + +private: + AppUtils() {} + + DISALLOW_COPY_AND_MOVE(AppUtils); +}; +} // namespace AAFwk +} // namespace OHOS +#endif // OHOS_ABILITY_RUNTIME_APP_UTILS_H diff --git a/test/unittest/ability_permission_util_test/mock/include/bundle_mgr_helper.h b/test/unittest/ability_permission_util_test/mock/include/bundle_mgr_helper.h new file mode 100644 index 00000000000..3917f1dd97d --- /dev/null +++ b/test/unittest/ability_permission_util_test/mock/include/bundle_mgr_helper.h @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ABILITY_RUNTIME_BUNDLE_MGR_HELPER_H +#define OHOS_ABILITY_RUNTIME_BUNDLE_MGR_HELPER_H + +#include + +#include "bundle_info.h" + +namespace OHOS { + +namespace AppExecFwk { +class BundleMgrHelper { +public: + static bool isNullBundleMgrInstance; + static int32_t retGetNameForUid; + static BundleInfo retBundleInfo; + static bool retGetBundleInfo; + +public: + BundleMgrHelper() {} + + ~BundleMgrHelper() {} + + static std::shared_ptr GetInstance() + { + if (isNullBundleMgrInstance) { + return nullptr; + } + static std::shared_ptr instance = std::make_shared(); + return instance; + } + + int32_t GetNameForUid(const int32_t uid, std::string &name) + { + return retGetNameForUid; + } + + bool GetBundleInfo(const std::string &bundleName, const BundleFlag flag, BundleInfo &bundleInfo, int32_t userId) + { + bundleInfo = retBundleInfo; + return retGetBundleInfo; + } +}; +} // namespace AppExecFwk +} // namespace OHOS +#endif // OHOS_ABILITY_RUNTIME_BUNDLE_MGR_HELPER_H \ No newline at end of file diff --git a/test/unittest/ability_permission_util_test/mock/include/mock_app_mgr_impl.h b/test/unittest/ability_permission_util_test/mock/include/mock_app_mgr_impl.h new file mode 100644 index 00000000000..fa7365a71b0 --- /dev/null +++ b/test/unittest/ability_permission_util_test/mock/include/mock_app_mgr_impl.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ABILITY_RUNTIME_MOCK_APP_MGR_IMPL_H +#define OHOS_ABILITY_RUNTIME_MOCK_APP_MGR_IMPL_H + +#include "app_mgr_stub.h" + +namespace OHOS { +namespace AppExecFwk { +class MockAppMgrImpl : public AppMgrStub { +public: + static int32_t retGetAllRunningInstanceKeysByBundleName; + static std::vector retInstanceKeys; + + MockAppMgrImpl(); + + ~MockAppMgrImpl(); + + /** + * GetAllRunningInstanceKeysByBundleName, call GetAllRunningInstanceKeysByBundleName() through proxy project. + * Obtains running instance keys of multi-instance app that are running on the device. + * + * @param bundlename, bundle name in Application record. + * @param instanceKeys, output instance keys of the multi-instance app. + * @param userId, user id. + * @return ERR_OK ,return back success，others fail. + */ + virtual int32_t GetAllRunningInstanceKeysByBundleName(const std::string &bundleName, + std::vector &instanceKeys, int32_t userId = -1) override; +}; +} // namespace AppExecFwk +} // namespace OHOS + +#endif // OHOS_ABILITY_RUNTIME_MOCK_APP_MGR_IMPL_H diff --git a/test/unittest/ability_permission_util_test/mock/include/mock_permission_verification.h b/test/unittest/ability_permission_util_test/mock/include/mock_permission_verification.h deleted file mode 100644 index 4fcc914ac49..00000000000 --- a/test/unittest/ability_permission_util_test/mock/include/mock_permission_verification.h +++ /dev/null @@ -1,100 +0,0 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_ABILITY_RUNTIME_PERMISSION_VERIFICATION_H -#define OHOS_ABILITY_RUNTIME_PERMISSION_VERIFICATION_H - -#include "ipc_skeleton.h" -#include "singleton.h" -#include "want.h" -#include "mock_my_flag.h" - -namespace OHOS { -namespace AAFwk { - -class PermissionVerification : public DelayedSingleton { -public: -struct VerificationInfo { - bool visible = false; - bool isBackgroundCall = true; - bool associatedWakeUp = false; - uint32_t accessTokenId = 0; - int32_t apiTargetVersion = 0; -}; - - PermissionVerification() = default; - ~PermissionVerification() = default; - - bool VerifyCallingPermission(const std::string &permissionName) const; - - bool IsSACall() const; - - bool IsShellCall() const; - - bool CheckSpecificSystemAbilityAccessPermission() const; - - bool VerifyRunningInfoPerm() const; - - bool VerifyControllerPerm() const; - - bool VerifyDlpPermission(Want &want) const; - - int VerifyAccountPermission() const; - - bool VerifyMissionPermission() const; - - int VerifyAppStateObserverPermission() const; - - int32_t VerifyUpdateConfigurationPerm() const; - - bool VerifyInstallBundlePermission() const; - - bool VerifyGetBundleInfoPrivilegedPermission() const; - - int CheckCallDataAbilityPermission(const VerificationInfo &verificationInfo, bool isShell) const; - - int CheckCallServiceAbilityPermission(const VerificationInfo &verificationInfo) const; - - int CheckCallAbilityPermission(const VerificationInfo &verificationInfo) const; - - int CheckCallServiceExtensionPermission(const VerificationInfo &verificationInfo) const; - - int CheckStartByCallPermission(const VerificationInfo &verificationInfo) const; - - unsigned int GetCallingTokenID() const; - - bool JudgeStartInvisibleAbility(const uint32_t accessTokenId, const bool visible) const; - - bool JudgeStartAbilityFromBackground(const bool isBackgroundCall) const; - - bool JudgeAssociatedWakeUp(const uint32_t accessTokenId, const bool associatedWakeUp) const; - - int JudgeInvisibleAndBackground(const VerificationInfo &verificationInfo) const; - - inline bool IsCallFromSameAccessToken(const uint32_t accessTokenId) const - { - return IPCSkeleton::GetCallingTokenID() == accessTokenId; - } - - bool JudgeCallerIsAllowedToUseSystemAPI() const; - bool IsSystemAppCall() const; - - bool VerifyPrepareTerminatePermission() const; - - bool VerifySetProcessCachePermission() const; -}; -} // namespace AAFwk -} // namespace OHOS -#endif // OHOS_ABILITY_RUNTIME_PERMISSION_VERIFICATION_H \ No newline at end of file diff --git a/test/unittest/ability_permission_util_test/mock/include/multi_instance_utils.h b/test/unittest/ability_permission_util_test/mock/include/multi_instance_utils.h new file mode 100644 index 00000000000..8f2266bed22 --- /dev/null +++ b/test/unittest/ability_permission_util_test/mock/include/multi_instance_utils.h @@ -0,0 +1,98 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ABILITY_RUNTIME_MULTI_INSTANCE_UTILS_H +#define OHOS_ABILITY_RUNTIME_MULTI_INSTANCE_UTILS_H + +#include + +#include "application_info.h" +#include "extension_ability_info.h" +#include "want.h" + +namespace OHOS { +namespace AAFwk { +/** + * @class MultiInstanceUtils + * provides multi-instance utilities. + */ +class MultiInstanceUtils { +public: + static std::string retInstanceKey; + static bool isMultiInstanceApp; + static bool isDefaultInstanceKey; + static bool isSupportedExtensionType; + static bool isInstanceKeyExist; + +public: + /** + * GetInstanceKey, get instance key of the given want. + * + * @param want The want param. + * @return The instance key. + */ + static std::string GetInstanceKey(const Want& want) + { + return retInstanceKey; + } + + /** + * IsMultiInstanceApp, check if the app is the default multi-instance app. + * + * @param appInfo The app info to be queried. + * @return Whether the app is the default multi-instance app. + */ + static bool IsMultiInstanceApp(AppExecFwk::ApplicationInfo appInfo) + { + return isMultiInstanceApp; + } + + /** + * IsDefaultInstanceKey, check if the key is the default instance key. + * + * @param key The key to be queried. + * @return Whether the instance key is the default. + */ + static bool IsDefaultInstanceKey(const std::string& key) + { + return isDefaultInstanceKey; + } + + /** + * IsSupportedExtensionType, check if the type supports extension type. + * + * @param type The extension ability type. + * @return Whether the type supports extension type. + */ + static bool IsSupportedExtensionType(AppExecFwk::ExtensionAbilityType type) + { + return isSupportedExtensionType; + } + + /** + * IsInstanceKeyExist, check if the instance key exists. + * + * @param bundleName The bundle name. + * @param key The instance key to be queried. + * @return Whether the instance key exists. + */ + static bool IsInstanceKeyExist(const std::string& bundleName, const std::string& key) + { + return isInstanceKeyExist; + } +}; +} // namespace AAFwk +} // namespace OHOS +#endif // OHOS_ABILITY_RUNTIME_MULTI_INSTANCE_UTILS_H diff --git a/test/unittest/ability_permission_util_test/mock/include/permission_verification.h b/test/unittest/ability_permission_util_test/mock/include/permission_verification.h new file mode 100644 index 00000000000..e734da8c9cb --- /dev/null +++ b/test/unittest/ability_permission_util_test/mock/include/permission_verification.h @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2024-2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ABILITY_RUNTIME_PERMISSION_VERIFICATION_H +#define OHOS_ABILITY_RUNTIME_PERMISSION_VERIFICATION_H + +#include + +namespace OHOS { +namespace AAFwk { + +class PermissionVerification { +public: + static bool retJudgeCallerIsAllowedToUseSystemAPI; + static bool retVerifyStartRecentAbilityPermission; + static bool retVerifyPrepareTerminatePermission; + static bool retVerifyStartSelfUIAbility; + +public: + static std::shared_ptr GetInstance(); + + PermissionVerification(); + + ~PermissionVerification(); + + bool IsSACall() const; + + bool IsShellCall() const; + + bool JudgeCallerIsAllowedToUseSystemAPI() const; + + bool VerifyStartRecentAbilityPermission() const; + + bool VerifyPrepareTerminatePermission(int32_t tokenId) const; + + bool VerifyStartSelfUIAbility(int32_t tokenId) const; +}; +} // namespace AAFwk +} // namespace OHOS +#endif // OHOS_ABILITY_RUNTIME_PERMISSION_VERIFICATION_H \ No newline at end of file diff --git a/test/unittest/ability_permission_util_test/mock/include/start_ability_utils.h b/test/unittest/ability_permission_util_test/mock/include/start_ability_utils.h new file mode 100644 index 00000000000..5f8eaefeea5 --- /dev/null +++ b/test/unittest/ability_permission_util_test/mock/include/start_ability_utils.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ABILITY_RUNTIME_START_ABILITY_UTILS_H +#define OHOS_ABILITY_RUNTIME_START_ABILITY_UTILS_H + +#include "ability_info.h" + +namespace OHOS { +namespace AAFwk { +class StartAbilityUtils { +public: + static bool retGetApplicationInfo; + static AppExecFwk::ApplicationInfo retApplicationInfo; + + static bool GetApplicationInfo(const std::string &bundleName, int32_t userId, + AppExecFwk::ApplicationInfo &appInfo) + { + appInfo = retApplicationInfo; + return retGetApplicationInfo; + } +}; +} +} +#endif // OHOS_ABILITY_RUNTIME_START_ABILITY_UTILS_H \ No newline at end of file diff --git a/test/unittest/ability_permission_util_test/mock/src/ability_record.cpp b/test/unittest/ability_permission_util_test/mock/src/ability_record.cpp new file mode 100644 index 00000000000..48df4ac0518 --- /dev/null +++ b/test/unittest/ability_permission_util_test/mock/src/ability_record.cpp @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "ability_record.h" + +namespace OHOS { +namespace AAFwk { +std::shared_ptr Token::abilityRecord = nullptr; + +Token::Token() +{} + +Token::~Token() +{} + +std::shared_ptr Token::GetAbilityRecordByToken(sptr token) +{ + return abilityRecord; +} + +AbilityRecord::AbilityRecord() +{} + +AbilityRecord::~AbilityRecord() +{} + +const AppExecFwk::AbilityInfo &AbilityRecord::GetAbilityInfo() const +{ + return abilityInfo; +} + +std::string AbilityRecord::GetInstanceKey() +{ + return instanceKey; +} + +bool AbilityRecord::IsTerminating() +{ + return isTerminating; +} + +const AppExecFwk::ApplicationInfo &AbilityRecord::GetApplicationInfo() const +{ + return appInfo; +} +} // namespace AAFwk +} // namespace OHOS diff --git a/test/unittest/ability_permission_util_test/mock/src/app_scheduler.cpp b/test/unittest/ability_permission_util_test/mock/src/app_scheduler.cpp new file mode 100644 index 00000000000..9aa9768d399 --- /dev/null +++ b/test/unittest/ability_permission_util_test/mock/src/app_scheduler.cpp @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "app_scheduler.h" + +namespace OHOS { +namespace AAFwk { +AppScheduler::AppScheduler() +{} + +AppScheduler::~AppScheduler() +{} + +void AppScheduler::GetRunningProcessInfoByPid(const pid_t pid, OHOS::AppExecFwk::RunningProcessInfo &info) const +{ + info.isTestProcess = true; +} +} // namespace AAFwk +} // namespace OHOS diff --git a/test/unittest/ability_permission_util_test/mock/src/mock_app_mgr_impl.cpp b/test/unittest/ability_permission_util_test/mock/src/mock_app_mgr_impl.cpp new file mode 100644 index 00000000000..88a2d9e4014 --- /dev/null +++ b/test/unittest/ability_permission_util_test/mock/src/mock_app_mgr_impl.cpp @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "mock_app_mgr_impl.h" + +namespace OHOS { +namespace AppExecFwk { +int32_t MockAppMgrImpl::retGetAllRunningInstanceKeysByBundleName = 0; +std::vector MockAppMgrImpl::retInstanceKeys; + +MockAppMgrImpl::MockAppMgrImpl() +{} + +MockAppMgrImpl::~MockAppMgrImpl() +{} + +int32_t MockAppMgrImpl::GetAllRunningInstanceKeysByBundleName(const std::string &bundleName, + std::vector &instanceKeys, int32_t userId) +{ + instanceKeys = retInstanceKeys; + return retGetAllRunningInstanceKeysByBundleName; +} +} // namespace AppExecFwk +} // namespace OHOS diff --git a/test/unittest/ability_permission_util_test/mock/src/mock_permission_verification.cpp b/test/unittest/ability_permission_util_test/mock/src/mock_permission_verification.cpp deleted file mode 100644 index 6fbc5bcf3e6..00000000000 --- a/test/unittest/ability_permission_util_test/mock/src/mock_permission_verification.cpp +++ /dev/null @@ -1,133 +0,0 @@ -/* - * Copyright (c) 2024 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 "mock_permission_verification.h" - -namespace OHOS { -namespace AAFwk { - -bool PermissionVerification::VerifyCallingPermission(const std::string &permissionName) const -{ - return !!(MyFlag::flag_); -} -bool PermissionVerification::IsSACall() const -{ - return (MyFlag::flag_ & MyFlag::FLAG::IS_SA_CALL); -} -bool PermissionVerification::IsShellCall() const -{ - return (MyFlag::flag_ & MyFlag::FLAG::IS_SHELL_CALL); -} -bool PermissionVerification::CheckSpecificSystemAbilityAccessPermission() const -{ - return !!(MyFlag::flag_); -} -bool PermissionVerification::VerifyRunningInfoPerm() const -{ - return !!(MyFlag::flag_); -} -bool PermissionVerification::VerifyControllerPerm() const -{ - return !!(MyFlag::flag_); -} -#ifdef WITH_DLP -bool PermissionVerification::VerifyDlpPermission(Want &want) const -{ - return !!(MyFlag::flag_); -} -#endif // WITH_DLP -int PermissionVerification::VerifyAccountPermission() const -{ - return MyFlag::flag_; -} -bool PermissionVerification::VerifyMissionPermission() const -{ - return !!(MyFlag::flag_); -} -int PermissionVerification::VerifyAppStateObserverPermission() const -{ - return MyFlag::flag_; -} -int32_t PermissionVerification::VerifyUpdateConfigurationPerm() const -{ - return static_cast(MyFlag::flag_); -} -bool PermissionVerification::VerifyInstallBundlePermission() const -{ - return !!(MyFlag::flag_); -} -bool PermissionVerification::VerifyGetBundleInfoPrivilegedPermission() const -{ - return !!(MyFlag::flag_); -} -int PermissionVerification::CheckCallDataAbilityPermission(const VerificationInfo &verificationInfo, bool isShell) const -{ - return MyFlag::flag_; -} -int PermissionVerification::CheckCallServiceAbilityPermission(const VerificationInfo &verificationInfo) const -{ - return MyFlag::flag_; -} -int PermissionVerification::CheckCallAbilityPermission(const VerificationInfo &verificationInfo) const -{ - return MyFlag::flag_; -} -int PermissionVerification::CheckCallServiceExtensionPermission(const VerificationInfo &verificationInfo) const -{ - return MyFlag::flag_; -} -int PermissionVerification::CheckStartByCallPermission(const VerificationInfo &verificationInfo) const -{ - return MyFlag::flag_; -} -unsigned int PermissionVerification::GetCallingTokenID() const -{ - return static_cast(MyFlag::flag_); -} -bool PermissionVerification::JudgeStartInvisibleAbility(const uint32_t accessTokenId, const bool visible) const -{ - return !!(MyFlag::flag_); -} -bool PermissionVerification::JudgeStartAbilityFromBackground(const bool isBackgroundCall) const -{ - return !!(MyFlag::flag_); -} -bool PermissionVerification::JudgeAssociatedWakeUp(const uint32_t accessTokenId, const bool associatedWakeUp) const -{ - return !!(MyFlag::flag_); -} -int PermissionVerification::JudgeInvisibleAndBackground(const VerificationInfo &verificationInfo) const -{ - return MyFlag::flag_; -} -bool PermissionVerification::JudgeCallerIsAllowedToUseSystemAPI() const -{ - return true; -} -bool PermissionVerification::VerifyPrepareTerminatePermission() const -{ - return true; -} -bool PermissionVerification::IsSystemAppCall() const -{ - return true; -} - -bool PermissionVerification::VerifySetProcessCachePermission() const -{ - return true; -} -} // namespace AAFwk -} // namespace OHOS \ No newline at end of file diff --git a/test/unittest/ability_permission_util_test/mock/src/permission_verification.cpp b/test/unittest/ability_permission_util_test/mock/src/permission_verification.cpp new file mode 100644 index 00000000000..dc62883bbb2 --- /dev/null +++ b/test/unittest/ability_permission_util_test/mock/src/permission_verification.cpp @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "mock_my_flag.h" +#include "permission_verification.h" + +namespace OHOS { +namespace AAFwk { +bool PermissionVerification::retJudgeCallerIsAllowedToUseSystemAPI = false; +bool PermissionVerification::retVerifyStartRecentAbilityPermission = false; +bool PermissionVerification::retVerifyPrepareTerminatePermission = false; +bool PermissionVerification::retVerifyStartSelfUIAbility = false; + +PermissionVerification::PermissionVerification() {} + +PermissionVerification::~PermissionVerification() {} + +std::shared_ptr PermissionVerification::GetInstance() +{ + static std::shared_ptr instance = std::make_shared(); + return instance; +} + +bool PermissionVerification::IsSACall() const +{ + return (MyFlag::flag_ & MyFlag::FLAG::IS_SA_CALL); +} + +bool PermissionVerification::IsShellCall() const +{ + return (MyFlag::flag_ & MyFlag::FLAG::IS_SHELL_CALL); +} + +bool PermissionVerification::JudgeCallerIsAllowedToUseSystemAPI() const +{ + return retJudgeCallerIsAllowedToUseSystemAPI; +} + +bool PermissionVerification::VerifyStartRecentAbilityPermission() const +{ + return retVerifyStartRecentAbilityPermission; +} + +bool PermissionVerification::VerifyPrepareTerminatePermission(int32_t tokenId) const +{ + return retVerifyPrepareTerminatePermission; +} + +bool PermissionVerification::VerifyStartSelfUIAbility(int32_t tokenId) const +{ + return retVerifyStartSelfUIAbility; +} +} // namespace AAFwk +} // namespace OHOS \ No newline at end of file -- Gitee