diff --git a/bundle.json b/bundle.json index 62ba325842fb1112358b41ab8f2120e937061ed9..6c50a6466a83114a34106826e02535537930d3dc 100644 --- a/bundle.json +++ b/bundle.json @@ -179,7 +179,8 @@ "//foundation/aafwk/standard/frameworks/kits/content/cpp/test:unittest", "//foundation/aafwk/standard/frameworks/kits/ability/native/test:unittest", "//foundation/aafwk/standard/interfaces/kits/napi/aafwk/dataShare/test:unittest", - "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test:moduletest", + "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test/moduletest:moduletest", + "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test/unittest:unittest", "//foundation/aafwk/standard/frameworks/kits/test:moduletest", "//foundation/aafwk/standard/services/test:moduletest", "//foundation/aafwk/standard/services:unittest", diff --git a/frameworks/kits/ability/ability_runtime/src/ability_context_impl.cpp b/frameworks/kits/ability/ability_runtime/src/ability_context_impl.cpp index 7fe1a471cf048580712914dd8722c15a8e2e1c87..57c8cf1fc139a9d85761f193c8e46f794db03059 100644 --- a/frameworks/kits/ability/ability_runtime/src/ability_context_impl.cpp +++ b/frameworks/kits/ability/ability_runtime/src/ability_context_impl.cpp @@ -353,11 +353,12 @@ ErrCode AbilityContextImpl::StartAbility( ErrCode AbilityContextImpl::ReleaseAbility(const std::shared_ptr &callback) { + HILOG_DEBUG("AbilityContextImpl::Release begain."); if (!localCallContainer_) { HILOG_ERROR("%{public}s false.", __func__); return ERR_INVALID_VALUE; } - + HILOG_DEBUG("AbilityContextImpl::Release end."); return localCallContainer_->Release(callback); } diff --git a/frameworks/kits/ability/ability_runtime/src/local_call_container.cpp b/frameworks/kits/ability/ability_runtime/src/local_call_container.cpp index a1ac33cca6d94ae58deb8a6d71aec1aeed5011fa..a1cf18bde7dcea12b57de5a2bf6b413715748346 100644 --- a/frameworks/kits/ability/ability_runtime/src/local_call_container.cpp +++ b/frameworks/kits/ability/ability_runtime/src/local_call_container.cpp @@ -63,9 +63,9 @@ int LocalCallContainer::StartAbilityInner( HILOG_ERROR("LocalCallContainer::Resolve abilityClient is nullptr"); return ERR_INVALID_VALUE; } - sptr connect = iface_cast(this); + sptr connect = iface_cast(this->AsObject()); HILOG_DEBUG("start ability by call, abilityClient->StartAbilityByCall call"); - return abilityClient->StartAbilityByCall(want, this, callerToken); + return abilityClient->StartAbilityByCall(want, connect, callerToken); } // already finish call request. HILOG_DEBUG("start ability by call, callback->InvokeCallBack(remote) begin"); @@ -77,7 +77,9 @@ int LocalCallContainer::StartAbilityInner( int LocalCallContainer::Release(const std::shared_ptr& callback) { + HILOG_DEBUG("LocalCallContainer::Release begain."); auto isExist = [&callback](auto &record) { + HILOG_DEBUG("LocalCallContainer::Release begain1."); return record.second->RemoveCaller(callback); }; @@ -95,6 +97,7 @@ int LocalCallContainer::Release(const std::shared_ptr& callback) if (record->IsExistCallBack()) { // just release callback. + HILOG_DEBUG("LocalCallContainer::Release begain2."); return ERR_OK; } @@ -105,14 +108,14 @@ int LocalCallContainer::Release(const std::shared_ptr& callback) HILOG_ERROR("LocalCallContainer::Resolve abilityClient is nullptr"); return ERR_INVALID_VALUE; } - sptr connect = iface_cast(this); + sptr connect = iface_cast(this->AsObject()); if (abilityClient->ReleaseAbility(connect, elementName) != ERR_OK) { HILOG_ERROR("ReleaseAbility failed."); return ERR_INVALID_VALUE; } callProxyRecords_.erase(iter); - + HILOG_DEBUG("LocalCallContainer::Release end."); return ERR_OK; } @@ -180,7 +183,6 @@ bool LocalCallContainer::GetCallLocalreocrd( localCallRecord = iter->second; return true; } - return false; } diff --git a/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_ability_manager_client.cpp b/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_ability_manager_client.cpp index 284df7e225e4b63fccdde2add4d7ba972b9985b1..7423927c815093c48ef6721d56a80bb6a4019440 100644 --- a/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_ability_manager_client.cpp +++ b/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_ability_manager_client.cpp @@ -130,9 +130,11 @@ ErrCode AbilityManagerClient::StartAbilityByCall( HILOG_INFO("AbilityManagerClient::StartAbilityByCall start"); if (remoteObject_ == nullptr) { HILOG_INFO("AbilityManagerClient::StartAbilityByCall fail because remoteobject is null"); - return ABILITY_SERVICE_NOT_CONNECTED; + remoteObject_ = + OHOS::DelayedSingleton::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID); } sptr abms = iface_cast(remoteObject_); + HILOG_INFO("AbilityManagerClient::StartAbilityByCall end"); return abms->StartAbilityByCall(want, connect, callerToken); } @@ -142,10 +144,11 @@ ErrCode AbilityManagerClient::ReleaseAbility( HILOG_INFO("AbilityManagerClient::ReleaseAbility start"); if (remoteObject_ == nullptr) { HILOG_INFO("AbilityManagerClient::ReleaseAbility fail because remoteobject is null"); - return ABILITY_SERVICE_NOT_CONNECTED; + remoteObject_ = + OHOS::DelayedSingleton::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID); } - HILOG_INFO("AbilityManagerClient::StartAbility start2"); sptr abms = iface_cast(remoteObject_); + HILOG_INFO("AbilityManagerClient::ReleaseAbility end"); return abms->ReleaseAbility(connect, element); } diff --git a/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_serviceability_manager_service.cpp b/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_serviceability_manager_service.cpp index 2e1125b34861be734b6ac5ded468b519469b756d..01e0d174911733771f21a9c2e47a5d23012634bc 100644 --- a/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_serviceability_manager_service.cpp +++ b/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_serviceability_manager_service.cpp @@ -45,11 +45,12 @@ int MockServiceAbilityManagerService::StartAbility( int MockServiceAbilityManagerService::StartAbilityByCall( const Want &want, const sptr &connect, const sptr &callerToken) { - GTEST_LOG_(INFO) << "MockServiceAbilityManagerService::StartAbilityByCall"; + GTEST_LOG_(INFO) << "MockServiceAbilityManagerService::StartAbilityByCall begain"; if (!connect) { GTEST_LOG_(INFO) << "MockAbilityManagerService::StartAbilityByCall connect is null"; return -1; } + GTEST_LOG_(INFO) << "MockServiceAbilityManagerService::StartAbilityByCall end"; return 0; } @@ -69,7 +70,7 @@ int MockServiceAbilityManagerService::TerminateAbility( int MockServiceAbilityManagerService::ConnectAbility( const Want &want, const sptr &connect, const sptr &callerToken, int32_t userId) { - return -1; + return 0; } int MockServiceAbilityManagerService::DisconnectAbility(const sptr &connect) diff --git a/frameworks/kits/ability/ability_runtime/test/BUILD.gn b/frameworks/kits/ability/ability_runtime/test/moduletest/BUILD.gn similarity index 85% rename from frameworks/kits/ability/ability_runtime/test/BUILD.gn rename to frameworks/kits/ability/ability_runtime/test/moduletest/BUILD.gn index cbdb9dc5c4082132a98ac705fed220ba48ffe38e..7b7b22c5e1c3e903abb5d3927d323204abaa5cd3 100644 --- a/frameworks/kits/ability/ability_runtime/test/BUILD.gn +++ b/frameworks/kits/ability/ability_runtime/test/moduletest/BUILD.gn @@ -26,10 +26,7 @@ config("module_private_config") { } include_dirs = [ "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test/mock/AMS", - "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test/mock/Ability/include", - "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test/mock/BMS/include", - "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_core/include/bundlemgr/", - "//foundation/distributedschedule/safwk/services/safwk/include", + #"//foundation/distributedschedule/safwk/services/safwk/include", ] } @@ -39,7 +36,7 @@ ohos_moduletest("ability_caller_fw_module_test") { "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_ability_manager_client.cpp", "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_serviceability_manager_service.cpp", "//foundation/aafwk/standard/frameworks/kits/ability/native/test/mock/include/sys_mgr_client_mock.cpp", - "moduletest/ability_caller_fw_module_test.cpp", + "ability_caller_fw_module_test.cpp", ] configs = [ ":module_private_config" ] @@ -75,8 +72,4 @@ group("moduletest") { deps = [] deps += [ ":ability_caller_fw_module_test" ] - - # if (is_phone_product) { - # deps += [ ":ability_caller_fw_module_test" ] - # } } diff --git a/frameworks/kits/ability/ability_runtime/test/moduletest/ability_caller_fw_module_test.cpp b/frameworks/kits/ability/ability_runtime/test/moduletest/ability_caller_fw_module_test.cpp index 19505858ba2fa86482470f3695197ce38ed3565f..79bf37ab2f6628148820e5685695e516ca99b3f8 100644 --- a/frameworks/kits/ability/ability_runtime/test/moduletest/ability_caller_fw_module_test.cpp +++ b/frameworks/kits/ability/ability_runtime/test/moduletest/ability_caller_fw_module_test.cpp @@ -61,10 +61,6 @@ void AbilityCallerTest::SetUpTestCase(void) } sysMgr->RegisterSystemAbility(OHOS::ABILITY_MGR_SERVICE_ID, abilityObject); - - auto task = []()->Ability* { return new (std::nothrow) Ability; }; - - AbilityLoader::GetInstance().RegisterAbility(ACE_SERVICE_ABILITY_NAME, task); } void AbilityCallerTest::TearDownTestCase(void) @@ -85,20 +81,8 @@ void AbilityCallerTest::TearDown(void) */ HWTEST_F(AbilityCallerTest, AaFwk_Ability_StartAbility_0100, Function | MediumTest | Level1) { - std::shared_ptr application = std::make_shared(); - sptr abilityToken = sptr(new AbilityThread()); - std::shared_ptr abilityInfo = std::make_shared(); - abilityInfo->type = AppExecFwk::AbilityType::SERVICE; - abilityInfo->name = "DemoAbilityNameA"; - abilityInfo->bundleName = "DemoBundleNameA"; - abilityInfo->deviceId = "DemoDeviceIdA"; - std::shared_ptr abilityRecord = - std::make_shared(abilityInfo, abilityToken); - - AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr); - Want want; - want.SetElementName("DemoDeviceIdB", "DemoBundleNameB", "DemoAbilityNameB"); + want.SetElementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); std::shared_ptr callback = std::make_shared(); callback->SetCallBack([](const sptr &) {}); @@ -107,10 +91,14 @@ HWTEST_F(AbilityCallerTest, AaFwk_Ability_StartAbility_0100, Function | MediumTe ErrCode ret = context_->StartAbility(want, callback); EXPECT_TRUE(ret == 0); - AppExecFwk::ElementName element("DemoDeviceIdB", "DemoBundleNameB", "DemoAbilityNameB"); + AppExecFwk::ElementName element("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); sptr callRemoteObject = OHOS::DelayedSingleton::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID); context_->localCallContainer_->OnAbilityConnectDone(element, callRemoteObject, ERR_OK); + std::vector info; + EXPECT_TRUE(info.size() == 0); + context_->localCallContainer_->DumpCalls(info); + EXPECT_TRUE(info.size() != 0); EXPECT_TRUE(callback->IsCallBack()); } @@ -122,7 +110,7 @@ HWTEST_F(AbilityCallerTest, AaFwk_Ability_StartAbility_0100, Function | MediumTe HWTEST_F(AbilityCallerTest, AaFwk_Ability_StartAbility_0200, Function | MediumTest | Level1) { Want want; - want.SetElementName("DemoDeviceIdB", "DemoBundleNameB", "DemoAbilityNameB"); + want.SetElementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); ErrCode ret = context_->StartAbility(want, nullptr); EXPECT_FALSE(ret == 0); @@ -151,18 +139,6 @@ HWTEST_F(AbilityCallerTest, AaFwk_Ability_StartAbility_0300, Function | MediumTe */ HWTEST_F(AbilityCallerTest, AaFwk_Ability_ReleaseAbility_0100, Function | MediumTest | Level1) { - std::shared_ptr application = std::make_shared(); - sptr abilityToken = sptr(new AbilityThread()); - std::shared_ptr abilityInfo = std::make_shared(); - abilityInfo->type = AppExecFwk::AbilityType::SERVICE; - abilityInfo->name = "DemoAbilityNameA"; - abilityInfo->bundleName = "DemoBundleNameA"; - abilityInfo->deviceId = "DemoDeviceIdA"; - std::shared_ptr abilityRecord = - std::make_shared(abilityInfo, abilityToken); - - AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr); - Want want; want.SetElementName("DemoDeviceIdB", "DemoBundleNameB", "DemoAbilityNameB"); @@ -197,20 +173,8 @@ HWTEST_F(AbilityCallerTest, AaFwk_Ability_ReleaseAbility_0200, Function | Medium */ HWTEST_F(AbilityCallerTest, AaFwk_Ability_OnCallStubDied_0100, Function | MediumTest | Level1) { - std::shared_ptr application = std::make_shared(); - sptr abilityToken = sptr(new AbilityThread()); - std::shared_ptr abilityInfo = std::make_shared(); - abilityInfo->type = AppExecFwk::AbilityType::SERVICE; - abilityInfo->name = "DemoAbilityNameA"; - abilityInfo->bundleName = "DemoBundleNameA"; - abilityInfo->deviceId = "DemoDeviceIdA"; - std::shared_ptr abilityRecord = - std::make_shared(abilityInfo, abilityToken); - - AbilityThread::AbilityThreadMain(application, abilityRecord, nullptr); - Want want; - want.SetElementName("DemoDeviceIdB", "DemoBundleNameB", "DemoAbilityNameB"); + want.SetElementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); std::shared_ptr callback = std::make_shared(); bool isSetOnReleaseCalled = false; @@ -225,7 +189,7 @@ HWTEST_F(AbilityCallerTest, AaFwk_Ability_OnCallStubDied_0100, Function | Medium EXPECT_TRUE(ret == 0); std::shared_ptr localCallRecord; - AppExecFwk::ElementName elementName("DemoDeviceIdB", "DemoBundleNameB", "DemoAbilityNameB"); + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); context_->localCallContainer_->GetCallLocalreocrd(elementName, localCallRecord); sptr callRemoteObject = diff --git a/frameworks/kits/ability/ability_runtime/test/unittest/BUILD.gn b/frameworks/kits/ability/ability_runtime/test/unittest/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..0aa9a194d73f285edda3e1c1543fbf3549655a6e --- /dev/null +++ b/frameworks/kits/ability/ability_runtime/test/unittest/BUILD.gn @@ -0,0 +1,124 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") + +module_out_path = "ability_runtime/ability_call_test" + +############################################################################### + +config("module_private_config") { + visibility = [ ":*" ] +} + +ohos_unittest("ability_context_impl_ut_test") { + module_out_path = module_out_path + + include_dirs = [ "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test/mock/AMS" ] + + sources = [ + "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_ability_manager_client.cpp", + "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_serviceability_manager_service.cpp", + "//foundation/aafwk/standard/frameworks/kits/ability/native/test/mock/include/sys_mgr_client_mock.cpp", + "ability_context_impl_ut_test.cpp", + ] + + deps = [ + "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime:ability_context_native", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//foundation/aafwk/standard/frameworks/kits/appkit:appkit_native", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/aafwk/standard/interfaces/innerkits/want:want", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_core:appexecfwk_core", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy:samgr_proxy", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] +} + +ohos_unittest("caller_call_back_ut_test") { + module_out_path = module_out_path + sources = [ "caller_call_back_ut_test.cpp" ] + + deps = [ + "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime:ability_context_native", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//third_party/googletest:gtest_main", + ] +} + +ohos_unittest("local_call_container_ut_test") { + module_out_path = module_out_path + + include_dirs = [ "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test/mock/AMS" ] + + sources = [ + "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_ability_manager_client.cpp", + "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_serviceability_manager_service.cpp", + "//foundation/aafwk/standard/frameworks/kits/ability/native/test/mock/include/sys_mgr_client_mock.cpp", + "local_call_container_ut_test.cpp", + ] + + deps = [ + "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime:ability_context_native", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//foundation/aafwk/standard/frameworks/kits/appkit:appkit_native", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/aafwk/standard/interfaces/innerkits/want:want", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_core:appexecfwk_core", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy:samgr_proxy", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] +} + +ohos_unittest("local_call_record_ut_test") { + module_out_path = module_out_path + + include_dirs = [ "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test/mock/AMS" ] + + sources = [ + "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_ability_manager_client.cpp", + "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_serviceability_manager_service.cpp", + "//foundation/aafwk/standard/frameworks/kits/ability/native/test/mock/include/sys_mgr_client_mock.cpp", + "local_call_record_ut_test.cpp", + ] + + deps = [ + "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime:ability_context_native", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//foundation/aafwk/standard/frameworks/kits/appkit:appkit_native", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/aafwk/standard/interfaces/innerkits/want:want", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_core:appexecfwk_core", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy:samgr_proxy", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + ] +} + +################################################################################ +group("unittest") { + testonly = true + deps = [] + + deps += [ + ":ability_context_impl_ut_test", + ":caller_call_back_ut_test", + ":local_call_container_ut_test", + ":local_call_record_ut_test", + ] +} diff --git a/frameworks/kits/ability/ability_runtime/test/unittest/ability_context_impl_ut_test.cpp b/frameworks/kits/ability/ability_runtime/test/unittest/ability_context_impl_ut_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..fc0014c519079a80dd7446651a06ec351db05e4a --- /dev/null +++ b/frameworks/kits/ability/ability_runtime/test/unittest/ability_context_impl_ut_test.cpp @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#define private public +#include "ability_context_impl.h" +#define protected public +#include "ability_loader.h" +#include "ability_thread.h" +#include "mock_serviceability_manager_service.h" +#include "system_ability_definition.h" +#include "sys_mgr_client.h" + +namespace OHOS { +namespace AppExecFwk { +using namespace testing::ext; +using namespace OHOS::AbilityRuntime; +class AbilityContextImplTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +public: + std::unique_ptr context_ = nullptr; +}; + +void AbilityContextImplTest::SetUpTestCase(void) +{ + OHOS::sptr abilityObject = new (std::nothrow) MockServiceAbilityManagerService(); + + auto sysMgr = OHOS::DelayedSingleton::GetInstance(); + if (sysMgr == NULL) { + GTEST_LOG_(ERROR) << "fail to get ISystemAbilityManager"; + return; + } + sysMgr->RegisterSystemAbility(OHOS::ABILITY_MGR_SERVICE_ID, abilityObject); +} + +void AbilityContextImplTest::TearDownTestCase(void) +{} + +void AbilityContextImplTest::SetUp(void) +{ + context_ = std::make_unique(); +} + +void AbilityContextImplTest::TearDown(void) +{} + +/** + * @tc.number: Ability_Context_Impl_StartAbility_0100 + * @tc.name: StartAbility + * @tc.desc: Ability context to process StartAbility, and the result is success(localCallContainer_ is null). + */ +HWTEST_F(AbilityContextImplTest, Ability_Context_Impl_StartAbility_0100, Function | MediumTest | Level1) +{ + Want want; + want.SetElementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + + std::shared_ptr callback = std::make_shared(); + callback->SetCallBack([](const sptr &) {}); + + ErrCode ret = context_->StartAbility(want, callback); + EXPECT_TRUE(ret == ERR_OK); +} + +/** + * @tc.number: Ability_Context_Impl_StartAbility_0200 + * @tc.name: StartAbility + * @tc.desc: Ability context to process StartAbility, and the result is success(localCallContainer_ is not null). + */ +HWTEST_F(AbilityContextImplTest, Ability_Context_Impl_StartAbility_0200, Function | MediumTest | Level1) +{ + Want want; + want.SetElementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + + std::shared_ptr callback = std::make_shared(); + callback->SetCallBack([](const sptr &) {}); + + context_->localCallContainer_ = new (std::nothrow)LocalCallContainer(); + EXPECT_NE(context_->localCallContainer_, nullptr); + + ErrCode ret = context_->StartAbility(want, callback); + EXPECT_TRUE(ret == ERR_OK); +} + +/** + * @tc.number: Ability_Context_Impl_ReleaseAbility_0100 + * @tc.name: StartAbility + * @tc.desc: Ability context to process ReleaseAbility, and the result is success. + */ +HWTEST_F(AbilityContextImplTest, Ability_Context_Impl_ReleaseAbility_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "========Ability_Context_Impl_ReleaseAbility_0100beagin==============."; + + std::shared_ptr callback = std::make_shared(); + callback->SetCallBack([](const sptr &) {}); + + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + std::shared_ptr localCallRecord = std::make_shared(elementName); + localCallRecord->AddCaller(callback); + + context_->localCallContainer_ = new (std::nothrow) LocalCallContainer(); + EXPECT_NE(context_->localCallContainer_, nullptr); + + std::string uri = elementName.GetURI(); + context_->localCallContainer_->callProxyRecords_.emplace(uri, localCallRecord); + + ErrCode ret = context_->ReleaseAbility(callback); + EXPECT_TRUE(ret == ERR_OK); + GTEST_LOG_(INFO) << "========Ability_Context_Impl_ReleaseAbility_0100end==============."; +} + +/** + * @tc.number: Ability_Context_Impl_ReleaseAbility_0200 + * @tc.name: StartAbility + * @tc.desc: Ability context to process ReleaseAbility, and the result is fail because localCallContainer is null. + */ +HWTEST_F(AbilityContextImplTest, Ability_Context_Impl_ReleaseAbility_0200, Function | MediumTest | Level1) +{ + std::shared_ptr callback = std::make_shared(); + ErrCode ret = context_->ReleaseAbility(callback); + EXPECT_TRUE(ret == ERR_INVALID_VALUE); +} +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/kits/ability/ability_runtime/test/unittest/caller_call_back_ut_test.cpp b/frameworks/kits/ability/ability_runtime/test/unittest/caller_call_back_ut_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..909f105e4adada7cb80838b02c5c201b2140bfe4 --- /dev/null +++ b/frameworks/kits/ability/ability_runtime/test/unittest/caller_call_back_ut_test.cpp @@ -0,0 +1,158 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#define private public +#define protected public +#include "caller_callback.h" +#undef private +#undef protected + +namespace OHOS { +namespace AppExecFwk { +using namespace testing::ext; +using namespace OHOS::AbilityRuntime; + +class CallerCallBackTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void CallerCallBackTest::SetUpTestCase(void) +{} + +void CallerCallBackTest::TearDownTestCase(void) +{} + +void CallerCallBackTest::SetUp(void) +{} + +void CallerCallBackTest::TearDown(void) +{} + +/** + * @tc.number: Caller_Call_Back_SetCallBack_0100 + * @tc.name: StartAbility + * @tc.desc: Caller call back to process SetCallBack success. + */ +HWTEST_F(CallerCallBackTest, Caller_Call_Back_SetCallBack_0100, Function | MediumTest | Level1) +{ + CallerCallBack callerCallBack; + EXPECT_TRUE(callerCallBack.callback_ == nullptr); + + callerCallBack.SetCallBack([](const sptr &) {}); + + EXPECT_TRUE(callerCallBack.callback_ != nullptr); +} + +/** + * @tc.number: Caller_Call_Back_SetOnRelease_0100 + * @tc.name: SetOnRelease + * @tc.desc: Caller call back to process SetOnRelease success. + */ +HWTEST_F(CallerCallBackTest, Caller_Call_Back_SetOnRelease_0100, Function | MediumTest | Level1) +{ + CallerCallBack callerCallBack; + EXPECT_TRUE(callerCallBack.onRelease_ == nullptr); + + callerCallBack.SetOnRelease([](const std::string &result) { + }); + + EXPECT_TRUE(callerCallBack.onRelease_ != nullptr); +} + +/** + * @tc.number: Caller_Call_Back_InvokeCallBack_0100 + * @tc.name: InvokeCallBack + * @tc.desc: Caller call back to process InvokeCallBack success. + */ +HWTEST_F(CallerCallBackTest, Caller_Call_Back_InvokeCallBack_0100, Function | MediumTest | Level1) +{ + CallerCallBack callerCallBack; + EXPECT_EQ(callerCallBack.isCallBack_, false); + + callerCallBack.SetCallBack([](const sptr &) {}); + + callerCallBack.InvokeCallBack(nullptr); + + EXPECT_EQ(callerCallBack.isCallBack_, true); +} + +/** + * @tc.number: Caller_Call_Back_InvokeCallBack_0200 + * @tc.name: InvokeCallBack + * @tc.desc: Caller call back to process InvokeCallBack fail because call back is null. + */ +HWTEST_F(CallerCallBackTest, Caller_Call_Back_InvokeCallBack_0200, Function | MediumTest | Level1) +{ + CallerCallBack callerCallBack; + EXPECT_EQ(callerCallBack.isCallBack_, false); + + callerCallBack.InvokeCallBack(nullptr); + + EXPECT_EQ(callerCallBack.isCallBack_, false); +} + +/** + * @tc.number: Caller_Call_Back_InvokeOnRelease_0100 + * @tc.name: InvokeOnRelease + * @tc.desc: Caller call back to process InvokeOnRelease success. + */ +HWTEST_F(CallerCallBackTest, Caller_Call_Back_InvokeOnRelease_0100, Function | MediumTest | Level1) +{ + CallerCallBack callerCallBack; + + callerCallBack.SetOnRelease([](const std::string &result) { + EXPECT_TRUE("result" == result); + }); + + std::string key = "result"; + callerCallBack.InvokeOnRelease(key); +} + +/** + * @tc.number: Caller_Call_Back_InvokeOnRelease_0200 + * @tc.name: InvokeOnRelease + * @tc.desc: Caller call back to process InvokeOnRelease fail because onRelease is null. + */ +HWTEST_F(CallerCallBackTest, Caller_Call_Back_InvokeOnRelease_0200, Function | MediumTest | Level1) +{ + CallerCallBack callerCallBack; + + std::string key(""); + callerCallBack.InvokeOnRelease(key); + + EXPECT_TRUE("" == key); +} + +/** + * @tc.number: Caller_Call_Back_IsCallBack_0100 + * @tc.name: IsCallBack + * @tc.desc: Caller call back to process IsCallBack success. + */ +HWTEST_F(CallerCallBackTest, Caller_Call_Back_IsCallBack_0100, Function | MediumTest | Level1) +{ + CallerCallBack callerCallBack; + callerCallBack.isCallBack_ = true; + + bool ret = callerCallBack.IsCallBack(); + + EXPECT_EQ(ret, true); +} +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/kits/ability/ability_runtime/test/unittest/local_call_container_ut_test.cpp b/frameworks/kits/ability/ability_runtime/test/unittest/local_call_container_ut_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..894e3bc784097b4de99b70e7e4b600b2776df536 --- /dev/null +++ b/frameworks/kits/ability/ability_runtime/test/unittest/local_call_container_ut_test.cpp @@ -0,0 +1,417 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#define private public +#include "local_call_container.h" +#define protected public +#include "ability_loader.h" +#include "ability_thread.h" +#include "mock_serviceability_manager_service.h" +#include "system_ability_definition.h" +#include "sys_mgr_client.h" + +namespace OHOS { +namespace AppExecFwk { +using namespace testing::ext; +using namespace OHOS::AbilityRuntime; + +namespace { +} +class LocalCallContainerTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void LocalCallContainerTest::SetUpTestCase(void) +{ + OHOS::sptr abilityObject = new (std::nothrow) MockServiceAbilityManagerService(); + + auto sysMgr = OHOS::DelayedSingleton::GetInstance(); + if (sysMgr == NULL) { + GTEST_LOG_(ERROR) << "fail to get ISystemAbilityManager"; + return; + } + + sysMgr->RegisterSystemAbility(OHOS::ABILITY_MGR_SERVICE_ID, abilityObject); +} + +void LocalCallContainerTest::TearDownTestCase(void) +{ + GTEST_LOG_(INFO) << "LocalCallContainerTest::TearDownTestCase end"; +} + +void LocalCallContainerTest::SetUp(void) +{} + +void LocalCallContainerTest::TearDown(void) +{ + GTEST_LOG_(INFO) << "LocalCallContainerTest::TearDown end"; +} + +/** + * @tc.number: Local_Call_Container_StartAbilityInner_0100 + * @tc.name: StartAbility + * @tc.desc: Local Call Container to process StartAbilityInner, and the result is success. + */ +HWTEST_F(LocalCallContainerTest, Local_Call_Container_StartAbilityInner_0100, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "Local_Call_Container_StartAbilityInner_0100::" << + "Local_Call_Container_StartAbilityInner_0100 begain"; + + sptr localCallContainer = new (std::nothrow)LocalCallContainer(); + + Want want; + want.SetElementName("DemoDeviceIdB", "DemoBundleNameB", "DemoAbilityNameB"); + + std::shared_ptr callback = std::make_shared(); + callback->SetCallBack([](const sptr &) {}); + GTEST_LOG_(INFO) << "Local_Call_Container_StartAbilityInner_0100::" << + "Local_Call_Container_StartAbilityInner_0100 begain1"; + ErrCode ret = localCallContainer->StartAbilityInner(want, callback, nullptr); + GTEST_LOG_(INFO) << "Local_Call_Container_StartAbilityInner_0100::" << + "Local_Call_Container_StartAbilityInner_0100 begain2"; + EXPECT_TRUE(ret == ERR_OK); + GTEST_LOG_(INFO) << "Local_Call_Container_StartAbilityInner_0100::" << + "Local_Call_Container_StartAbilityInner_0100 end"; +} + +/** + * @tc.number: Local_Call_Container_StartAbilityInner_0200 + * @tc.name: StartAbility + * @tc.desc: Local Call Container to process StartAbilityInner, and the result is fail because callback is null. + */ +HWTEST_F(LocalCallContainerTest, Local_Call_Container_StartAbilityInner_0200, Function | MediumTest | Level1) +{ + LocalCallContainer localCallContainer; + + Want want; + want.SetElementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + + sptr callRemoteObject = + OHOS::DelayedSingleton::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID); + + ErrCode ret = localCallContainer.StartAbilityInner(want, nullptr, callRemoteObject); + EXPECT_TRUE(ret == ERR_INVALID_VALUE); +} + +/** + * @tc.number: Local_Call_Container_StartAbilityInner_0300 + * @tc.name: StartAbility + * @tc.desc: Local Call Container to process StartAbilityInner, and the result is fail because bundle name is null. + */ +HWTEST_F(LocalCallContainerTest, Local_Call_Container_StartAbilityInner_0300, Function | MediumTest | Level1) +{ + LocalCallContainer localCallContainer; + + Want want; + want.SetElementName("DemoDeviceId", "", "DemoAbilityName"); + + sptr callRemoteObject = + OHOS::DelayedSingleton::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID); + + ErrCode ret = localCallContainer.StartAbilityInner(want, nullptr, callRemoteObject); + EXPECT_TRUE(ret == ERR_INVALID_VALUE); +} + +/** + * @tc.number: Local_Call_Container_StartAbilityInner_0400 + * @tc.name: StartAbility + * @tc.desc: Local Call Container to process StartAbilityInner, and the result is fail because ability name is null. + */ +HWTEST_F(LocalCallContainerTest, Local_Call_Container_StartAbilityInner_0400, Function | MediumTest | Level1) +{ + LocalCallContainer localCallContainer; + + Want want; + want.SetElementName("DemoDeviceId", "DemoBundleName", ""); + + sptr callRemoteObject = + OHOS::DelayedSingleton::GetInstance()->GetSystemAbility(ABILITY_MGR_SERVICE_ID); + + ErrCode ret = localCallContainer.StartAbilityInner(want, nullptr, callRemoteObject); + EXPECT_TRUE(ret == ERR_INVALID_VALUE); +} + +/** + * @tc.number: Local_Call_Container_Release_0100 + * @tc.name: Release + * @tc.desc: Local Call Container to process Release, and the result is success. + */ +HWTEST_F(LocalCallContainerTest, Local_Call_Container_Release_0100, Function | MediumTest | Level1) +{ + sptr localCallContainer = new (std::nothrow)LocalCallContainer(); + + Want want; + want.SetElementName("DemoDeviceId", "DemoBundleName", ""); + + std::shared_ptr callback = std::make_shared(); + + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + std::shared_ptr localCallRecord = std::make_shared(elementName); + localCallRecord->AddCaller(callback); + + callback->SetCallBack([](const sptr &) {}); + + std::string uri = elementName.GetURI(); + localCallContainer->callProxyRecords_.emplace(uri, localCallRecord); + + ErrCode ret = localCallContainer->Release(callback); + EXPECT_TRUE(ret == ERR_OK); +} + +/** + * @tc.number: Local_Call_Container_Release_0200 + * @tc.name: Release + * @tc.desc: Local Call Container to process Release, and the result is fail bacause callProxyRecords_ is null. + */ +HWTEST_F(LocalCallContainerTest, Local_Call_Container_Release_0200, Function | MediumTest | Level1) +{ + sptr localCallContainer = new (std::nothrow)LocalCallContainer(); + + Want want; + want.SetElementName("DemoDeviceId", "DemoBundleName", ""); + + std::shared_ptr callback = std::make_shared(); + + callback->SetCallBack([](const sptr &) {}); + + ErrCode ret = localCallContainer->Release(callback); + EXPECT_TRUE(ret == ERR_INVALID_VALUE); +} + +/** + * @tc.number: Local_Call_Container_DumpCalls_0100 + * @tc.name: DumpCalls + * @tc.desc: Local Call Container to process DumpCalls, and the result is success(call back is called). + */ +HWTEST_F(LocalCallContainerTest, Local_Call_Container_DumpCalls_0100, Function | MediumTest | Level1) +{ + LocalCallContainer localCallContainer; + + std::shared_ptr callback = std::make_shared(); + callback->isCallBack_ = true; + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + std::shared_ptr localCallRecord = std::make_shared(elementName); + localCallRecord->AddCaller(callback); + + std::string uri = elementName.GetURI(); + localCallContainer.callProxyRecords_.emplace(uri, localCallRecord); + + std::vector info; + std::string resultReceiver = ""; + EXPECT_TRUE(resultReceiver == ""); + localCallContainer.DumpCalls(info); + + for (auto it : info) { + GTEST_LOG_(ERROR) << it; + resultReceiver += it + "\n"; + } + string::size_type idx; + idx = resultReceiver.find("REQUESTEND"); + EXPECT_TRUE(idx != string::npos); +} + +/** + * @tc.number: Local_Call_Container_DumpCalls_0200 + * @tc.name: DumpCalls + * @tc.desc: Local Call Container to process DumpCalls, and the result is success(call back is not called). + */ +HWTEST_F(LocalCallContainerTest, Local_Call_Container_DumpCalls_0200, Function | MediumTest | Level1) +{ + LocalCallContainer localCallContainer; + + std::shared_ptr callback = std::make_shared(); + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + std::shared_ptr localCallRecord = std::make_shared(elementName); + localCallRecord->AddCaller(callback); + + std::string uri = elementName.GetURI(); + localCallContainer.callProxyRecords_.emplace(uri, localCallRecord); + + std::vector info; + std::string resultReceiver = ""; + std::string::size_type idx; + idx = resultReceiver.find("REQUESTING"); + EXPECT_FALSE(idx != string::npos); + localCallContainer.DumpCalls(info); + + for (auto it : info) { + resultReceiver += it + "\n"; + } + idx = resultReceiver.find("REQUESTING"); + EXPECT_TRUE(idx != string::npos); +} + +/** + * @tc.number: Local_Call_Container_DumpCalls_0300 + * @tc.name: DumpCalls + * @tc.desc: Local Call Container to process DumpCalls, and the result is success(no caller). + */ +HWTEST_F(LocalCallContainerTest, Local_Call_Container_DumpCalls_0300, Function | MediumTest | Level1) +{ + LocalCallContainer localCallContainer; + + std::shared_ptr callback = std::make_shared(); + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + std::shared_ptr localCallRecord = std::make_shared(elementName); + + std::string uri = elementName.GetURI(); + localCallContainer.callProxyRecords_.emplace(uri, localCallRecord); + + std::vector info; + std::string resultReceiver = ""; + std::string::size_type idx; + idx = resultReceiver.find("REQUESTEND"); + EXPECT_FALSE(idx != string::npos); + localCallContainer.DumpCalls(info); + + for (auto it : info) { + resultReceiver += it + "\n"; + } + + idx = resultReceiver.find("REQUESTEND"); + EXPECT_TRUE(idx != string::npos); +} + +/** + * @tc.number: Local_Call_Container_DumpCalls_0400 + * @tc.name: DumpCalls + * @tc.desc: Local Call Container to process DumpCalls, and the result is success(callProxyRecords_ is empty). + */ +HWTEST_F(LocalCallContainerTest, Local_Call_Container_DumpCalls_0400, Function | MediumTest | Level1) +{ + LocalCallContainer localCallContainer; + + std::vector info; + std::string resultReceiver = ""; + EXPECT_TRUE(resultReceiver == ""); + localCallContainer.DumpCalls(info); + EXPECT_TRUE(resultReceiver == ""); +} + +/** + * @tc.number: Local_Call_Container_OnAbilityConnectDone_0100 + * @tc.name: OnAbilityConnectDone + * @tc.desc: Local Call Container to process OnAbilityConnectDone, and the result is success resultCode == ERR_OK. + */ +HWTEST_F(LocalCallContainerTest, Local_Call_Container_OnAbilityConnectDone_0100, Function | MediumTest | Level1) +{ + LocalCallContainer localCallContainer; + + std::shared_ptr callback = std::make_shared(); + callback->SetCallBack([](const sptr &) {}); + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + std::shared_ptr localCallRecord = std::make_shared(elementName); + localCallRecord->AddCaller(callback); + localCallRecord->callers_.emplace_back(callback); + + std::string uri = elementName.GetURI(); + localCallContainer.callProxyRecords_.emplace(uri, localCallRecord); + + OHOS::sptr remoteObject = new (std::nothrow) MockServiceAbilityManagerService(); + + localCallContainer.OnAbilityConnectDone(elementName, remoteObject, 0); + EXPECT_EQ(callback->isCallBack_, true); +} + +/** + * @tc.number: Local_Call_Container_OnAbilityConnectDone_0200 + * @tc.name: OnAbilityConnectDone + * @tc.desc: Local Call Container to process OnAbilityConnectDone success when resultCode != ERR_OK. + */ +HWTEST_F(LocalCallContainerTest, Local_Call_Container_OnAbilityConnectDone_0200, Function | MediumTest | Level1) +{ + LocalCallContainer localCallContainer; + + std::shared_ptr callback = std::make_shared(); + callback->SetCallBack([](const sptr &) {}); + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + std::shared_ptr localCallRecord = std::make_shared(elementName); + localCallRecord->AddCaller(callback); + localCallRecord->callers_.emplace_back(callback); + + std::string uri = elementName.GetURI(); + localCallContainer.callProxyRecords_.emplace(uri, localCallRecord); + + OHOS::sptr remoteObject = new (std::nothrow) MockServiceAbilityManagerService(); + + localCallContainer.OnAbilityConnectDone(elementName, remoteObject, -1); + EXPECT_EQ(callback->isCallBack_, true); +} + +/** + * @tc.number: Local_Call_Container_OnAbilityConnectDone_0300 + * @tc.name: OnAbilityConnectDone + * @tc.desc: Local Call Container to process OnAbilityConnectDone fail because localCallRecord is null. + */ +HWTEST_F(LocalCallContainerTest, Local_Call_Container_OnAbilityConnectDone_0300, Function | MediumTest | Level1) +{ + LocalCallContainer localCallContainer; + + std::shared_ptr callback = std::make_shared(); + EXPECT_EQ(callback->isCallBack_, false); + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + std::shared_ptr localCallRecord = std::make_shared(elementName); + localCallRecord->AddCaller(callback); + + OHOS::sptr remoteObject = new (std::nothrow) MockServiceAbilityManagerService(); + + localCallContainer.OnAbilityConnectDone(elementName, remoteObject, 0); + EXPECT_EQ(callback->isCallBack_, false); +} + +/** + * @tc.number: Local_Call_Container_GetCallLocalreocrd_0100 + * @tc.name: GetCallLocalreocrd + * @tc.desc: Local Call Container to process GetCallLocalreocrd, and the result is success. + */ +HWTEST_F(LocalCallContainerTest, Local_Call_Container_GetCallLocalreocrd_0100, Function | MediumTest | Level1) +{ + LocalCallContainer localCallContainer; + + std::shared_ptr callback = std::make_shared(); + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + std::shared_ptr localCallRecord = std::make_shared(elementName); + localCallRecord->AddCaller(callback); + + std::string uri = elementName.GetURI(); + localCallContainer.callProxyRecords_.emplace(uri, localCallRecord); + + bool ret = localCallContainer.GetCallLocalreocrd(elementName, localCallRecord); + EXPECT_TRUE(ret == true); +} + +/** + * @tc.number: Local_Call_Container_GetCallLocalreocrd_0100 + * @tc.name: GetCallLocalreocrd + * @tc.desc: Local Call Container to process GetCallLocalreocrd, and the result is fail + * because call proxy records is empty. + */ +HWTEST_F(LocalCallContainerTest, Local_Call_Container_GetCallLocalreocrd_0200, Function | MediumTest | Level1) +{ + LocalCallContainer localCallContainer; + + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + std::shared_ptr localCallRecord = std::make_shared(elementName); + + bool ret = localCallContainer.GetCallLocalreocrd(elementName, localCallRecord); + EXPECT_TRUE(ret == false); +} +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/kits/ability/ability_runtime/test/unittest/local_call_record_ut_test.cpp b/frameworks/kits/ability/ability_runtime/test/unittest/local_call_record_ut_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a31e072f5d72bd4cd8953b1316042bae1c997dd6 --- /dev/null +++ b/frameworks/kits/ability/ability_runtime/test/unittest/local_call_record_ut_test.cpp @@ -0,0 +1,315 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "ability_loader.h" +#include "ability_thread.h" +#include "mock_serviceability_manager_service.h" +#define private public +#include "local_call_record.h" +#define protected public +#include "system_ability_definition.h" +#include "sys_mgr_client.h" + +namespace OHOS { +namespace AppExecFwk { +using namespace testing::ext; +using namespace OHOS::AbilityRuntime; + +namespace { +} + +class LocalCallRecordTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +public: + std::unique_ptr context_ = nullptr; +}; + +void LocalCallRecordTest::SetUpTestCase(void) +{ + OHOS::sptr abilityObject = new (std::nothrow) MockServiceAbilityManagerService(); + + auto sysMgr = OHOS::DelayedSingleton::GetInstance(); + if (sysMgr == NULL) { + GTEST_LOG_(ERROR) << "fail to get ISystemAbilityManager"; + return; + } + sysMgr->RegisterSystemAbility(OHOS::ABILITY_MGR_SERVICE_ID, abilityObject); +} + +void LocalCallRecordTest::TearDownTestCase(void) +{} + +void LocalCallRecordTest::SetUp(void) +{} + +void LocalCallRecordTest::TearDown(void) +{} + +/** + * @tc.number: Local_Call_Record_SetRemoteObject_0100 + * @tc.name: SetRemoteObject + * @tc.desc: LocalCallRecord to process SetRemoteObject success. + */ +HWTEST_F(LocalCallRecordTest, Local_Call_Record_SetRemoteObject_0100, Function | MediumTest | Level1) +{ + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + LocalCallRecord localCallRecord(elementName); + EXPECT_TRUE(localCallRecord.callRecipient_ == nullptr); + sptr call = new (std::nothrow) MockServiceAbilityManagerService(); + EXPECT_TRUE(call != nullptr); + localCallRecord.SetRemoteObject(call); + EXPECT_TRUE(localCallRecord.callRecipient_ != nullptr); + EXPECT_TRUE(localCallRecord.remoteObject_ != nullptr); +} + +/** + * @tc.number: Local_Call_Record_SetRemoteObject_0200 + * @tc.name: SetRemoteObject + * @tc.desc: LocalCallRecord to process SetRemoteObject fail because call back is null. + */ +HWTEST_F(LocalCallRecordTest, Local_Call_Record_SetRemoteObject_0200, Function | MediumTest | Level1) +{ + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + LocalCallRecord localCallRecord(elementName); + EXPECT_TRUE(localCallRecord.callRecipient_ == nullptr); + localCallRecord.SetRemoteObject(nullptr); + EXPECT_TRUE(localCallRecord.callRecipient_ == nullptr); + EXPECT_TRUE(localCallRecord.remoteObject_ == nullptr); +} + +/** + * @tc.number: Local_Call_Record_AddCaller_0100 + * @tc.name: AddCaller + * @tc.desc: LocalCallRecord to process AddCaller success. + */ +HWTEST_F(LocalCallRecordTest, Local_Call_Record_AddCaller_0100, Function | MediumTest | Level1) +{ + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + LocalCallRecord localCallRecord(elementName); + EXPECT_TRUE(localCallRecord.callers_.size() == 0); + std::shared_ptr callback = std::make_shared(); + localCallRecord.AddCaller(callback); + EXPECT_TRUE(localCallRecord.callers_.size() != 0); +} + +/** + * @tc.number: Local_Call_Record_RemoveCaller_0100 + * @tc.name: RemoveCaller + * @tc.desc: LocalCallRecord to process RemoveCaller success. + */ +HWTEST_F(LocalCallRecordTest, Local_Call_Record_RemoveCaller_0100, Function | MediumTest | Level1) +{ + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + LocalCallRecord localCallRecord(elementName); + std::shared_ptr callback = std::make_shared(); + localCallRecord.callers_.emplace_back(callback); + bool ret = localCallRecord.RemoveCaller(callback); + EXPECT_EQ(ret, true); +} + +/** + * @tc.number: Local_Call_Record_RemoveCaller_0200 + * @tc.name: RemoveCaller + * @tc.desc: LocalCallRecord to process RemoveCaller fail because callers_ is empty. + */ +HWTEST_F(LocalCallRecordTest, Local_Call_Record_RemoveCaller_0200, Function | MediumTest | Level1) +{ + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + LocalCallRecord localCallRecord(elementName); + std::shared_ptr callback = std::make_shared(); + bool ret = localCallRecord.RemoveCaller(callback); + EXPECT_EQ(ret, false); +} + + /** + * @tc.number: Local_Call_Record_RemoveCaller_0300 + * @tc.name: RemoveCaller + * @tc.desc: LocalCallRecord to process RemoveCaller fail because not find call back. + */ +HWTEST_F(LocalCallRecordTest, Local_Call_Record_RemoveCaller_0300, Function | MediumTest | Level1) +{ + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + LocalCallRecord localCallRecord(elementName); + std::shared_ptr callback = std::make_shared(); + localCallRecord.callers_.emplace_back(callback); + std::shared_ptr callback1 = std::make_shared(); + bool ret = localCallRecord.RemoveCaller(callback1); + EXPECT_EQ(ret, false); +} + + /** + * @tc.number: Local_Call_Record_OnCallStubDied_0100 + * @tc.name: OnCallStubDied + * @tc.desc: LocalCallRecord to process OnCallStubDied success. + */ +HWTEST_F(LocalCallRecordTest, Local_Call_Record_OnCallStubDied_0100, Function | MediumTest | Level1) +{ + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + LocalCallRecord localCallRecord(elementName); + std::shared_ptr callback = std::make_shared(); + callback->SetOnRelease([](const std::string &result) { + GTEST_LOG_(ERROR) << "OnRelease-----------" << result; + EXPECT_TRUE(result == "died"); + }); + localCallRecord.callers_.emplace_back(callback); + localCallRecord.OnCallStubDied(nullptr); +} + + /** + * @tc.number: Local_Call_Record_OnCallStubDied_0200 + * @tc.name: OnCallStubDied + * @tc.desc: LocalCallRecord to process OnCallStubDied fail because callers_ is empty. + */ +HWTEST_F(LocalCallRecordTest, Local_Call_Record_OnCallStubDied_0200, Function | MediumTest | Level1) +{ + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + LocalCallRecord localCallRecord(elementName); + std::shared_ptr callback = std::make_shared(); + callback->SetOnRelease([](const std::string &result) { + GTEST_LOG_(ERROR) << "OnRelease-----------" << result; + EXPECT_TRUE(result != "died"); + }); + localCallRecord.OnCallStubDied(nullptr); +} + + /** + * @tc.number: Local_Call_Record_OnCallStubDied_0300 + * @tc.name: OnCallStubDied + * @tc.desc: LocalCallRecord to process OnCallStubDied fail because callback is null. + */ +HWTEST_F(LocalCallRecordTest, Local_Call_Record_OnCallStubDied_0300, Function | MediumTest | Level1) +{ + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + LocalCallRecord localCallRecord(elementName); + std::shared_ptr callback = std::make_shared(); + callback->SetOnRelease([](const std::string &result) { + GTEST_LOG_(ERROR) << "OnRelease-----------" << result; + EXPECT_TRUE(result != "died"); + }); + localCallRecord.callers_.emplace_back(nullptr); + localCallRecord.OnCallStubDied(nullptr); +} + + /** + * @tc.number: Local_Call_Record_InvokeCallBack_0100 + * @tc.name: InvokeCallBack + * @tc.desc: LocalCallRecord to process InvokeCallBack success. + */ +HWTEST_F(LocalCallRecordTest, Local_Call_Record_InvokeCallBack_0100, Function | MediumTest | Level1) +{ + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + LocalCallRecord localCallRecord(elementName); + localCallRecord.remoteObject_ = new (std::nothrow) MockServiceAbilityManagerService(); + std::shared_ptr callback = std::make_shared(); + callback->SetCallBack([](const sptr &) {}); + EXPECT_TRUE(callback->IsCallBack() == false); + localCallRecord.callers_.emplace_back(callback); + localCallRecord.InvokeCallBack(); + EXPECT_TRUE(callback->IsCallBack() == true); +} + + /** + * @tc.number: Local_Call_Record_InvokeCallBack_0200 + * @tc.name: InvokeCallBack + * @tc.desc: LocalCallRecord to process InvokeCallBack fail because remote is null. + */ +HWTEST_F(LocalCallRecordTest, Local_Call_Record_InvokeCallBack_0200, Function | MediumTest | Level1) +{ + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + LocalCallRecord localCallRecord(elementName); + std::shared_ptr callback = std::make_shared(); + EXPECT_TRUE(callback->IsCallBack() == false); + localCallRecord.InvokeCallBack(); + EXPECT_TRUE(callback->IsCallBack() == false); +} + + /** + * @tc.number: Local_Call_Record_InvokeCallBack_0300 + * @tc.name: InvokeCallBack + * @tc.desc: LocalCallRecord to process InvokeCallBack fail because callers_ is empty. + */ +HWTEST_F(LocalCallRecordTest, Local_Call_Record_InvokeCallBack_0300, Function | MediumTest | Level1) +{ + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + LocalCallRecord localCallRecord(elementName); + localCallRecord.remoteObject_ = new (std::nothrow) MockServiceAbilityManagerService(); + std::shared_ptr callback = std::make_shared(); + EXPECT_TRUE(callback->IsCallBack() == false); + localCallRecord.InvokeCallBack(); + EXPECT_TRUE(callback->IsCallBack() == false); +} + + /** + * @tc.number: Local_Call_Record_InvokeCallBack_0400 + * @tc.name: InvokeCallBack + * @tc.desc: LocalCallRecord to process InvokeCallBack fail because call back is null. + */ +HWTEST_F(LocalCallRecordTest, Local_Call_Record_InvokeCallBack_0400, Function | MediumTest | Level1) +{ + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + LocalCallRecord localCallRecord(elementName); + localCallRecord.remoteObject_ = new (std::nothrow) MockServiceAbilityManagerService(); + std::shared_ptr callback = std::make_shared(); + EXPECT_TRUE(callback->IsCallBack() == false); + localCallRecord.callers_.emplace_back(nullptr); + localCallRecord.InvokeCallBack(); + EXPECT_TRUE(callback->IsCallBack() == false); +} + + /** + * @tc.number: Local_Call_Record_GetRemoteObject_0100 + * @tc.name: GetRemoteObject + * @tc.desc: LocalCallRecord to process GetRemoteObject success. + */ +HWTEST_F(LocalCallRecordTest, Local_Call_Record_GetRemoteObject_0100, Function | MediumTest | Level1) +{ + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + LocalCallRecord localCallRecord(elementName); + localCallRecord.remoteObject_ = new (std::nothrow) MockServiceAbilityManagerService(); + EXPECT_TRUE(localCallRecord.GetRemoteObject() != nullptr); +} + + /** + * @tc.number: Local_Call_Record_GetElementName_0100 + * @tc.name: GetElementName + * @tc.desc: LocalCallRecord to process GetElementName success. + */ +HWTEST_F(LocalCallRecordTest, Local_Call_Record_GetElementName_0100, Function | MediumTest | Level1) +{ + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + LocalCallRecord localCallRecord(elementName); + EXPECT_TRUE(localCallRecord.GetElementName().GetBundleName() == "DemoBundleName"); +} + + /** + * @tc.number: Local_Call_Record_IsExistCallBack_0100 + * @tc.name: IsExistCallBack + * @tc.desc: LocalCallRecord to process success. + */ +HWTEST_F(LocalCallRecordTest, Local_Call_Record_IsExistCallBack_0100, Function | MediumTest | Level1) +{ + AppExecFwk::ElementName elementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + LocalCallRecord localCallRecord(elementName); + std::shared_ptr callback = std::make_shared(); + localCallRecord.AddCaller(callback); + EXPECT_TRUE(localCallRecord.IsExistCallBack() == true); +} +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/kits/ability/native/include/ability_runtime/js_ability.h b/frameworks/kits/ability/native/include/ability_runtime/js_ability.h index 989495a67579ef4c723e0fcb4f6e5ca04309ef37..3b740e5726fd51c0ae598fb5dfa64fff6cbb87d1 100755 --- a/frameworks/kits/ability/native/include/ability_runtime/js_ability.h +++ b/frameworks/kits/ability/native/include/ability_runtime/js_ability.h @@ -77,6 +77,7 @@ private: JsRuntime &jsRuntime_; std::shared_ptr shellContextRef_; std::unique_ptr jsAbilityObj_; + sptr remoteCallee_; }; } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/kits/ability/native/src/ability_runtime/js_ability.cpp b/frameworks/kits/ability/native/src/ability_runtime/js_ability.cpp index 5e6d332fa6309d805aa0c84d5f0bfb7e387fe9c9..484d2f1855196b694f47d714441ea0ea84f7e522 100755 --- a/frameworks/kits/ability/native/src/ability_runtime/js_ability.cpp +++ b/frameworks/kits/ability/native/src/ability_runtime/js_ability.cpp @@ -370,6 +370,12 @@ sptr JsAbility::CallRequest() HILOG_WARN("JsAbility::CallRequest Obj is nullptr"); return nullptr; } + + if (remoteCallee_ != nullptr) { + HILOG_INFO("JsAbility::CallRequest get Callee remoteObj."); + return remoteCallee_; + } + HandleScope handleScope(jsRuntime_); HILOG_DEBUG("JsAbility::CallRequest set runtime scope."); auto& nativeEngine = jsRuntime_.GetNativeEngine(); @@ -403,8 +409,9 @@ sptr JsAbility::CallRequest() HILOG_ERROR("JsAbility::CallRequest obj is nullptr"); } + remoteCallee_ = remoteObj; HILOG_INFO("JsAbility::CallRequest end."); - return remoteObj; + return remoteCallee_; } void JsAbility::OnRequestPermissionsFromUserResult( diff --git a/frameworks/kits/ability/native/src/ability_runtime/js_caller_complex.cpp b/frameworks/kits/ability/native/src/ability_runtime/js_caller_complex.cpp index 76b16908e1db9803802758bc4062d9a01ce0a494..699329cb22fc730619d579427c8eb6b14a5b3505 100644 --- a/frameworks/kits/ability/native/src/ability_runtime/js_caller_complex.cpp +++ b/frameworks/kits/ability/native/src/ability_runtime/js_caller_complex.cpp @@ -58,6 +58,7 @@ public: return; } std::unique_ptr(static_cast(data)); + HILOG_ERROR("JsCallerComplex::%{public}s is called.", __func__); } static NativeValue* JsRelease(NativeEngine* engine, NativeCallbackInfo* info) @@ -112,7 +113,7 @@ private: } auto task = [notify = this, &str] () { notify->OnReleaseNotifyTask(str); }; - handler_->PostTask(task, "OnReleaseNotify"); + handler_->PostSyncTask(task, "OnReleaseNotify"); HILOG_DEBUG("OnReleaseNotify end"); } diff --git a/frameworks/kits/ability/native/src/new_ability_impl.cpp b/frameworks/kits/ability/native/src/new_ability_impl.cpp index 78f08b58884b401cc5fee58db5dc66810965056e..0fc4d7d53fddade706c7ccbfaa0aa7ad9c16f4c7 100644 --- a/frameworks/kits/ability/native/src/new_ability_impl.cpp +++ b/frameworks/kits/ability/native/src/new_ability_impl.cpp @@ -95,8 +95,10 @@ bool NewAbilityImpl::AbilityTransaction(const Want &want, const AAFwk::LifeCycle break; } case AAFwk::ABILITY_STATE_BACKGROUND_NEW: { + if (lifecycleState_ != ABILITY_STATE_STARTED_NEW) { + ret = false; + } Background(); - ret = false; break; } default: { diff --git a/frameworks/kits/ability/native/test/BUILD.gn b/frameworks/kits/ability/native/test/BUILD.gn index 3191a85b5a0650330884de957a42548725e94c87..7f6dad1fb2efb34ff620aef3a395e5214b918c0c 100644 --- a/frameworks/kits/ability/native/test/BUILD.gn +++ b/frameworks/kits/ability/native/test/BUILD.gn @@ -593,6 +593,33 @@ ohos_unittest("ability_thread_test") { ] } +ohos_unittest("ability_thread_call_request_test") { + module_out_path = module_output_path + sources = [ + "//foundation/aafwk/standard/frameworks/kits/appkit/native/app/src/context_container.cpp", + "//foundation/aafwk/standard/interfaces/innerkits/app_manager/src/appmgr/configuration.cpp", + "unittest/ability_thread_call_request_test.cpp", + ] + + configs = [ ":module_private_config" ] + + deps = [ + "${INNERKITS_PATH}/want:want", + "//foundation/aafwk/standard/common/task_dispatcher:task_dispatcher", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//foundation/aafwk/standard/frameworks/kits/appkit:app_context", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/appexecfwk/standard/common:libappexecfwk_common", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler:libeventhandler", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy:samgr_proxy", + "//third_party/googletest:gtest_main", + ] + + external_deps = [ "ability_runtime:runtime" ] +} + ohos_unittest("form_provider_client_test") { module_out_path = module_output_path include_dirs = [ @@ -1092,6 +1119,7 @@ group("unittest") { ":ability_permission_test", # ":ability_test", + ":ability_thread_call_request_test", ":ability_thread_dataability_test", ":ability_thread_test", ":continuation_test", diff --git a/frameworks/kits/ability/native/test/unittest/ability_thread_call_request_test.cpp b/frameworks/kits/ability/native/test/unittest/ability_thread_call_request_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..07ca9b8f1baf1b176c7a395c2a7c0cffc38dc2ba --- /dev/null +++ b/frameworks/kits/ability/native/test/unittest/ability_thread_call_request_test.cpp @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#define private public +#include "ability_thread.h" +#define protected public +#include "system_ability_definition.h" +#include "sys_mgr_client.h" + +namespace OHOS { +namespace AppExecFwk { +using namespace testing::ext; +using namespace OHOS; +using namespace OHOS::AppExecFwk; +class CurrentAbilityTest : public Ability { +public: + sptr CallRequest() + { + sptr remoteObject = + OHOS::DelayedSingleton::GetInstance() + ->GetSystemAbility(ABILITY_MGR_SERVICE_ID); + return remoteObject; + } +}; + +class AbilityThreadCallRequestTest : public testing::Test { +public: + AbilityThreadCallRequestTest() : abilitythread_(nullptr) + {} + ~AbilityThreadCallRequestTest() + { + abilitythread_ = nullptr; + } + AbilityThread *abilitythread_; + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void AbilityThreadCallRequestTest::SetUpTestCase(void) +{} + +void AbilityThreadCallRequestTest::TearDownTestCase(void) +{} + +void AbilityThreadCallRequestTest::SetUp(void) +{ + GTEST_LOG_(INFO) << "AbilityThreadCallRequestTest SetUp"; +} + +void AbilityThreadCallRequestTest::TearDown(void) +{ + GTEST_LOG_(INFO) << "AbilityThreadCallRequestTest TearDown"; +} + + +/** + * @tc.number: AaFwk_AbilityThread_CallRequest_0100 + * @tc.name: CallRequest + * @tc.desc: CallRequest success + */ +HWTEST_F(AbilityThreadCallRequestTest, AaFwk_AbilityThread_CallRequest_0100, Function | MediumTest | Level3) +{ + GTEST_LOG_(INFO) << "AaFwk_AbilityThread_CallRequest_0100 start"; + + AbilityThread *abilitythread = new (std::nothrow) AbilityThread(); + EXPECT_NE(abilitythread, nullptr); + if (abilitythread != nullptr) { + abilitythread->currentAbility_ = std::make_shared(); + EXPECT_NE(abilitythread->currentAbility_, nullptr); + auto runner = EventRunner::Create(true); + abilitythread->abilityHandler_ = std::make_shared(runner, abilitythread); + EXPECT_NE(abilitythread->abilityHandler_, nullptr); + sptr retval = nullptr; + retval = abilitythread->CallRequest(); + EXPECT_TRUE(retval != nullptr); + } + GTEST_LOG_(INFO) << "AaFwk_AbilityThread_CallRequest_0100 end"; +} + +/** + * @tc.number: AaFwk_AbilityThread_CallRequest_0200 + * @tc.name: CallRequest + * @tc.desc: CallRequest success fail because currentAbility_ is null + */ +HWTEST_F(AbilityThreadCallRequestTest, AaFwk_AbilityThread_CallRequest_0200, Function | MediumTest | Level3) +{ + GTEST_LOG_(INFO) << "AaFwk_AbilityThread_CallRequest_0200 start"; + AbilityThread *abilitythread = new (std::nothrow) AbilityThread(); + sptr retval = abilitythread->CallRequest(); + EXPECT_TRUE(retval == nullptr); + GTEST_LOG_(INFO) << "AaFwk_AbilityThread_CallRequest_0200 end"; +} + +/** + * @tc.number: AaFwk_AbilityThread_CallRequest_0300 + * @tc.name: CallRequest + * @tc.desc: CallRequest success fail because abilityHandler_ is null + */ +HWTEST_F(AbilityThreadCallRequestTest, AaFwk_AbilityThread_CallRequest_0300, Function | MediumTest | Level3) +{ + GTEST_LOG_(INFO) << "AaFwk_AbilityThread_CallRequest_0300 start"; + + AbilityThread *abilitythread = new (std::nothrow) AbilityThread(); + EXPECT_NE(abilitythread, nullptr); + if (abilitythread != nullptr) { + abilitythread->currentAbility_ = std::make_shared(); + EXPECT_NE(abilitythread->currentAbility_, nullptr); + sptr retval = abilitythread->CallRequest(); + EXPECT_TRUE(retval == nullptr); + } + GTEST_LOG_(INFO) << "AaFwk_AbilityThread_CallRequest_0300 end"; +} +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/kits/test/BUILD.gn b/frameworks/kits/test/BUILD.gn index e1129fb323667b18948a2e9c00d120618c9816a2..26a6bc09f77e6fe78b27faf43955bffb6e6120fe 100644 --- a/frameworks/kits/test/BUILD.gn +++ b/frameworks/kits/test/BUILD.gn @@ -181,6 +181,33 @@ ohos_moduletest("ability_conetxt_test") { ] } +ohos_moduletest("ability_thread_call_request_module_test") { + module_out_path = module_output_path + sources = [ + "//foundation/aafwk/standard/frameworks/kits/appkit/native/app/src/context_container.cpp", + "//foundation/aafwk/standard/frameworks/kits/test/moduletest/cpp/abilitytest/ability_thread_call_request_module_test.cpp", + "//foundation/aafwk/standard/interfaces/innerkits/app_manager/src/appmgr/configuration.cpp", + ] + + configs = [ ":module_private_config" ] + + deps = [ + "//foundation/aafwk/standard/common/task_dispatcher:task_dispatcher", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//foundation/aafwk/standard/frameworks/kits/appkit:app_context", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/aafwk/standard/interfaces/innerkits/want:want", + "//foundation/appexecfwk/standard/common:libappexecfwk_common", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler:libeventhandler", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy:samgr_proxy", + "//third_party/googletest:gtest_main", + ] + + external_deps = [ "ability_runtime:runtime" ] +} + ohos_moduletest("data_ability_operation_moduletest") { module_out_path = module_output_path sources = [ @@ -307,6 +334,7 @@ group("moduletest") { if (is_phone_product) { deps += [ ":ability_conetxt_test", + ":ability_thread_call_request_module_test", # ":ability_moduletest", ":data_ability_helper_module_test", diff --git a/frameworks/kits/test/moduletest/cpp/abilitytest/ability_thread_call_request_module_test.cpp b/frameworks/kits/test/moduletest/cpp/abilitytest/ability_thread_call_request_module_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..07ca9b8f1baf1b176c7a395c2a7c0cffc38dc2ba --- /dev/null +++ b/frameworks/kits/test/moduletest/cpp/abilitytest/ability_thread_call_request_module_test.cpp @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#define private public +#include "ability_thread.h" +#define protected public +#include "system_ability_definition.h" +#include "sys_mgr_client.h" + +namespace OHOS { +namespace AppExecFwk { +using namespace testing::ext; +using namespace OHOS; +using namespace OHOS::AppExecFwk; +class CurrentAbilityTest : public Ability { +public: + sptr CallRequest() + { + sptr remoteObject = + OHOS::DelayedSingleton::GetInstance() + ->GetSystemAbility(ABILITY_MGR_SERVICE_ID); + return remoteObject; + } +}; + +class AbilityThreadCallRequestTest : public testing::Test { +public: + AbilityThreadCallRequestTest() : abilitythread_(nullptr) + {} + ~AbilityThreadCallRequestTest() + { + abilitythread_ = nullptr; + } + AbilityThread *abilitythread_; + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void AbilityThreadCallRequestTest::SetUpTestCase(void) +{} + +void AbilityThreadCallRequestTest::TearDownTestCase(void) +{} + +void AbilityThreadCallRequestTest::SetUp(void) +{ + GTEST_LOG_(INFO) << "AbilityThreadCallRequestTest SetUp"; +} + +void AbilityThreadCallRequestTest::TearDown(void) +{ + GTEST_LOG_(INFO) << "AbilityThreadCallRequestTest TearDown"; +} + + +/** + * @tc.number: AaFwk_AbilityThread_CallRequest_0100 + * @tc.name: CallRequest + * @tc.desc: CallRequest success + */ +HWTEST_F(AbilityThreadCallRequestTest, AaFwk_AbilityThread_CallRequest_0100, Function | MediumTest | Level3) +{ + GTEST_LOG_(INFO) << "AaFwk_AbilityThread_CallRequest_0100 start"; + + AbilityThread *abilitythread = new (std::nothrow) AbilityThread(); + EXPECT_NE(abilitythread, nullptr); + if (abilitythread != nullptr) { + abilitythread->currentAbility_ = std::make_shared(); + EXPECT_NE(abilitythread->currentAbility_, nullptr); + auto runner = EventRunner::Create(true); + abilitythread->abilityHandler_ = std::make_shared(runner, abilitythread); + EXPECT_NE(abilitythread->abilityHandler_, nullptr); + sptr retval = nullptr; + retval = abilitythread->CallRequest(); + EXPECT_TRUE(retval != nullptr); + } + GTEST_LOG_(INFO) << "AaFwk_AbilityThread_CallRequest_0100 end"; +} + +/** + * @tc.number: AaFwk_AbilityThread_CallRequest_0200 + * @tc.name: CallRequest + * @tc.desc: CallRequest success fail because currentAbility_ is null + */ +HWTEST_F(AbilityThreadCallRequestTest, AaFwk_AbilityThread_CallRequest_0200, Function | MediumTest | Level3) +{ + GTEST_LOG_(INFO) << "AaFwk_AbilityThread_CallRequest_0200 start"; + AbilityThread *abilitythread = new (std::nothrow) AbilityThread(); + sptr retval = abilitythread->CallRequest(); + EXPECT_TRUE(retval == nullptr); + GTEST_LOG_(INFO) << "AaFwk_AbilityThread_CallRequest_0200 end"; +} + +/** + * @tc.number: AaFwk_AbilityThread_CallRequest_0300 + * @tc.name: CallRequest + * @tc.desc: CallRequest success fail because abilityHandler_ is null + */ +HWTEST_F(AbilityThreadCallRequestTest, AaFwk_AbilityThread_CallRequest_0300, Function | MediumTest | Level3) +{ + GTEST_LOG_(INFO) << "AaFwk_AbilityThread_CallRequest_0300 start"; + + AbilityThread *abilitythread = new (std::nothrow) AbilityThread(); + EXPECT_NE(abilitythread, nullptr); + if (abilitythread != nullptr) { + abilitythread->currentAbility_ = std::make_shared(); + EXPECT_NE(abilitythread->currentAbility_, nullptr); + sptr retval = abilitythread->CallRequest(); + EXPECT_TRUE(retval == nullptr); + } + GTEST_LOG_(INFO) << "AaFwk_AbilityThread_CallRequest_0300 end"; +} +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/kits/napi/aafwk/caller/caller.js b/interfaces/kits/napi/aafwk/caller/caller.js index 92cc5af9100711e2dac4cbf78bc94697f1113ee3..4ec2764a9e6bea46d5f8c20283bfda000252b336 100644 --- a/interfaces/kits/napi/aafwk/caller/caller.js +++ b/interfaces/kits/napi/aafwk/caller/caller.js @@ -58,6 +58,8 @@ class Caller { let status = await this.__call_obj__.callee.sendRequest(EVENT_CALL_NOTIFY, msgData, msgReply, option); if (!status) { + msgData.reclaim(); + msgReply.reclaim(); console.log("Caller call return status " + status); throw new Error("Function execution exception"); return ; @@ -67,6 +69,8 @@ class Caller { let str = msgReply.readString(); if (retval === REQUEST_SUCCESS && str === 'object') { console.log("Caller call return str " + str); + msgData.reclaim(); + msgReply.reclaim(); } else { console.log("Caller call retval is [" + retval + "], str [" + str + "]"); msgData.reclaim(); @@ -109,6 +113,8 @@ class Caller { let status = await this.__call_obj__.callee.sendRequest(EVENT_CALL_NOTIFY, msgData, msgReply, option); if (!status) { console.log("Caller callWithResult return data " + status); + msgData.reclaim(); + msgReply.reclaim(); return reply; } @@ -117,6 +123,7 @@ class Caller { if (retval === REQUEST_SUCCESS && str === 'object') { reply = msgReply; console.log("Caller callWithResult return data " + str); + msgData.reclaim(); } else { console.log("Caller callWithResult retval is [" + retval + "], str [" + str + "]"); msgData.reclaim(); diff --git a/ohos.build b/ohos.build index 7dd1884617d45bc23bb582abc48578ef4e5dcaa3..05bcbb7bf511defd0b3fcc1655c29418cc88fe39 100644 --- a/ohos.build +++ b/ohos.build @@ -118,7 +118,8 @@ "test_list": [ "//foundation/aafwk/standard/frameworks/kits/content/cpp/test:unittest", "//foundation/aafwk/standard/frameworks/kits/ability/native/test:unittest", - "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test:moduletest", + "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test/moduletest:moduletest", + "//foundation/aafwk/standard/frameworks/kits/ability/ability_runtime/test/unittest:unittest", "//foundation/aafwk/standard/frameworks/kits/test:moduletest", "//foundation/aafwk/standard/services/test:moduletest", "//foundation/aafwk/standard/services:unittest", diff --git a/services/abilitymgr/include/ability_record.h b/services/abilitymgr/include/ability_record.h index a6384c46dff1b82cec6b234a5d4aa5cf030bd460..cf1c6732134fefdbb5b5a7d0157e4d88721f60ba 100644 --- a/services/abilitymgr/include/ability_record.h +++ b/services/abilitymgr/include/ability_record.h @@ -885,6 +885,7 @@ private: int32_t restartCount_ = -1; int32_t restratMax_ = -1; std::string specifiedFlag_; + std::mutex lock_; }; class AbilityRecordNew : public AbilityRecord { diff --git a/services/abilitymgr/include/inner_mission_info.h b/services/abilitymgr/include/inner_mission_info.h index faec076413295cd66f39b6c6a45b0f129c191040..af13a48e3507e0f7dc6aa8e64eb9e79781889cf6 100644 --- a/services/abilitymgr/include/inner_mission_info.h +++ b/services/abilitymgr/include/inner_mission_info.h @@ -31,6 +31,10 @@ enum class JsonType { ARRAY, STRING, }; +enum class StartMethod { + START_NORMAL, + START_CALL, +}; /** * @struct InnerMissionInfo @@ -40,6 +44,7 @@ struct InnerMissionInfo { MissionInfo missionInfo; std::string missionName; bool isSingletonMode; + int32_t startMethod; std::string ToJsonStr() const; bool FromJsonStr(const std::string &jsonStr); diff --git a/services/abilitymgr/include/mission.h b/services/abilitymgr/include/mission.h index 899311b5a2747359fe1bc15df881b7e01bda4da9..161ab18e7cbd8caaba1bf92e0e2e2d42ef1f42ca 100644 --- a/services/abilitymgr/include/mission.h +++ b/services/abilitymgr/include/mission.h @@ -29,7 +29,8 @@ namespace AAFwk { */ class Mission : public std::enable_shared_from_this { public: - Mission(int32_t id, const std::shared_ptr abilityRecord, const std::string &missionName = ""); + Mission(int32_t id, const std::shared_ptr abilityRecord, const std::string &missionName = "", + int32_t startMethod = 0); Mission(const std::shared_ptr &mission); virtual ~Mission(); @@ -120,8 +121,25 @@ public: */ void Dump(std::vector &info); + /** + * @brief whether it is a form ByCall start-up + * + * @return true form BaCall start-up, false other + */ + bool IsStartByCall(); + + /** + * @brief update mission id + * + * @param id mission id. + * @param method start method. + * @return Returns true on success, false on failure + */ + bool UpdateMissionId(int32_t id, int32_t method); + private: int32_t missionId_; + int32_t startMethod_; std::shared_ptr abilityRecord_; std::string missionName_; std::weak_ptr ownerMissionList_; diff --git a/services/abilitymgr/src/ability_manager_service.cpp b/services/abilitymgr/src/ability_manager_service.cpp index 4c7cf21c3858fbbc692d634fa2669d7f423c0c3d..efa9380595929fa81f37d5e995e7d3b212474e87 100644 --- a/services/abilitymgr/src/ability_manager_service.cpp +++ b/services/abilitymgr/src/ability_manager_service.cpp @@ -2859,10 +2859,12 @@ bool AbilityManagerService::VerificationToken(const sptr &token) } if (dataAbilityManager_->GetAbilityRecordByToken(token)) { + HILOG_INFO("Verification token4."); return true; } if (connectManager_->GetServiceRecordByToken(token)) { + HILOG_INFO("Verification token5."); return true; } @@ -3475,6 +3477,18 @@ int AbilityManagerService::StartAbilityByCall( return RESOLVE_CALL_NO_PERMISSIONS; } + HILOG_DEBUG("abilityInfo.applicationInfo.singleUser is %{public}s", + abilityRequest.abilityInfo.applicationInfo.singleUser ? "true" : "false"); + if (abilityRequest.abilityInfo.applicationInfo.singleUser) { + auto missionListManager = GetListManagerByUserId(U0_USER_ID); + if (missionListManager == nullptr) { + HILOG_ERROR("missionListManager is Null. userId=%{public}d", U0_USER_ID); + return ERR_INVALID_VALUE; + } + + return missionListManager->ResolveLocked(abilityRequest); + } + return currentMissionListManager_->ResolveLocked(abilityRequest); } diff --git a/services/abilitymgr/src/ability_record.cpp b/services/abilitymgr/src/ability_record.cpp index 2e556f359b9e00a9a0bae2b7d5a101ecd3c4bc30..03a20a15aaa462806fd5322a69877ccefab4bf2f 100644 --- a/services/abilitymgr/src/ability_record.cpp +++ b/services/abilitymgr/src/ability_record.cpp @@ -694,6 +694,7 @@ std::shared_ptr AbilityRecord::GetResult() const void AbilityRecord::SendResult() { HILOG_INFO("Send result."); + std::lock_guard guard(lock_); CHECK_POINTER(scheduler_); CHECK_POINTER(result_); scheduler_->SendResult(result_->requestCode_, result_->resultCode_, result_->resultWant_); @@ -705,6 +706,10 @@ void AbilityRecord::SendResult() void AbilityRecord::SendResultToCallers() { for (auto caller : GetCallerRecordList()) { + if (caller == nullptr) { + HILOG_WARN("Caller record is nullptr."); + continue; + } std::shared_ptr callerAbilityRecord = caller->GetCaller(); if (callerAbilityRecord != nullptr && callerAbilityRecord->GetResult() != nullptr) { callerAbilityRecord->SendResult(); @@ -715,6 +720,10 @@ void AbilityRecord::SendResultToCallers() void AbilityRecord::SaveResultToCallers(const int resultCode, const Want *resultWant) { for (auto caller : GetCallerRecordList()) { + if (caller == nullptr) { + HILOG_WARN("Caller record is nullptr."); + continue; + } std::shared_ptr callerAbilityRecord = caller->GetCaller(); if (callerAbilityRecord != nullptr) { callerAbilityRecord->SetResult( @@ -1062,6 +1071,7 @@ void AbilityRecord::OnSchedulerDied(const wptr &remote) if (mission) { HILOG_WARN("On scheduler died. Is app not response Reason:%{public}d", mission->IsANRState()); } + std::lock_guard guard(lock_); CHECK_POINTER(scheduler_); auto object = remote.promote(); diff --git a/services/abilitymgr/src/ability_scheduler_proxy.cpp b/services/abilitymgr/src/ability_scheduler_proxy.cpp index 557d9c42a522b16d0c59541443ef2f3fd02792c3..17fcd71a727c675107cb6a1fa056f7c5a0087d8c 100755 --- a/services/abilitymgr/src/ability_scheduler_proxy.cpp +++ b/services/abilitymgr/src/ability_scheduler_proxy.cpp @@ -1032,10 +1032,9 @@ sptr AbilitySchedulerProxy::CallRequest() HILOG_ERROR("CallRequest failed, err %{public}d", result); return nullptr; } - - auto call = reply.ReadParcelable(); - if (!call) { - HILOG_ERROR("CallRequest error"); + auto call = reply.ReadRemoteObject(); + if (call == nullptr) { + HILOG_ERROR("CallRequest failed, err remoteObject is nullptr"); return nullptr; } diff --git a/services/abilitymgr/src/ability_scheduler_stub.cpp b/services/abilitymgr/src/ability_scheduler_stub.cpp index 89e19940414d40019d3d127e4c5bf403428909a0..1b8057897fe52cc40f902fa1523757e356fbdd18 100644 --- a/services/abilitymgr/src/ability_scheduler_stub.cpp +++ b/services/abilitymgr/src/ability_scheduler_stub.cpp @@ -614,8 +614,8 @@ int AbilitySchedulerStub::CallRequestInner(MessageParcel &data, MessageParcel &r return ERR_INVALID_VALUE; } - if (!reply.WriteParcelable(call)) { - HILOG_ERROR("call request write failed."); + if (!reply.WriteRemoteObject(call)) { + HILOG_ERROR("Connect done remote object error."); return ERR_INVALID_VALUE; } diff --git a/services/abilitymgr/src/call_record.cpp b/services/abilitymgr/src/call_record.cpp index c4f7ca30979b8d42eb3b681569b1469f7274be91..934e4194bc5a8762a2496b6bd94a2f81cc542abf 100644 --- a/services/abilitymgr/src/call_record.cpp +++ b/services/abilitymgr/src/call_record.cpp @@ -140,8 +140,6 @@ bool CallRecord::SchedulerDisConnectDone() void CallRecord::OnCallStubDied(const wptr & remote) { HILOG_WARN("callstub is died. id:%{public}d", recordId_); - auto object = remote.promote(); - CHECK_POINTER(object); auto abilityManagerService = DelayedSingleton::GetInstance(); CHECK_POINTER(abilityManagerService); diff --git a/services/abilitymgr/src/inner_mission_info.cpp b/services/abilitymgr/src/inner_mission_info.cpp index 6231b346fce388e389a010501dfaa0ac76402157..2198f0df7ed3b311e87ef5494c2b2e88ea14512e 100644 --- a/services/abilitymgr/src/inner_mission_info.cpp +++ b/services/abilitymgr/src/inner_mission_info.cpp @@ -25,6 +25,7 @@ std::string InnerMissionInfo::ToJsonStr() const nlohmann::json value; value["MissionName"] = missionName; value["IsSingleton"] = isSingletonMode; + value["StartMethod"] = startMethod; value["MissionId"] = missionInfo.id; value["RunningState"] = missionInfo.runningState; value["LockedState"] = missionInfo.lockedState; @@ -71,6 +72,10 @@ bool InnerMissionInfo::FromJsonStr(const std::string &jsonStr) return false; } isSingletonMode = value["IsSingleton"].get(); + if (!CheckJsonNode("StartMethod", JsonType::NUMBER)) { + return false; + } + startMethod = value["StartMethod"].get(); if (!CheckJsonNode("MissionId", JsonType::NUMBER)) { return false; } diff --git a/services/abilitymgr/src/mission.cpp b/services/abilitymgr/src/mission.cpp index 7113b70418a0b8dec6fcd8163ceccf0b09dab28e..20fdda11f1c2a716db269ff25210602b89c5a99a 100644 --- a/services/abilitymgr/src/mission.cpp +++ b/services/abilitymgr/src/mission.cpp @@ -17,8 +17,9 @@ namespace OHOS { namespace AAFwk { -Mission::Mission(int32_t id, const std::shared_ptr abilityRecord, const std::string &missionName) - : missionId_(id), abilityRecord_(abilityRecord), missionName_(missionName) +Mission::Mission(int32_t id, const std::shared_ptr abilityRecord, const std::string &missionName, + int32_t startMethod) + : missionId_(id), startMethod_(startMethod), abilityRecord_(abilityRecord), missionName_(missionName) { } @@ -29,6 +30,7 @@ Mission::Mission(const std::shared_ptr &mission) } missionId_ = mission->missionId_; + startMethod_ = mission->startMethod_; abilityRecord_ = mission->abilityRecord_; missionName_ = mission->missionName_; ownerMissionList_ = mission->ownerMissionList_; @@ -115,5 +117,21 @@ void Mission::Dump(std::vector &info) } } +bool Mission::IsStartByCall() +{ + return static_cast(StartMethod::START_CALL) == startMethod_; +} + +bool Mission::UpdateMissionId(int32_t id, int32_t method) +{ + if (method == startMethod_ && id > 0) { + return false; + } + + startMethod_ = method; + missionId_ = id; + return true; +} + } // namespace AAFwk } // namespace OHOS diff --git a/services/abilitymgr/src/mission_info_mgr.cpp b/services/abilitymgr/src/mission_info_mgr.cpp index 5dbb0d3d63b06bbd12c3ef3101e008614d01b0c0..224364b1b2cf0976000d8ff0b896816fdc12c328 100644 --- a/services/abilitymgr/src/mission_info_mgr.cpp +++ b/services/abilitymgr/src/mission_info_mgr.cpp @@ -179,6 +179,16 @@ bool MissionInfoMgr::DeleteAllMissionInfos(const std::shared_ptr(startMethod)) { + case StartMethod::START_CALL: + return true; + default: + return false; + } +} + int MissionInfoMgr::GetMissionInfos(int32_t numMax, std::vector &missionInfos) { HILOG_INFO("GetMissionInfos, numMax:%{public}d", numMax); @@ -190,6 +200,11 @@ int MissionInfoMgr::GetMissionInfos(int32_t numMax, std::vector &mi if (static_cast(missionInfos.size()) >= numMax) { break; } + + if (DoesNotShowInTheMissionList(mission.startMethod)) { + HILOG_INFO("MissionId[%{public}d] don't show in mission list", mission.missionInfo.id); + continue; + } MissionInfo info = mission.missionInfo; missionInfos.emplace_back(info); } @@ -215,6 +230,12 @@ int MissionInfoMgr::GetMissionInfoById(int32_t missionId, MissionInfo &missionIn HILOG_ERROR("no such mission:%{public}d", missionId); return -1; } + + if (DoesNotShowInTheMissionList((*it).startMethod)) { + HILOG_INFO("MissionId[%{public}d] don't show in mission list", (*it).missionInfo.id); + return -1; + } + HILOG_INFO("GetMissionInfoById, find missionId missionId:%{public}d", missionId); missionInfo = (*it).missionInfo; return 0; diff --git a/services/abilitymgr/src/mission_list_manager.cpp b/services/abilitymgr/src/mission_list_manager.cpp index 7f27af14e24704375f28ee8f4462c6f296897b3a..b220cab98686632df52908b8ae4dcc420d3293f9 100644 --- a/services/abilitymgr/src/mission_list_manager.cpp +++ b/services/abilitymgr/src/mission_list_manager.cpp @@ -286,10 +286,36 @@ int MissionListManager::StartAbilityLocked(const std::shared_ptr } } +static int32_t CallType2StartMethod(int32_t callType) +{ + switch (callType) { + case AbilityCallType::INVALID_TYPE: + return static_cast(StartMethod::START_NORMAL); + case AbilityCallType::CALL_REQUEST_TYPE: + return static_cast(StartMethod::START_CALL); + default: + break; + } + return -1; +} + +static bool CallTypeFilter(int32_t callType) +{ + switch (callType) { + case AbilityCallType::CALL_REQUEST_TYPE: + return true; + default: + break; + } + return false; +} + void MissionListManager::GetTargetMissionAndAbility(const AbilityRequest &abilityRequest, std::shared_ptr &targetMission, std::shared_ptr &targetRecord) { + auto startMethod = CallType2StartMethod(abilityRequest.callType); + HILOG_DEBUG("GetTargetMissionAndAbility called startMethod is %{public}d.", startMethod); auto reUsedMission = GetReusedMission(abilityRequest); if (reUsedMission) { HILOG_DEBUG("find reused mission in running list."); @@ -299,7 +325,13 @@ void MissionListManager::GetTargetMissionAndAbility(const AbilityRequest &abilit targetRecord->SetWant(abilityRequest.want); targetRecord->SetIsNewWant(true); } - return; + + if (!(targetMission->IsStartByCall() + && !CallTypeFilter(startMethod))) { + HILOG_DEBUG("mission exists. No update required"); + return; + } + HILOG_DEBUG("mission exists. need to be updated"); } // no reused mission, create a new one. @@ -319,6 +351,7 @@ void MissionListManager::GetTargetMissionAndAbility(const AbilityRequest &abilit info.missionName = missionName; info.isSingletonMode = isSingleton; + info.startMethod = startMethod; info.missionInfo.runningState = 0; info.missionInfo.continuable = abilityRequest.abilityInfo.continuable; info.missionInfo.time = Time2str(time(0)); @@ -332,10 +365,22 @@ void MissionListManager::GetTargetMissionAndAbility(const AbilityRequest &abilit return; } } - targetRecord = AbilityRecord::CreateAbilityRecord(abilityRequest); - targetMission = std::make_shared(info.missionInfo.id, targetRecord, missionName); - targetRecord->SetUseNewMission(); - targetRecord->SetMission(targetMission); + + if (targetMission == nullptr) { + HILOG_DEBUG("Make new mission data."); + targetRecord = AbilityRecord::CreateAbilityRecord(abilityRequest); + targetMission = std::make_shared(info.missionInfo.id, targetRecord, missionName, startMethod); + targetRecord->SetUseNewMission(); + targetRecord->SetMission(targetMission); + } else { + HILOG_DEBUG("Update old mission data."); + auto state = targetMission->UpdateMissionId(info.missionInfo.id, startMethod); + if (!state) { + HILOG_INFO("targetMission UpdateMissionId(%{public}d, %{public}d) failed", info.missionInfo.id, + startMethod); + } + HILOG_DEBUG("Update MissionId UpdateMissionId(%{public}d, %{public}d) end", info.missionInfo.id, startMethod); + } if (abilityRequest.abilityInfo.launchMode == AppExecFwk::LaunchMode::SPECIFIED) { targetRecord->SetSpecifiedFlag(abilityRequest.specifiedFlag); diff --git a/services/abilitymgr/test/BUILD.gn b/services/abilitymgr/test/BUILD.gn index 0ebb63642dec769375a458fc20c73f22eb3f2ea4..3ee4bf0b45dcd0376eb58b167070fc6292382f0e 100644 --- a/services/abilitymgr/test/BUILD.gn +++ b/services/abilitymgr/test/BUILD.gn @@ -168,6 +168,7 @@ group("unittest") { "unittest/phone/ability_connect_callback_stub_test:unittest", "unittest/phone/ability_connect_manage_test:unittest", "unittest/phone/ability_dump_test:unittest", + "unittest/phone/ability_manager_client_test:unittest", "unittest/phone/ability_manager_proxy_test:unittest", "unittest/phone/ability_manager_service_account_test:unittest", "unittest/phone/ability_manager_service_test:unittest", @@ -182,6 +183,8 @@ group("unittest") { "unittest/phone/ability_with_applications_test:unittest", "unittest/phone/abilityms_appms_test:unittest", "unittest/phone/app_scheduler_test:unittest", + "unittest/phone/call_container_test:unittest", + "unittest/phone/call_record_test:unittest", "unittest/phone/check_query_abilityinfo_test:unittest", "unittest/phone/configuration_test:unittest", "unittest/phone/connection_record_test:unittest", @@ -192,6 +195,8 @@ group("unittest") { "unittest/phone/lifecycle_test:unittest", "unittest/phone/lock_screen_white_list_test:unittest", "unittest/phone/mission_list_manager_test:unittest", + "unittest/phone/mission_list_manager_ut_test:unittest", + "unittest/phone/mission_list_test:unittest", "unittest/phone/mission_record_test:unittest", "unittest/phone/mission_stack_test:unittest", "unittest/phone/pending_want_key_test:unittest", diff --git a/services/abilitymgr/test/mock/libs/appexecfwk_core/include/bundlemgr/mock_bundle_manager.h b/services/abilitymgr/test/mock/libs/appexecfwk_core/include/bundlemgr/mock_bundle_manager.h index 27502c814e6d5d339e563105c8e457e79068fecd..5870d1f84efa8655e60e46e2ed56ba451aabd05b 100644 --- a/services/abilitymgr/test/mock/libs/appexecfwk_core/include/bundlemgr/mock_bundle_manager.h +++ b/services/abilitymgr/test/mock/libs/appexecfwk_core/include/bundlemgr/mock_bundle_manager.h @@ -56,6 +56,7 @@ auto HiWordInfo = [](std::string bundleName, AbilityInfo &abilityInfo, ElementNa abilityInfo.applicationInfo.name = "Helloworld"; abilityInfo.type = AbilityType::PAGE; abilityInfo.applicationInfo.isLauncherApp = true; + abilityInfo.applicationInfo.apiCompatibleVersion = 8; return true; }; diff --git a/services/abilitymgr/test/unittest/phone/ability_manager_client_test/BUILD.gn b/services/abilitymgr/test/unittest/phone/ability_manager_client_test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..7577602c81845e337669d27b1bb6a9cada996521 --- /dev/null +++ b/services/abilitymgr/test/unittest/phone/ability_manager_client_test/BUILD.gn @@ -0,0 +1,70 @@ +# Copyright (c) 2021-2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/aafwk/standard/aafwk.gni") + +ohos_unittest("ability_manager_client_test") { + module_out_path = "ability_runtime/ability_call_test" + + include_dirs = [ + "${services_path}/abilitymgr/test/mock/libs/system_ability_mock", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy/include", + "//foundation/distributedschedule/samgr/adapter/interfaces/innerkits/include/", + "//foundation/aafwk/standard/interfaces/innerkits/app_manager/include/appmgr", + "//foundation/aafwk/standard/frameworks/kits/ability/native/test/mock/include", + ] + + sources = [ + "${services_path}/abilitymgr/src/ability_manager_client.cpp", + "ability_manager_client_test.cpp", + ] + + configs = [ "${services_path}/abilitymgr:abilityms_config" ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + deps = [ + "${innerkits_path}/want:want", + "${services_path}/abilitymgr/test:abilityms_test_source", + "${services_path}/abilitymgr/test/mock/libs/aakit:aakit_mock", + "${services_path}/abilitymgr/test/mock/libs/appexecfwk_core:appexecfwk_appmgr_mock", + "${services_path}/abilitymgr/test/mock/libs/appexecfwk_core:appexecfwk_bundlemgr_mock", + "${services_path}/common:perm_verification", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//foundation/aafwk/standard/frameworks/kits/ability/native:dummy_classes", + "//foundation/aafwk/standard/interfaces/innerkits/app_manager:app_manager", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler:libeventhandler", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//third_party/libpng:libpng", + "//utils/native/base:utils", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "device_manager_base:devicemanagersdk", + "dsoftbus_standard:softbus_client", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] +} + +group("unittest") { + testonly = true + deps = [ ":ability_manager_client_test" ] +} diff --git a/services/abilitymgr/test/unittest/phone/ability_manager_client_test/ability_manager_client_test.cpp b/services/abilitymgr/test/unittest/phone/ability_manager_client_test/ability_manager_client_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a00b287d89c68eb162fe4008427c8538a9db673a --- /dev/null +++ b/services/abilitymgr/test/unittest/phone/ability_manager_client_test/ability_manager_client_test.cpp @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#define private public +#define protected public +#include "ability_manager_client.h" +#undef private +#undef protected +#include "ability_manager_stub_mock_test.h" + +using namespace testing::ext; +using namespace testing; +using namespace OHOS::AppExecFwk; + +namespace OHOS { +namespace AAFwk { +class AbilityManagerClientTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr client_ {nullptr}; + sptr mock_ {nullptr}; +}; + +void AbilityManagerClientTest::SetUpTestCase(void) +{} +void AbilityManagerClientTest::TearDownTestCase(void) +{} +void AbilityManagerClientTest::TearDown() +{} + +void AbilityManagerClientTest::SetUp() +{ + client_ = std::make_shared(); + mock_ = new AbilityManagerStubTestMock(); + client_->remoteObject_ = mock_; +} + +/* + * Feature: AbilityManagerClient + * Function: StartAbilityByCall + * SubFunction: NA + * FunctionPoints: AbilityManagerClient StartAbility + * EnvConditions: NA + * CaseDescription: Verify the StartAbilityByCall call normal + */ +HWTEST_F(AbilityManagerClientTest, StartAbilityByCall_001, TestSize.Level1) +{ + Want want; + EXPECT_EQ(client_->StartAbilityByCall(want, nullptr, nullptr), 0); +} + +/* + * Feature: AbilityManagerClient + * Function: StartAbilityByCall + * SubFunction: NA + * FunctionPoints: AbilityManagerClient StartAbility + * EnvConditions: NA + * CaseDescription: Verify the ReleaseAbility call normal + */ +HWTEST_F(AbilityManagerClientTest, ReleaseAbility_001, TestSize.Level1) +{ + ElementName element; + sptr connect = nullptr; + EXPECT_EQ(client_->ReleaseAbility(connect, element), 0); +} +} // namespace AAFwk +} // namespace OHOS \ No newline at end of file diff --git a/services/abilitymgr/test/unittest/phone/ability_manager_client_test/ability_manager_stub_mock_test.h b/services/abilitymgr/test/unittest/phone/ability_manager_client_test/ability_manager_stub_mock_test.h new file mode 100644 index 0000000000000000000000000000000000000000..2d4167321eee6daa818f23e6f5a054a5621d1373 --- /dev/null +++ b/services/abilitymgr/test/unittest/phone/ability_manager_client_test/ability_manager_stub_mock_test.h @@ -0,0 +1,472 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ABILITY_UNITTEST_ABILITY_MANAGER_STUB_MOCK_H +#define ABILITY_UNITTEST_ABILITY_MANAGER_STUB_MOCK_H +#include +#include +#include +#include "ability_manager_interface.h" + +namespace OHOS { +namespace AAFwk { +class AbilityManagerStubTestMock : public IRemoteStub { +public: + DECLARE_INTERFACE_DESCRIPTOR(u"IAbilityManagerMock"); + + AbilityManagerStubTestMock() : code_(0) + {} + virtual ~AbilityManagerStubTestMock() + {} + + MOCK_METHOD4(SendRequest, int(uint32_t, MessageParcel &, MessageParcel &, MessageOption &)); + + int InvokeSendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) + { + code_ = code; + + if (GET_RECENT_MISSION == code) { + std::vector missionInfos; + AbilityMissionInfo info; + info.id = 1; + const Want want; + info.baseWant = want; + AppExecFwk::ElementName baseEle("baseDevice", "baseBundle", "baseAbility"); + info.baseAbility = baseEle; + AppExecFwk::ElementName topEle("topDevice", "topBundle", "topAbility"); + info.topAbility = topEle; + missionInfos.emplace_back(info); + + reply.WriteInt32(missionInfos.size()); + for (auto &it : missionInfos) { + if (!reply.WriteParcelable(&it)) { + return ERR_INVALID_VALUE; + } + } + + int res = 1; + if (!reply.WriteInt32(res)) { + return ERR_INVALID_VALUE; + } + } + + return 0; + } + + int InvokeErrorSendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) + { + code_ = code; + return UNKNOWN_ERROR; + } + + int code_ = 0; + + virtual int StartAbility(const Want &want, int32_t userId = DEFAULT_INVAL_VALUE, int requestCode = -1) + { + return 0; + } + + virtual int StartAbility(const Want &want, + const AbilityStartSetting &abilityStartSetting, + const sptr &callerToken, + int32_t userId = DEFAULT_INVAL_VALUE, + int requestCode = DEFAULT_INVAL_VALUE) + { + return 0; + } + + virtual int StartAbility( + const Want &want, + const StartOptions &startOptions, + const sptr &callerToken, + int32_t userId = DEFAULT_INVAL_VALUE, + int requestCode = DEFAULT_INVAL_VALUE) + { + return 0; + } + + virtual int TerminateAbility(const sptr &token, int resultCode, const Want *resultWant = nullptr) + { + return 0; + } + virtual int CloseAbility(const sptr &token, int resultCode = DEFAULT_INVAL_VALUE, + const Want *resultWant = nullptr) override + { + return 0; + } + virtual int MinimizeAbility(const sptr &token, bool fromUser) override + { + return 0; + } + + virtual int ConnectAbility( + const Want &want, + const sptr &connect, + const sptr &callerToken, + int32_t userId = DEFAULT_INVAL_VALUE) + { + return 0; + } + + virtual sptr AcquireDataAbility( + const Uri &uri, bool tryBind, const sptr &callerToken) override + { + return nullptr; + } + + virtual int ReleaseDataAbility(sptr dataAbilityScheduler, const sptr &callerToken) + { + return 0; + } + + virtual int DisconnectAbility(const sptr &connect) + { + return 0; + } + + virtual void AddWindowInfo(const sptr &token, int32_t windowToken) + {} + + virtual int AttachAbilityThread(const sptr &scheduler, const sptr &token) + { + return 0; + } + + virtual int AbilityTransitionDone(const sptr &token, int state, const PacMap &saveData) + { + return 0; + } + + virtual int ScheduleConnectAbilityDone(const sptr &token, const sptr &remoteObject) + { + return 0; + } + + virtual int ScheduleDisconnectAbilityDone(const sptr &token) + { + return 0; + } + + virtual int ScheduleCommandAbilityDone(const sptr &token) + { + return 0; + } + + virtual void DumpState(const std::string &args, std::vector &state) + {} + + virtual void DumpSysState( + const std::string& args, std::vector& info, bool isClient, bool isUserID, int UserID) + {} + + virtual int TerminateAbilityResult(const sptr &token, int startId) + { + return 0; + } + + virtual int StopServiceAbility(const Want &want, int32_t userId = DEFAULT_INVAL_VALUE) + { + return 0; + } + + virtual int GetAllStackInfo(StackInfo &stackInfo) + { + return 0; + } + + virtual int GetRecentMissions( + const int32_t numMax, const int32_t flags, std::vector &recentList) + { + return 0; + } + + int GetMissionSnapshot(const int32_t missionId, MissionPixelMap &missionPixelMap) + { + return 0; + } + + virtual int RemoveMission(int id) + { + return 0; + } + + virtual int RemoveStack(int id) + { + return 0; + } + + virtual int KillProcess(const std::string &bundleName) + { + return 0; + } + + virtual int UninstallApp(const std::string &bundleName) + { + return 0; + } + + virtual int MoveMissionToTop(int32_t missionId) + { + return 0; + } + + bool IsFirstInMission(const sptr &token) override + { + return true; + } + + int CompelVerifyPermission(const std::string &permission, int pid, int uid, std::string &message) override + { + return 0; + } + + int MoveMissionToEnd(const sptr &token, const bool nonFirst) override + { + return 0; + } + + int PowerOff() override + { + return 0; + } + + int PowerOn() override + { + return 0; + } + + int LockMission(int missionId) override + { + return 0; + } + int UnlockMission(int missionId) override + { + return 0; + } + + int SetMissionDescriptionInfo( + const sptr &token, const MissionDescriptionInfo &missionDescriptionInfo) override + { + return 0; + } + + int GetMissionLockModeState() + { + return 0; + } + + int MoveMissionToFloatingStack(const MissionOption &missionOption) + { + return 0; + } + + int UpdateConfiguration(const AppExecFwk::Configuration &config) + + { + return 0; + } + + int MoveMissionToSplitScreenStack(const MissionOption &primary, const MissionOption &secondary) + { + return 0; + } + + int ChangeFocusAbility(const sptr &lostFocusToken, const sptr &getFocusToken) + { + return 0; + } + + int MinimizeMultiWindow(int missionId) + { + return 0; + } + + int MaximizeMultiWindow(int missionId) + { + return 0; + } + + int GetFloatingMissions(std::vector &list) + { + return 0; + } + + int CloseMultiWindow(int missionId) + { + return 0; + } + + int SetMissionStackSetting(const StackSetting &stackSetting) + { + return 0; + } + + virtual int SetShowOnLockScreen(bool isAllow) override + { + return 0; + } + + virtual int ClearUpApplicationData(const std::string &bundleName) override + { + return 0; + } + + virtual int StartUser(int userId) override + { + return 0; + } + + virtual int StopUser(int userId, const sptr &callback) override + { + return 0; + } + virtual int StartSyncRemoteMissions(const std::string& devId, bool fixConflict, int64_t tag) override + { + return 0; + } + virtual int StopSyncRemoteMissions(const std::string& devId) override + { + return 0; + } + virtual int RegisterMissionListener(const std::string &deviceId, + const sptr &listener) override + { + return 0; + } + virtual int UnRegisterMissionListener(const std::string &deviceId, + const sptr &listener) override + { + return 0; + } + virtual int ReleaseAbility(const sptr &connect, + const AppExecFwk::ElementName &element) override + { + return 0; + } + virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot) + { + return 0; + } + virtual int RegisterSnapshotHandler(const sptr& handler) + { + return 0; + } + + virtual int SetAbilityController(const sptr &abilityController, + bool imAStabilityTest) override + { + return 0; + } + + virtual bool IsRunningInStabilityTest() override + { + return true; + } + + virtual int SendANRProcessID(int pid) override + { + return 0; + } + + MOCK_METHOD2(TerminateAbilityByCaller, int(const sptr &callerToken, int requestCode)); + MOCK_METHOD4(StartAbility, int(const Want &want, const sptr &callerToken, + int32_t userId, int requestCode)); + MOCK_METHOD2( + GetWantSender, sptr(const WantSenderInfo &wantSenderInfo, const sptr &callerToken)); + MOCK_METHOD2(SendWantSender, int(const sptr &target, const SenderInfo &senderInfo)); + MOCK_METHOD1(CancelWantSender, void(const sptr &sender)); + MOCK_METHOD1(GetPendingWantUid, int(const sptr &target)); + MOCK_METHOD1(GetPendingWantUserId, int(const sptr &target)); + MOCK_METHOD1(GetPendingWantBundleName, std::string(const sptr &target)); + MOCK_METHOD1(GetPendingWantCode, int(const sptr &target)); + MOCK_METHOD1(GetPendingWantType, int(const sptr &target)); + MOCK_METHOD2(RegisterCancelListener, void(const sptr &sender, const sptr &receiver)); + MOCK_METHOD2(UnregisterCancelListener, void(const sptr &sender, const sptr &receiver)); + MOCK_METHOD2(GetPendingRequestWant, int(const sptr &target, std::shared_ptr &want)); + MOCK_METHOD1(GetSystemMemoryAttr, void(AppExecFwk::SystemMemoryAttr &memoryInfo)); + MOCK_METHOD3(StartContinuation, int(const Want &want, const sptr &abilityToken, int32_t status)); + MOCK_METHOD2(NotifyContinuationResult, int(int32_t missionId, int32_t result)); + MOCK_METHOD5(ContinueMission, int(const std::string &srcDeviceId, const std::string &dstDeviceId, + int32_t missionId, const sptr &callBack, AAFwk::WantParams &wantParams)); + MOCK_METHOD2(ContinueAbility, int(const std::string &deviceId, int32_t missionId)); + MOCK_METHOD3(NotifyCompleteContinuation, void(const std::string &deviceId, int32_t sessionId, bool isSuccess)); + + MOCK_METHOD1(LockMissionForCleanup, int(int32_t missionId)); + MOCK_METHOD1(UnlockMissionForCleanup, int(int32_t missionId)); + MOCK_METHOD1(RegisterMissionListener, int(const sptr &listener)); + MOCK_METHOD1(UnRegisterMissionListener, int(const sptr &listener)); + MOCK_METHOD3( + GetMissionInfos, int(const std::string& deviceId, int32_t numMax, std::vector &missionInfos)); + MOCK_METHOD3(GetMissionInfo, int(const std::string& deviceId, int32_t missionId, MissionInfo &missionInfo)); + MOCK_METHOD1(CleanMission, int(int32_t missionId)); + MOCK_METHOD0(CleanAllMissions, int()); + MOCK_METHOD1(MoveMissionToFront, int(int32_t missionId)); + MOCK_METHOD2(MoveMissionToFront, int(int32_t missionId, const StartOptions &startOptions)); + MOCK_METHOD2(SetMissionLabel, int(const sptr &token, const std::string &label)); + MOCK_METHOD2(GetWantSenderInfo, int(const sptr &target, std::shared_ptr &info)); + MOCK_METHOD1(GetAbilityRunningInfos, int(std::vector &info)); + MOCK_METHOD2(GetExtensionRunningInfos, int(int upperLimit, std::vector &info)); + MOCK_METHOD1(GetProcessRunningInfos, int(std::vector &info)); + + virtual int StartAbilityByCall( + const Want &want, const sptr &connect, const sptr &callerToken) override + { + return 0; + } + + virtual int StartUserTest(const Want &want, const sptr &observer) override + { + return 0; + } + + virtual int FinishUserTest(const std::string &msg, const int &resultCode, const std::string &bundleName) override + { + return 0; + } + + virtual int GetCurrentTopAbility(sptr &token) override + { + return 0; + } + + virtual int DelegatorDoAbilityForeground(const sptr &token) override + { + return 0; + } + + virtual int DelegatorDoAbilityBackground(const sptr &token) override + { + return 0; + } + + virtual int DoAbilityForeground(const sptr &token, uint32_t flag) override + { + return 0; + } + + virtual int DoAbilityBackground(const sptr &token, uint32_t flag) override + { + return 0; + } + + virtual int ForceTimeoutForTest(const std::string &abilityName, const std::string &state) override + { + return 0; + } +}; +} // namespace AAFwk +} // namespace OHOS + +#endif diff --git a/services/abilitymgr/test/unittest/phone/ability_manager_proxy_test/ability_manager_proxy_test.cpp b/services/abilitymgr/test/unittest/phone/ability_manager_proxy_test/ability_manager_proxy_test.cpp index 68a16ff107800c771ea7611a6f402533b4c09d03..05d4d8704df3a1fcace89283caefa611e3b4ada5 100644 --- a/services/abilitymgr/test/unittest/phone/ability_manager_proxy_test/ability_manager_proxy_test.cpp +++ b/services/abilitymgr/test/unittest/phone/ability_manager_proxy_test/ability_manager_proxy_test.cpp @@ -786,5 +786,75 @@ HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ReleaseDataAbility_004, Te EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(TRANSACTION_ERR)); EXPECT_EQ(proxy_->ReleaseDataAbility(scheduler, abilityRecord->GetToken()), TRANSACTION_ERR); } + +/* + * Feature: AbilityManagerService + * Function: StartAbilityByCall + * SubFunction: NA + * FunctionPoints: AbilityManagerService StartAbilityByCall + * EnvConditions: NA + * CaseDescription: Verify the function StartAbilityByCall connect is nullptr. + */ +HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartAbilityByCall_001, TestSize.Level1) +{ + Want want; + sptr callerToken = nullptr; + sptr connect = nullptr; + EXPECT_EQ(proxy_->StartAbilityByCall(want, connect, callerToken), ERR_INVALID_VALUE); +} + +/* + * Feature: AbilityManagerService + * Function: StartAbilityByCall + * SubFunction: NA + * FunctionPoints: AbilityManagerService StartAbilityByCall + * EnvConditions: NA + * CaseDescription: Verify the function StartAbilityByCall is normal flow. + */ +HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartAbilityByCall_002, TestSize.Level1) +{ + Want want; + sptr callerToken = nullptr; + sptr connect = new AbilityConnectCallback(); + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) + .Times(1) + .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest)); + EXPECT_EQ(proxy_->StartAbilityByCall(want, connect, callerToken), ERR_OK); + EXPECT_EQ(IAbilityManager::START_CALL_ABILITY, mock_->code_); +} + +/* + * Feature: AbilityManagerService + * Function: ReleaseAbility + * SubFunction: NA + * FunctionPoints: AbilityManagerService ReleaseAbility + * EnvConditions: NA + * CaseDescription: Verify the function ReleaseAbility connect is nullptr. + */ +HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ReleaseAbility_001, TestSize.Level1) +{ + AppExecFwk::ElementName element; + sptr connect = nullptr; + EXPECT_EQ(proxy_->ReleaseAbility(connect, element), ERR_INVALID_VALUE); +} + +/* + * Feature: AbilityManagerService + * Function: ReleaseAbility + * SubFunction: NA + * FunctionPoints: AbilityManagerService ReleaseAbility + * EnvConditions: NA + * CaseDescription: Verify the function ReleaseAbility is normal flow. + */ +HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ReleaseAbility_002, TestSize.Level1) +{ + AppExecFwk::ElementName element; + sptr connect = new AbilityConnectCallback(); + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) + .Times(1) + .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest)); + EXPECT_EQ(proxy_->ReleaseAbility(connect, element), ERR_OK); + EXPECT_EQ(IAbilityManager::RELEASE_CALL_ABILITY, mock_->code_); +} } // namespace AAFwk } // namespace OHOS \ No newline at end of file diff --git a/services/abilitymgr/test/unittest/phone/ability_manager_service_test/BUILD.gn b/services/abilitymgr/test/unittest/phone/ability_manager_service_test/BUILD.gn index 97a773591ca332c1e0500533bd76e134a8760bb7..28882de9e3b1e4dcb9281784521942698f6518d8 100644 --- a/services/abilitymgr/test/unittest/phone/ability_manager_service_test/BUILD.gn +++ b/services/abilitymgr/test/unittest/phone/ability_manager_service_test/BUILD.gn @@ -67,7 +67,60 @@ ohos_unittest("ability_manager_service_test") { ] } +ohos_unittest("ability_manager_service_test_call") { + module_out_path = "ability_runtime/ability_call_test" + + include_dirs = [ + "${services_path}/abilitymgr/test/mock/libs/system_ability_mock", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy/include", + "//foundation/distributedschedule/samgr/adapter/interfaces/innerkits/include/", + "//foundation/aafwk/standard/interfaces/innerkits/app_manager/include/appmgr", + "//foundation/aafwk/standard/frameworks/kits/ability/native/test/mock/include", + ] + + sources = [ + # add mock file + "//foundation/aafwk/standard/services/abilitymgr/test/mock/libs/appexecfwk_core/src/appmgr/mock_app_scheduler.cpp", + "ability_manager_service_test_call.cpp", + ] + + configs = [ "${services_path}/abilitymgr:abilityms_config" ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + deps = [ + "${innerkits_path}/want:want", + "${services_path}/abilitymgr/test:abilityms_test_source", + "${services_path}/abilitymgr/test/mock/libs/aakit:aakit_mock", + "${services_path}/abilitymgr/test/mock/libs/appexecfwk_core:appexecfwk_appmgr_mock", + "${services_path}/abilitymgr/test/mock/libs/appexecfwk_core:appexecfwk_bundlemgr_mock", + "${services_path}/common:perm_verification", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//foundation/aafwk/standard/frameworks/kits/ability/native:dummy_classes", + "//foundation/aafwk/standard/interfaces/innerkits/app_manager:app_manager", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler:libeventhandler", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//third_party/libpng:libpng", + "//utils/native/base:utils", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "device_manager_base:devicemanagersdk", + "dsoftbus_standard:softbus_client", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] +} + group("unittest") { testonly = true + # deps = [ ":ability_manager_service_test" ] + deps = [ ":ability_manager_service_test_call" ] } diff --git a/services/abilitymgr/test/unittest/phone/ability_manager_service_test/ability_manager_service_test_call.cpp b/services/abilitymgr/test/unittest/phone/ability_manager_service_test/ability_manager_service_test_call.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b965aa1a17739fb86c3183a02a586b8a6b525ba3 --- /dev/null +++ b/services/abilitymgr/test/unittest/phone/ability_manager_service_test/ability_manager_service_test_call.cpp @@ -0,0 +1,321 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#define private public +#define protected public +#include "ability_manager_service.h" +#include "ability_event_handler.h" +#undef private +#undef protected + +#include "app_process_data.h" +#include "system_ability_definition.h" +#include "ability_manager_errors.h" +#include "ability_scheduler.h" +#include "bundlemgr/mock_bundle_manager.h" +#include "sa_mgr_client.h" +#include "mock_ability_connect_callback.h" +#include "mock_ability_token.h" +#include "if_system_ability_manager.h" +#include "iservice_registry.h" + +using namespace testing; +using namespace testing::ext; +using namespace OHOS::AppExecFwk; + +namespace { + const std::string DEVICE_ID = "15010038475446345206a332922cb765"; + const std::string BUNDLE_NAME = "testBundle"; + const std::string NAME = ".testMainAbility"; +} + +namespace OHOS { +namespace AAFwk { +static void WaitUntilTaskFinished() +{ + const uint32_t maxRetryCount = 1000; + const uint32_t sleepTime = 1000; + uint32_t count = 0; + auto handler = OHOS::DelayedSingleton::GetInstance()->GetEventHandler(); + std::atomic taskCalled(false); + auto f = [&taskCalled]() { taskCalled.store(true); }; + if (handler->PostTask(f)) { + while (!taskCalled.load()) { + ++count; + if (count >= maxRetryCount) { + break; + } + usleep(sleepTime); + } + } +} + +#define SLEEP(milli) std::this_thread::sleep_for(std::chrono::seconds(milli)) + +namespace { +const std::string WaitUntilTaskFinishedByTimer = "BundleMgrService"; +} // namespace + +class AbilityManagerServiceTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); + void OnStartAms(); + void OnStopAms(); + int StartAbility(const Want &want); + static constexpr int TEST_WAIT_TIME = 100000; + +public: + AbilityRequest abilityRequest_; + std::shared_ptr abilityRecord_ {nullptr}; + std::shared_ptr abilityMs_ = DelayedSingleton::GetInstance(); +}; + +int AbilityManagerServiceTest::StartAbility(const Want &want) +{ + int ref = -1; + auto topAbility = abilityMs_->GetStackManager()->GetCurrentTopAbility(); + if (topAbility) { + topAbility->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE); + } + ref = abilityMs_->StartAbility(want); + WaitUntilTaskFinished(); + return ref; +} + +void AbilityManagerServiceTest::OnStartAms() +{ + if (abilityMs_) { + if (abilityMs_->state_ == ServiceRunningState::STATE_RUNNING) { + return; + } + + abilityMs_->state_ = ServiceRunningState::STATE_RUNNING; + + abilityMs_->eventLoop_ = AppExecFwk::EventRunner::Create(AbilityConfig::NAME_ABILITY_MGR_SERVICE); + EXPECT_TRUE(abilityMs_->eventLoop_); + + abilityMs_->handler_ = std::make_shared(abilityMs_->eventLoop_, abilityMs_); + abilityMs_->connectManager_ = std::make_shared(); + abilityMs_->connectManagers_.emplace(0, abilityMs_->connectManager_); + EXPECT_TRUE(abilityMs_->handler_); + EXPECT_TRUE(abilityMs_->connectManager_); + + abilityMs_->dataAbilityManager_ = std::make_shared(); + abilityMs_->dataAbilityManagers_.emplace(0, abilityMs_->dataAbilityManager_); + EXPECT_TRUE(abilityMs_->dataAbilityManager_); + + abilityMs_->amsConfigResolver_ = std::make_shared(); + EXPECT_TRUE(abilityMs_->amsConfigResolver_); + abilityMs_->amsConfigResolver_->Parse(); + + abilityMs_->pendingWantManager_ = std::make_shared(); + EXPECT_TRUE(abilityMs_->pendingWantManager_); + + abilityMs_->currentMissionListManager_ = std::make_shared(0); + abilityMs_->currentMissionListManager_->Init(); + int userId = abilityMs_->GetUserId(); + abilityMs_->SetStackManager(userId, true); + EXPECT_TRUE(abilityMs_->GetStackManager()); + abilityMs_->stackManagers_.emplace(0, abilityMs_->GetStackManager()); + abilityMs_->eventLoop_->Run(); + return; + } + + GTEST_LOG_(INFO) << "OnStart fail"; +} + +void AbilityManagerServiceTest::OnStopAms() +{ + abilityMs_->OnStop(); +} + +void AbilityManagerServiceTest::SetUpTestCase() +{ + OHOS::DelayedSingleton::GetInstance()->RegisterSystemAbility( + OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new BundleMgrService()); +} + +void AbilityManagerServiceTest::TearDownTestCase() +{ + OHOS::DelayedSingleton::DestroyInstance(); +} + +void AbilityManagerServiceTest::SetUp() +{ + OnStartAms(); + WaitUntilTaskFinished(); + if (abilityRecord_ == nullptr) { + abilityRequest_.appInfo.bundleName = "data.client.bundle"; + abilityRequest_.abilityInfo.name = "ClientAbility"; + abilityRequest_.abilityInfo.type = AbilityType::DATA; + abilityRecord_ = AbilityRecord::CreateAbilityRecord(abilityRequest_); + } +} + +void AbilityManagerServiceTest::TearDown() +{ + OnStopAms(); +} + +/** + * @tc.name: CheckCallPermissions_001 + * @tc.desc: Verify function CheckCallPermissions return RESOLVE_CALL_NO_PERMISSIONS + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AbilityManagerServiceTest, CheckCallPermissions_001, TestSize.Level1) +{ + abilityRequest_.callerUid = 0; + EXPECT_EQ(RESOLVE_CALL_NO_PERMISSIONS, abilityMs_->CheckCallPermissions(abilityRequest_)); +} + +/** + * @tc.name: CheckCallPermissions_002 + * @tc.desc: Verify function CheckCallPermissions return ERR_OK + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AbilityManagerServiceTest, CheckCallPermissions_002, TestSize.Level1) +{ + abilityRequest_.callerUid = 1000; + abilityRequest_.abilityInfo.type = AppExecFwk::AbilityType::PAGE; + abilityRequest_.abilityInfo.launchMode = AppExecFwk::LaunchMode::SINGLETON; + EXPECT_EQ(ERR_OK, abilityMs_->CheckCallPermissions(abilityRequest_)); +} + +/** + * @tc.name: StartAbilityByCall_001 + * @tc.desc: Verify function StartAbilityByCall return RESOLVE_ABILITY_ERR + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AbilityManagerServiceTest, StartAbilityByCall_001, TestSize.Level1) +{ + Want want; + sptr connect = new AbilityConnectCallback(); + EXPECT_EQ(RESOLVE_ABILITY_ERR, abilityMs_->StartAbilityByCall(want, connect, nullptr)); +} + +/** + * @tc.name: StartAbilityByCall_002 + * @tc.desc: Verify function StartAbilityByCall return RESOLVE_CALL_ABILITY_VERSION_ERR + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AbilityManagerServiceTest, StartAbilityByCall_002, TestSize.Level1) +{ + std::string localDeviceId; + bool getLocalDeviceId = abilityMs_->GetLocalDeviceId(localDeviceId); + EXPECT_EQ(true, getLocalDeviceId); + Want want; + ElementName element(localDeviceId, "com.ix.hiMusic", "MusicAbility"); + want.SetElement(element); + sptr connect = new AbilityConnectCallback(); + EXPECT_EQ(RESOLVE_CALL_ABILITY_VERSION_ERR, abilityMs_->StartAbilityByCall(want, connect, nullptr)); +} + +/** + * @tc.name: StartAbilityByCall_003 + * @tc.desc: Verify function StartAbilityByCall return RESOLVE_CALL_NO_PERMISSIONS + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AbilityManagerServiceTest, StartAbilityByCall_003, TestSize.Level1) +{ + std::string localDeviceId; + bool getLocalDeviceId = abilityMs_->GetLocalDeviceId(localDeviceId); + EXPECT_EQ(true, getLocalDeviceId); + Want want; + ElementName element(localDeviceId, "com.ix.hiworld", "MusicAbility"); + want.SetElement(element); + sptr connect = new AbilityConnectCallback(); + EXPECT_EQ(RESOLVE_CALL_NO_PERMISSIONS, abilityMs_->StartAbilityByCall(want, connect, nullptr)); +} + +/** + * @tc.name: ReleaseAbility_001 + * @tc.desc: Verify function ReleaseAbility return ERR_INVALID_VALUE + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AbilityManagerServiceTest, ReleaseAbility_001, TestSize.Level1) +{ + std::string localDeviceId; + bool getLocalDeviceId = abilityMs_->GetLocalDeviceId(localDeviceId); + EXPECT_EQ(true, getLocalDeviceId); + Want want; + ElementName element(localDeviceId, "com.ix.hiworld", "MusicAbility"); + want.SetElement(element); + EXPECT_EQ(ERR_INVALID_VALUE, abilityMs_->ReleaseAbility(nullptr, element)); +} + +/** + * @tc.name: ReleaseAbility_002 + * @tc.desc: Verify function ReleaseAbility return RELEASE_CALL_ABILITY_INNER_ERR + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AbilityManagerServiceTest, ReleaseAbility_002, TestSize.Level1) +{ + std::string localDeviceId; + bool getLocalDeviceId = abilityMs_->GetLocalDeviceId(localDeviceId); + EXPECT_EQ(true, getLocalDeviceId); + Want want; + ElementName element(localDeviceId, "com.ix.hiworld", "MusicAbility"); + want.SetElement(element); + sptr connect = new AbilityConnectCallback(); + EXPECT_EQ(RELEASE_CALL_ABILITY_INNER_ERR, abilityMs_->ReleaseAbility(connect, element)); +} + +/** + * @tc.name: OnCallConnectDied_001 + * @tc.desc: Verify function OnCallConnectDied call success + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AbilityManagerServiceTest, OnCallConnectDied_001, TestSize.Level1) +{ + std::shared_ptr callContainer = std::make_shared(); + EXPECT_EQ(callContainer->callRecordMap_.size(), 0); + + AbilityRequest abilityRequest; + abilityRequest.callerUid = 1; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.connect = new AbilityConnectCallback(); + std::shared_ptr callRecord = CallRecord::CreateCallRecord( + abilityRequest.callerUid, abilityRecord_->shared_from_this(), + abilityRequest.connect, abilityRequest.callerToken); + callRecord->SetCallState(CallState::REQUESTED); + callContainer->AddCallRecord(abilityRequest.connect, callRecord); + EXPECT_EQ(callContainer->callRecordMap_.size(), 1); + + auto mission = std::make_shared(0, abilityRecord_, "launcher"); + auto missionList = std::make_shared(); + missionList->AddMissionToTop(mission); + abilityRecord_->callContainer_ = callContainer; + + std::shared_ptr missionListMgr = std::make_shared(0); + missionListMgr->currentMissionLists_.push_front(missionList); + + abilityMs_->currentMissionListManager_ = missionListMgr; + abilityMs_->OnCallConnectDied(callRecord); + EXPECT_EQ(callContainer->callRecordMap_.size(), 0); +} +} +} \ No newline at end of file diff --git a/services/abilitymgr/test/unittest/phone/ability_manager_stub_test/ability_manager_stub_test.cpp b/services/abilitymgr/test/unittest/phone/ability_manager_stub_test/ability_manager_stub_test.cpp index b95f55bd057af129ca98f181e7d49b2c55b63f76..37fcbccc43874cd130124bcec662786c9d9fbbcd 100644 --- a/services/abilitymgr/test/unittest/phone/ability_manager_stub_test/ability_manager_stub_test.cpp +++ b/services/abilitymgr/test/unittest/phone/ability_manager_stub_test/ability_manager_stub_test.cpp @@ -449,5 +449,88 @@ HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_017, TestSize.Level1) EXPECT_EQ(res, NO_ERROR); } + +/* + * Feature: AbilityManagerService + * Function: OnRemoteRequest + * SubFunction: NA + * FunctionPoints: AbilityManagerService OnRemoteRequest + * EnvConditions: code is START_CALL_ABILITY + * CaseDescription: Verify that on remote request is normal + */ +HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_018, TestSize.Level1) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + Want want; + WriteInterfaceToken(data); + want.SetFlags(10); + data.WriteParcelable(&want); + int res = stub_->OnRemoteRequest(IAbilityManager::START_CALL_ABILITY, data, reply, option); + + EXPECT_EQ(res, NO_ERROR); +} + +/* + * Feature: AbilityManagerService + * Function: OnRemoteRequest + * SubFunction: NA + * FunctionPoints: AbilityManagerService OnRemoteRequest + * EnvConditions: code is START_CALL_ABILITY + * CaseDescription: Verify that on remote request is ERR_INVALID_VALUE + */ +HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_019, TestSize.Level1) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + WriteInterfaceToken(data); + int res = stub_->OnRemoteRequest(IAbilityManager::START_CALL_ABILITY, data, reply, option); + + EXPECT_EQ(res, ERR_INVALID_VALUE); +} + +/* + * Feature: AbilityManagerService + * Function: OnRemoteRequest + * SubFunction: NA + * FunctionPoints: AbilityManagerService OnRemoteRequest + * EnvConditions: code is START_CALL_ABILITY + * CaseDescription: Verify that on remote request is normal + */ +HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_020, TestSize.Level1) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + WriteInterfaceToken(data); + AppExecFwk::ElementName element; + sptr connect = new AbilityConnectCallback(); + data.WriteParcelable(connect->AsObject()); + data.WriteParcelable(&element); + int res = stub_->OnRemoteRequest(IAbilityManager::RELEASE_CALL_ABILITY, data, reply, option); + + EXPECT_EQ(res, NO_ERROR); +} + +/* + * Feature: AbilityManagerService + * Function: OnRemoteRequest + * SubFunction: NA + * FunctionPoints: AbilityManagerService OnRemoteRequest + * EnvConditions: code is START_CALL_ABILITY + * CaseDescription: Verify that on remote request is ERR_INVALID_VALUE + */ +HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_021, TestSize.Level1) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + WriteInterfaceToken(data); + int res = stub_->OnRemoteRequest(IAbilityManager::RELEASE_CALL_ABILITY, data, reply, option); + + EXPECT_EQ(res, ERR_INVALID_VALUE); +} } // namespace AAFwk } // namespace OHOS diff --git a/services/abilitymgr/test/unittest/phone/ability_record_test/BUILD.gn b/services/abilitymgr/test/unittest/phone/ability_record_test/BUILD.gn index 351a1aec8c0bfda118324f1a410678f7529c45b4..839a02b36af8775ae6fee846b81870756be03dfc 100644 --- a/services/abilitymgr/test/unittest/phone/ability_record_test/BUILD.gn +++ b/services/abilitymgr/test/unittest/phone/ability_record_test/BUILD.gn @@ -63,8 +63,60 @@ ohos_unittest("ability_record_test") { ] } +ohos_unittest("ability_record_test_call") { + module_out_path = "ability_runtime/ability_call_test" + + include_dirs = [ + "${services_path}/abilitymgr/test/mock/libs/system_ability_mock", + "//foundation/aafwk/standard/services/abilitymgr/test/mock/libs/ability_scheduler_mock", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy/include", + ] + + sources = [ + "//foundation/aafwk/standard/services/abilitymgr/test/mock/libs/appexecfwk_core/src/appmgr/mock_app_scheduler.cpp", + "ability_record_test_call.cpp", # add mock file + ] + + configs = [ + "${services_path}/abilitymgr:abilityms_config", + "${services_path}/abilitymgr/test/mock:aafwk_mock_config", + ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + deps = [ + "${innerkits_path}/want:want", + "${services_path}/abilitymgr/test:abilityms_test_source", + "${services_path}/abilitymgr/test/mock/libs/aakit:aakit_mock", + "${services_path}/abilitymgr/test/mock/libs/appexecfwk_core:appexecfwk_appmgr_mock", + "${services_path}/abilitymgr/test/mock/libs/appexecfwk_core:appexecfwk_bundlemgr_mock", + "${services_path}/common:perm_verification", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//foundation/aafwk/standard/frameworks/kits/ability/native:dummy_classes", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler:libeventhandler", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//third_party/libpng:libpng", + "//utils/native/base:utils", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "device_manager_base:devicemanagersdk", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] +} + group("unittest") { testonly = true - deps = [ ":ability_record_test" ] + deps = [ + ":ability_record_test", + ":ability_record_test_call", + ] } diff --git a/services/abilitymgr/test/unittest/phone/ability_record_test/ability_record_test_call.cpp b/services/abilitymgr/test/unittest/phone/ability_record_test/ability_record_test_call.cpp new file mode 100644 index 0000000000000000000000000000000000000000..cc73de74d50756c0fd5f7460cf606aa5e4fef13a --- /dev/null +++ b/services/abilitymgr/test/unittest/phone/ability_record_test/ability_record_test_call.cpp @@ -0,0 +1,430 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#define private public +#define protected public +#include "ability_record.h" +#undef private +#undef protected + +#include "ability_manager_service.h" +#include "ability_scheduler.h" +#include "connection_record.h" +#include "mission_record.h" +#include "mock_ability_connect_callback.h" +#include "ability_scheduler_mock.h" +#include "ability_connect_callback_stub.h" + +using namespace testing::ext; + +namespace OHOS { +namespace AAFwk { +class AbilityRecordTest : public testing::TestWithParam { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr abilityRecord_ {nullptr}; + std::shared_ptr abilityResult_ {nullptr}; + std::shared_ptr abilityRequest_ {nullptr}; + static constexpr unsigned int CHANGE_CONFIG_LOCALE = 0x00000001; +}; + +void AbilityRecordTest::SetUpTestCase(void) +{ + OHOS::DelayedSingleton::GetInstance()->OnStart(); +} +void AbilityRecordTest::TearDownTestCase(void) +{ + OHOS::DelayedSingleton::GetInstance()->OnStop(); +} + +void AbilityRecordTest::SetUp(void) +{ + OHOS::AppExecFwk::AbilityInfo abilityInfo; + OHOS::AppExecFwk::ApplicationInfo applicationInfo; + Want want; + abilityRecord_ = std::make_shared(want, abilityInfo, applicationInfo); + abilityResult_ = std::make_shared(-1, -1, want); + abilityRequest_ = std::make_shared(); + abilityRecord_->Init(); +} + +void AbilityRecordTest::TearDown(void) +{ + abilityRecord_.reset(); + abilityResult_.reset(); + abilityRequest_.reset(); +} + +bool IsTestAbilityExist(const std::string &data) +{ + return std::string::npos != data.find("previous ability app name [NULL]"); +} + +bool IsTestAbilityExist1(const std::string &data) +{ + return std::string::npos != data.find("test_pre_app"); +} + +bool IsTestAbilityExist2(const std::string &data) +{ + return std::string::npos != data.find("test_next_app"); +} + +/* + * Feature: AbilityRecord + * Function: IsCallType + * SubFunction: IsCallType + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Verify create one abilityRequest could through IsCallType INVALID_TYPE + */ +HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_IsCallType_001, TestSize.Level1) +{ + EXPECT_EQ(abilityRequest_->IsCallType(AbilityCallType::INVALID_TYPE), true); +} + +/* + * Feature: AbilityRecord + * Function: IsCallType + * SubFunction: IsCallType + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Verify create one abilityRequest could through IsCallType CALL_REQUEST_TYPE + */ +HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_IsCallType_002, TestSize.Level1) +{ + abilityRequest_->callType = AbilityCallType::CALL_REQUEST_TYPE; + EXPECT_EQ(abilityRequest_->IsCallType(AbilityCallType::CALL_REQUEST_TYPE), true); +} + +/* + * Feature: AbilityRecord + * Function: Resolve + * SubFunction: Resolve + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Verify create one abilityRecord could through Resolve + * ResolveResultType::NG_INNER_ERROR + */ +HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_Resolve_001, TestSize.Level1) +{ + AbilityRequest abilityRequest; + EXPECT_EQ(abilityRecord_->Resolve(abilityRequest), ResolveResultType::NG_INNER_ERROR); +} + +/* + * Feature: AbilityRecord + * Function: Resolve + * SubFunction: Resolve + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Verify create one abilityRequest could through Resolve + * ResolveResultType::NG_INNER_ERROR + */ +HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_Resolve_002, TestSize.Level1) +{ + AbilityRequest abilityRequest; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + EXPECT_EQ(abilityRecord_->Resolve(abilityRequest), ResolveResultType::NG_INNER_ERROR); +} + +/* + * Feature: AbilityRecord + * Function: Resolve + * SubFunction: Resolve + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Verify create one abilityRequest could through Resolve + * ResolveResultType::NG_INNER_ERROR + */ +HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_Resolve_003, TestSize.Level1) +{ + AbilityRequest abilityRequest; + abilityRequest.connect = new AbilityConnectCallback(); + EXPECT_EQ(abilityRecord_->Resolve(abilityRequest), ResolveResultType::NG_INNER_ERROR); +} + +/* + * Feature: AbilityRecord + * Function: Resolve + * SubFunction: Resolve + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Verify create one abilityRequest could through Resolve + * ResolveResultType::OK_HAS_REMOTE_OBJ + */ +HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_Resolve_004, TestSize.Level1) +{ + AbilityRequest abilityRequest; + abilityRequest.callerUid = 1; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.connect = new AbilityConnectCallback(); + std::shared_ptr callRecord = CallRecord::CreateCallRecord( + abilityRequest.callerUid, abilityRecord_->shared_from_this(), + abilityRequest.connect, abilityRequest.callerToken); + callRecord->SetCallState(CallState::REQUESTING); + abilityRecord_->callContainer_ = std::make_shared(); + abilityRecord_->callContainer_->AddCallRecord(abilityRequest.connect, callRecord); + class AbilitySchedulerMockFunction : public AbilitySchedulerMock + { + public: + virtual sptr CallRequest() override + { + return sptr(this); + } + }; + + OHOS::sptr scheduler = new AbilitySchedulerMockFunction(); + sptr object = scheduler->CallRequest(); + abilityRecord_->callContainer_->CallRequestDone(object); + callRecord->SetCallState(CallState::REQUESTED); + EXPECT_EQ(abilityRecord_->Resolve(abilityRequest), ResolveResultType::OK_HAS_REMOTE_OBJ); +} + +/* + * Feature: AbilityRecord + * Function: Resolve + * SubFunction: Resolve + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Verify create one abilityRequest could through Resolve + * ResolveResultType::OK_NO_REMOTE_OBJ + */ +HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_Resolve_005, TestSize.Level1) +{ + AbilityRequest abilityRequest; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.connect = new AbilityConnectCallback(); + EXPECT_EQ(abilityRecord_->Resolve(abilityRequest), ResolveResultType::OK_NO_REMOTE_OBJ); +} + +/* + * Feature: AbilityRecord + * Function: Release + * SubFunction: Release + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Verify create one abilityRecord could through Release false + */ +HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_Release_001, TestSize.Level1) +{ + sptr connect = new AbilityConnectCallback(); + EXPECT_EQ(abilityRecord_->Release(connect), false); +} + +/* + * Feature: AbilityRecord + * Function: Release + * SubFunction: Release + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Verify create one abilityRecord could through Release false + */ +HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_Release_002, TestSize.Level1) +{ + sptr connect = new AbilityConnectCallback(); + AbilityRequest abilityRequest; + abilityRequest.callerUid = 1; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.connect = connect; + std::shared_ptr callRecord = CallRecord::CreateCallRecord( + abilityRequest.callerUid, abilityRecord_->shared_from_this(), + abilityRequest.connect, abilityRequest.callerToken); + abilityRecord_->callContainer_ = std::make_shared(); + abilityRecord_->callContainer_->AddCallRecord(abilityRequest.connect, callRecord); + EXPECT_EQ(abilityRecord_->Release(connect), true); +} + +/* + * Feature: AbilityRecord + * Function: IsStartedByCall + * SubFunction: IsStartedByCall + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Verify create one abilityRecord could through IsStartedByCall false + */ +HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_IsStartedByCall_001, TestSize.Level1) +{ + EXPECT_EQ(abilityRecord_->IsStartedByCall(), false); +} + +/* + * Feature: AbilityRecord + * Function: SetStartedByCall + * SubFunction: SetStartedByCall + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Verify create one abilityRecord could through IsStartedByCall true + */ +HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetStartedByCall_001, TestSize.Level1) +{ + abilityRecord_->SetStartedByCall(true); + EXPECT_EQ(abilityRecord_->IsStartedByCall(), true); +} + +/* + * Feature: AbilityRecord + * Function: CallRequest + * SubFunction: CallRequest + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Verify create one abilityRecord could through Release success + */ +HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CallRequest_001, TestSize.Level1) +{ + class AbilitySchedulerMockFunction : public AbilitySchedulerMock + { + virtual sptr CallRequest() override + { + return sptr(this); + } + }; + + OHOS::sptr scheduler = new AbilitySchedulerMockFunction(); + abilityRecord_->lifecycleDeal_ = std::make_unique(); + EXPECT_EQ(false, abilityRecord_->IsReady()); + abilityRecord_->SetScheduler(scheduler); + + AbilityRequest abilityRequest; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.connect = new AbilityConnectCallback(); + EXPECT_EQ(abilityRecord_->Resolve(abilityRequest), ResolveResultType::OK_NO_REMOTE_OBJ); + EXPECT_EQ(abilityRecord_->CallRequest(), true); +} + +/* + * Feature: AbilityRecord + * Function: CallRequest + * SubFunction: CallRequest + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Verify create one abilityRecord could through Release success + */ +HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CallRequest_002, TestSize.Level1) +{ + OHOS::sptr scheduler = new AbilitySchedulerMock(); + abilityRecord_->lifecycleDeal_ = std::make_unique(); + EXPECT_EQ(false, abilityRecord_->IsReady()); + abilityRecord_->SetScheduler(scheduler); + + AbilityRequest abilityRequest; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.connect = new AbilityConnectCallback(); + EXPECT_EQ(abilityRecord_->Resolve(abilityRequest), ResolveResultType::OK_NO_REMOTE_OBJ); + EXPECT_EQ(abilityRecord_->CallRequest(), false); +} + +/* + * Feature: AbilityRecord + * Function: IsStartToBackground + * SubFunction: IsStartToBackground + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Verify create one abilityRecord could through IsStartToBackground false + */ +HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_IsStartToBackground_001, TestSize.Level1) +{ + EXPECT_EQ(abilityRecord_->IsStartToBackground(), false); +} + +/* + * Feature: AbilityRecord + * Function: SetStartToBackground + * SubFunction: SetStartToBackground + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Verify create one abilityRecord could through SetStartToBackground success + */ +HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetStartToBackground_002, TestSize.Level1) +{ + abilityRecord_->SetStartToBackground(true); + EXPECT_EQ(abilityRecord_->IsStartToBackground(), true); + abilityRecord_->SetStartToBackground(false); + EXPECT_EQ(abilityRecord_->IsStartToBackground(), false); +} + +/* + * Feature: AbilityRecord + * Function: SetSpecifiedFlag + * SubFunction: SetSpecifiedFlag + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Verify create one abilityRecord could through SetSpecifiedFlag success + */ +HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetSpecifiedFlag_001, TestSize.Level1) +{ + const std::string specifiedFlag= "flag"; + abilityRecord_->SetSpecifiedFlag(specifiedFlag); + EXPECT_EQ(specifiedFlag, abilityRecord_->GetSpecifiedFlag()); +} + +/* + * Feature: AbilityRecord + * Function: GetSpecifiedFlag + * SubFunction: GetSpecifiedFlag + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Verify create one abilityRecord could through GetSpecifiedFlag success + */ +HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_GetSpecifiedFlag_002, TestSize.Level1) +{ + EXPECT_EQ(std::string(), abilityRecord_->GetSpecifiedFlag()); +} + +/* + * Feature: AbilityRecord + * Function: IsNeedToCallRequest + * SubFunction: IsNeedToCallRequest + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Verify create one abilityRecord could through SetSpecifiedFlag false + */ +HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_IsNeedToCallRequest_001, TestSize.Level1) +{ + EXPECT_EQ(false, abilityRecord_->IsNeedToCallRequest()); +} + +/* + * Feature: AbilityRecord + * Function: IsNeedToCallRequest + * SubFunction: IsNeedToCallRequest + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Verify create one abilityRecord could through GetSpecifiedFlag success + */ +HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_IsNeedToCallRequest_002, TestSize.Level1) +{ + AbilityRequest abilityRequest; + abilityRequest.callerUid = 1; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.connect = new AbilityConnectCallback(); + std::shared_ptr callRecord = CallRecord::CreateCallRecord( + abilityRequest.callerUid, abilityRecord_->shared_from_this(), + abilityRequest.connect, abilityRequest.callerToken); + callRecord->SetCallState(CallState::INIT); + + abilityRecord_->callContainer_ = std::make_shared(); + abilityRecord_->callContainer_->AddCallRecord(abilityRequest.connect, callRecord); + + EXPECT_EQ(true, abilityRecord_->IsNeedToCallRequest()); +} +} // namespace AAFwk +} // namespace OHOS \ No newline at end of file diff --git a/services/abilitymgr/test/unittest/phone/ability_scheduler_proxy_test/ability_scheduler_proxy_test.cpp b/services/abilitymgr/test/unittest/phone/ability_scheduler_proxy_test/ability_scheduler_proxy_test.cpp index 574bf41a41752ca787f6ac6dc8b7af0865647cbf..63b4f252406db32a04a1dd9a3cd7fcdebbff9ab0 100644 --- a/services/abilitymgr/test/unittest/phone/ability_scheduler_proxy_test/ability_scheduler_proxy_test.cpp +++ b/services/abilitymgr/test/unittest/phone/ability_scheduler_proxy_test/ability_scheduler_proxy_test.cpp @@ -294,5 +294,37 @@ HWTEST_F(AbilitySchedulerProxyTest, ability_scheduler_proxy_operating_013, TestS EXPECT_EQ(IAbilityScheduler::NOTIFY_CONTINUATION_RESULT, mock_->code_); } + +/** + * @tc.name: ability_scheduler_proxy_operating_014 + * @tc.desc: test CallRequest + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AbilitySchedulerProxyTest, ability_scheduler_proxy_operating_014, TestSize.Level0) +{ + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) + .Times(1) + .WillOnce(Invoke(mock_.GetRefPtr(), &AbilitySchedulerMock::InvokeSendRequest)); + abilitySchedulerProxy_->CallRequest(); + + EXPECT_EQ(IAbilityScheduler::REQUEST_CALL_REMOTE, mock_->code_); +} + +/** + * @tc.name: ability_scheduler_proxy_operating_015 + * @tc.desc: test CallRequest + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AbilitySchedulerProxyTest, ability_scheduler_proxy_operating_015, TestSize.Level0) +{ + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) + .Times(1) + .WillOnce(Invoke(mock_.GetRefPtr(), &AbilitySchedulerMock::InvokeErrorSendRequest)); + abilitySchedulerProxy_->CallRequest(); + + EXPECT_EQ(IAbilityScheduler::REQUEST_CALL_REMOTE, mock_->code_); +} } // namespace AAFwk } // namespace OHOS \ No newline at end of file diff --git a/services/abilitymgr/test/unittest/phone/ability_scheduler_stub_test/ability_schedule_stub_mock.h b/services/abilitymgr/test/unittest/phone/ability_scheduler_stub_test/ability_schedule_stub_mock.h index ce061009455fb9542e134f5bd19a36c0883b36d4..2ef828793c70d7b8a2f10379d8eada21ac73329c 100755 --- a/services/abilitymgr/test/unittest/phone/ability_scheduler_stub_test/ability_schedule_stub_mock.h +++ b/services/abilitymgr/test/unittest/phone/ability_scheduler_stub_test/ability_schedule_stub_mock.h @@ -137,7 +137,7 @@ public: {} virtual sptr CallRequest() override { - return sptr(nullptr); + return sptr(this); } }; } // namespace AAFwk diff --git a/services/abilitymgr/test/unittest/phone/ability_scheduler_stub_test/ability_scheduler_stub_test.cpp b/services/abilitymgr/test/unittest/phone/ability_scheduler_stub_test/ability_scheduler_stub_test.cpp index 2481809453e0bb0c0cbeacfb01734b8773395b9c..1e4cf5613a0430114847813218ddb4a73fbef939 100644 --- a/services/abilitymgr/test/unittest/phone/ability_scheduler_stub_test/ability_scheduler_stub_test.cpp +++ b/services/abilitymgr/test/unittest/phone/ability_scheduler_stub_test/ability_scheduler_stub_test.cpp @@ -234,5 +234,23 @@ HWTEST_F(AbilitySchedulerStubTest, AbilitySchedulerStub_009, TestSize.Level0) auto res = stub_->OnRemoteRequest(IAbilityScheduler::NOTIFY_CONTINUATION_RESULT, data, reply, option); EXPECT_EQ(res, NO_ERROR); } + +/** + * @tc.name: AbilitySchedulerStub_0010 + * @tc.desc: test NotifyContinuationResult + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AbilitySchedulerStubTest, AbilitySchedulerStub_0010, TestSize.Level0) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + WriteInterfaceToken(data); + int32_t result = 0; + data.WriteInt32(result); + auto res = stub_->OnRemoteRequest(IAbilityScheduler::REQUEST_CALL_REMOTE, data, reply, option); + EXPECT_EQ(res, NO_ERROR); +} } // namespace AAFwk } // namespace OHOS \ No newline at end of file diff --git a/services/abilitymgr/test/unittest/phone/call_container_test/BUILD.gn b/services/abilitymgr/test/unittest/phone/call_container_test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..0aaecc1c3534970d163563076a1e9b64873c35c9 --- /dev/null +++ b/services/abilitymgr/test/unittest/phone/call_container_test/BUILD.gn @@ -0,0 +1,65 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/aafwk/standard/aafwk.gni") + +module_output_path = "ability_runtime/ability_call_test" + +ohos_unittest("call_container_test") { + module_out_path = module_output_path + + include_dirs = [ + "${services_path}/abilitymgr/test/mock/libs/system_ability_mock", + "//foundation/aafwk/standard/services/abilitymgr/test/mock/libs/ability_scheduler_mock", + "//foundation/communication/ipc/interfaces/innerkits/ipc_core/include", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy/include", + ] + + sources = [ + "//foundation/aafwk/standard/services/abilitymgr/test/mock/libs/appexecfwk_core/src/appmgr/mock_app_scheduler.cpp", + "call_container_test.cpp", + ] + + configs = [ + "${services_path}/abilitymgr:abilityms_config", + "${services_path}/abilitymgr/test/mock:aafwk_mock_config", + ] + + deps = [ + "${innerkits_path}/want:want", + "${services_path}/abilitymgr/test:abilityms_test_source", + "${services_path}/abilitymgr/test/mock/libs/aakit:aakit_mock", + "${services_path}/abilitymgr/test/mock/libs/appexecfwk_core:appexecfwk_appmgr_mock", + "${services_path}/common:perm_verification", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//foundation/aafwk/standard/frameworks/kits/ability/native:dummy_classes", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//third_party/libpng:libpng", + "//utils/native/base:utils", + ] + + external_deps = [ + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] +} + +group("unittest") { + testonly = true + + deps = [ ":call_container_test" ] +} diff --git a/services/abilitymgr/test/unittest/phone/call_container_test/call_container_test.cpp b/services/abilitymgr/test/unittest/phone/call_container_test/call_container_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..1f17623ce7b45ab8eac971b981b8b200cfed1d8a --- /dev/null +++ b/services/abilitymgr/test/unittest/phone/call_container_test/call_container_test.cpp @@ -0,0 +1,459 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#define private public +#define protected public +#include "call_container.h" +#include "ability_record.h" +#include "ability_manager_service.h" +#undef private +#undef protected +#include "ability_event_handler.h" +#include "ability_scheduler_mock.h" +#include "mock_ability_connect_callback.h" + +using namespace testing::ext; + + +static void WaitUntilTaskFinished() +{ + const uint32_t maxRetryCount = 1000; + const uint32_t sleepTime = 1000; + uint32_t count = 0; + auto handler = OHOS::DelayedSingleton::GetInstance()->GetEventHandler(); + std::atomic taskCalled(false); + auto f = [&taskCalled]() { taskCalled.store(true); }; + if (handler->PostTask(f)) { + while (!taskCalled.load()) { + ++count; + if (count >= maxRetryCount) { + std::cout << "max count\n"; + break; + } + usleep(sleepTime); + } + } +} + +namespace OHOS { +namespace AAFwk { +class CallContainerTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + void OnStartAms(); + std::shared_ptr get() const; + std::shared_ptr abilityRecord_ {nullptr}; +private: + std::shared_ptr callContainer_ {nullptr}; + std::shared_ptr abilityMgrServ_ {nullptr}; + int MOCK_MAIN_USER_ID = 100; +}; + +void CallContainerTest::SetUpTestCase(void) +{ +} +void CallContainerTest::TearDownTestCase(void) +{ + DelayedSingleton::DestroyInstance(); +} +void CallContainerTest::TearDown() +{ + DelayedSingleton::DestroyInstance(); +} + +void CallContainerTest::SetUp() +{ + callContainer_ = std::make_shared(); + OHOS::AppExecFwk::AbilityInfo abilityInfo; + OHOS::AppExecFwk::ApplicationInfo applicationInfo; + Want want; + abilityRecord_ = std::make_shared(want, abilityInfo, applicationInfo); + abilityMgrServ_ = DelayedSingleton::GetInstance(); + OnStartAms(); +} + +void CallContainerTest::OnStartAms() +{ + if (abilityMgrServ_) { + if (abilityMgrServ_->state_ == ServiceRunningState::STATE_RUNNING) { + return; + } + + abilityMgrServ_->state_ = ServiceRunningState::STATE_RUNNING; + abilityMgrServ_->useNewMission_ = true; + + abilityMgrServ_->eventLoop_ = AppExecFwk::EventRunner::Create(AbilityConfig::NAME_ABILITY_MGR_SERVICE); + EXPECT_TRUE(abilityMgrServ_->eventLoop_); + + abilityMgrServ_->handler_ = std::make_shared(abilityMgrServ_->eventLoop_, abilityMgrServ_); + EXPECT_TRUE(abilityMgrServ_->handler_); + + // init user controller. + abilityMgrServ_->userController_ = std::make_shared(); + EXPECT_TRUE(abilityMgrServ_->userController_); + abilityMgrServ_->userController_->Init(); + int userId = MOCK_MAIN_USER_ID; + abilityMgrServ_->userController_->SetCurrentUserId(userId); + abilityMgrServ_->InitConnectManager(userId, true); + abilityMgrServ_->InitDataAbilityManager(userId, true); + abilityMgrServ_->InitPendWantManager(userId, true); + abilityMgrServ_->systemDataAbilityManager_ = std::make_shared(); + EXPECT_TRUE(abilityMgrServ_->systemDataAbilityManager_); + + abilityMgrServ_->amsConfigResolver_ = std::make_shared(); + EXPECT_TRUE(abilityMgrServ_->amsConfigResolver_); + abilityMgrServ_->amsConfigResolver_->Parse(); + abilityMgrServ_->useNewMission_ = abilityMgrServ_->amsConfigResolver_->IsUseNewMission(); + + abilityMgrServ_->SetStackManager(userId, true); + abilityMgrServ_->InitMissionListManager(userId, true); + abilityMgrServ_->connectManager_->SetEventHandler(abilityMgrServ_->handler_); + abilityMgrServ_->eventLoop_->Run(); + auto topAbility = abilityMgrServ_->GetListManagerByUserId(MOCK_MAIN_USER_ID)->GetCurrentTopAbilityLocked(); + if (topAbility) { + topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND_NEW); + } + WaitUntilTaskFinished(); + return; + } + + GTEST_LOG_(INFO) << "OnStart fail"; +} + + +std::shared_ptr CallContainerTest::get() const +{ + return callContainer_; +} + +/* + * Feature: CallContainer + * Function: AddCallRecord + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions:NA + * CaseDescription: Verify funtion call called + */ +HWTEST_F(CallContainerTest, Call_Container_Add_Call_Record_001, TestSize.Level1) +{ + std::shared_ptr callContainer = get(); + AbilityRequest abilityRequest; + abilityRequest.callerUid = 1; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.connect = new AbilityConnectCallback(); + std::shared_ptr callRecord = CallRecord::CreateCallRecord( + abilityRequest.callerUid, abilityRecord_->shared_from_this(), + abilityRequest.connect, abilityRequest.callerToken); + callContainer->AddCallRecord(abilityRequest.connect, callRecord); + + std::shared_ptr getCallRecord = callContainer->GetCallRecord(abilityRequest.connect); + EXPECT_EQ(callRecord, getCallRecord); +} + +/* + * Feature: CallContainer + * Function: GetCallRecord + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions:NA + * CaseDescription: Verify funtion call called + */ +HWTEST_F(CallContainerTest, Call_Container_Get_Call_Record_001, TestSize.Level1) +{ + sptr connect = new AbilityConnectCallback(); + std::shared_ptr callContainer = get(); + std::shared_ptr getCallRecord = callContainer->GetCallRecord(connect); + EXPECT_EQ(nullptr, getCallRecord); +} + +/* + * Feature: CallContainer + * Function: RemoveCallRecord + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions:NA + * CaseDescription: Verify funtion call called + */ +HWTEST_F(CallContainerTest, Call_Container_Remove_Call_Record_001, TestSize.Level1) +{ + sptr connect = new AbilityConnectCallback(); + std::shared_ptr callContainer = get(); + bool result = callContainer->RemoveCallRecord(connect); + EXPECT_EQ(result, false); +} + +/* + * Feature: CallContainer + * Function: RemoveCallRecord + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions:NA + * CaseDescription: Verify funtion call called + */ +HWTEST_F(CallContainerTest, Call_Container_Remove_Call_Record_002, TestSize.Level1) +{ + std::shared_ptr callContainer = get(); + AbilityRequest abilityRequest; + abilityRequest.callerUid = 1; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.connect = new AbilityConnectCallback(); + std::shared_ptr callRecord = CallRecord::CreateCallRecord( + abilityRequest.callerUid, abilityRecord_->shared_from_this(), + abilityRequest.connect, abilityRequest.callerToken); + callContainer->AddCallRecord(abilityRequest.connect, callRecord); + + bool result = callContainer->RemoveCallRecord(abilityRequest.connect); + EXPECT_EQ(result, true); +} + +/* + * Feature: CallContainer + * Function: CallRequestDone + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions:NA + * CaseDescription: Verify funtion call called + */ +HWTEST_F(CallContainerTest, Call_Container_Call_Request_Done_001, TestSize.Level1) +{ + std::shared_ptr callContainer = get(); + OHOS::sptr scheduler = new AbilitySchedulerMock(); + abilityRecord_->SetScheduler(scheduler); + sptr object = scheduler->CallRequest(); + bool result = callContainer->CallRequestDone(object); + EXPECT_EQ(result, false); +} + +/* + * Feature: CallContainer + * Function: CallRequestDone + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions:NA + * CaseDescription: Verify funtion call called + */ +HWTEST_F(CallContainerTest, Call_Container_Call_Request_Done_002, TestSize.Level1) +{ + class AbilitySchedulerMockFunction : public AbilitySchedulerMock { + virtual sptr CallRequest() { return this; } + }; + + std::shared_ptr callContainer = get(); + OHOS::sptr scheduler = new AbilitySchedulerMockFunction(); + sptr object = scheduler->CallRequest(); + bool result = callContainer->CallRequestDone(object); + EXPECT_EQ(result, true); +} + +/* + * Feature: CallContainer + * Function: Dump + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions:NA + * CaseDescription: Verify funtion call called + */ +HWTEST_F(CallContainerTest, Call_Container_Dump_001, TestSize.Level1) +{ + std::shared_ptr callContainer = get(); + std::vector dumpInfo; + callContainer->Dump(dumpInfo); + EXPECT_EQ(dumpInfo.size(), 0); +} + +/* + * Feature: CallContainer + * Function: Dump + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions:NA + * CaseDescription: Verify funtion call called + */ +HWTEST_F(CallContainerTest, Call_Container_Dump_002, TestSize.Level1) +{ + std::shared_ptr callContainer = get(); + AbilityRequest abilityRequest; + abilityRequest.callerUid = 1; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.connect = new AbilityConnectCallback(); + std::shared_ptr callRecord = CallRecord::CreateCallRecord( + abilityRequest.callerUid, abilityRecord_->shared_from_this(), + abilityRequest.connect, abilityRequest.callerToken); + callContainer->AddCallRecord(abilityRequest.connect, callRecord); + + std::vector dumpInfo; + callContainer->Dump(dumpInfo); + EXPECT_NE(dumpInfo.size(), 0); +} + +/* + * Feature: CallContainer + * Function: IsNeedToCallRequest + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions:NA + * CaseDescription: Verify funtion call called + */ +HWTEST_F(CallContainerTest, Call_Container_Is_Need_To_Call_Request_001, TestSize.Level1) +{ + std::shared_ptr callContainer = get(); + EXPECT_EQ(callContainer->IsNeedToCallRequest(), false); +} + +/* + * Feature: CallContainer + * Function: IsNeedToCallRequest + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions:NA + * CaseDescription: Verify funtion call called + */ +HWTEST_F(CallContainerTest, Call_Container_Is_Need_To_Call_Request_002, TestSize.Level1) +{ + std::shared_ptr callContainer = get(); + AbilityRequest abilityRequest; + abilityRequest.callerUid = 1; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.connect = new AbilityConnectCallback(); + std::shared_ptr callRecord = CallRecord::CreateCallRecord( + abilityRequest.callerUid, abilityRecord_->shared_from_this(), + abilityRequest.connect, abilityRequest.callerToken); + callRecord->SetCallState(CallState::INIT); + callContainer->AddCallRecord(abilityRequest.connect, callRecord); + EXPECT_EQ(callContainer->IsNeedToCallRequest(), true); +} + +/* + * Feature: CallContainer + * Function: IsNeedToCallRequest + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions:NA + * CaseDescription: Verify funtion call called + */ +HWTEST_F(CallContainerTest, Call_Container_Is_Need_To_Call_Request_003, TestSize.Level1) +{ + std::shared_ptr callContainer = get(); + AbilityRequest abilityRequest; + abilityRequest.callerUid = 1; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.connect = new AbilityConnectCallback(); + std::shared_ptr callRecord = CallRecord::CreateCallRecord( + abilityRequest.callerUid, abilityRecord_->shared_from_this(), + abilityRequest.connect, abilityRequest.callerToken); + callRecord->SetCallState(CallState::REQUESTING); + callContainer->AddCallRecord(abilityRequest.connect, callRecord); + EXPECT_EQ(callContainer->IsNeedToCallRequest(), true); +} + +/* + * Feature: CallContainer + * Function: IsNeedToCallRequest + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions:NA + * CaseDescription: Verify funtion call called + */ +HWTEST_F(CallContainerTest, Call_Container_Is_Need_To_Call_Request_004, TestSize.Level1) +{ + std::shared_ptr callContainer = get(); + AbilityRequest abilityRequest; + abilityRequest.callerUid = 1; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.connect = new AbilityConnectCallback(); + std::shared_ptr callRecord = CallRecord::CreateCallRecord( + abilityRequest.callerUid, abilityRecord_->shared_from_this(), + abilityRequest.connect, abilityRequest.callerToken); + callRecord->SetCallState(CallState::REQUESTED); + callContainer->AddCallRecord(abilityRequest.connect, callRecord); + EXPECT_EQ(callContainer->IsNeedToCallRequest(), false); +} + +/* + * Feature: CallContainer + * Function: AddConnectDeathRecipient + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions:NA + * CaseDescription: Verify funtion call called + */ +HWTEST_F(CallContainerTest, Call_Container_Add_Connect_Death_Recipient_001, TestSize.Level1) +{ + std::shared_ptr callContainer = get(); + sptr connect = new AbilityConnectCallback(); + callContainer->AddConnectDeathRecipient(connect); + EXPECT_EQ(callContainer->deathRecipientMap_.size(), 1); +} + +/* + * Feature: CallContainer + * Function: RemoveConnectDeathRecipient + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions:NA + * CaseDescription: Verify funtion call called + */ +HWTEST_F(CallContainerTest, Call_Container_Remove_Connect_Death_Recipient_001, TestSize.Level1) +{ + std::shared_ptr callContainer = get(); + sptr connect = new AbilityConnectCallback(); + callContainer->AddConnectDeathRecipient(connect); + callContainer->RemoveConnectDeathRecipient(connect); + EXPECT_EQ(callContainer->deathRecipientMap_.size(), 0); +} + +/* + * Feature: CallContainer + * Function: OnConnectionDied + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions:NA + * CaseDescription: Verify funtion call called + */ +HWTEST_F(CallContainerTest, Call_Container_On_Connect_Died_001, TestSize.Level1) +{ + std::shared_ptr callContainer = get(); + EXPECT_EQ(callContainer->callRecordMap_.size(), 0); + + AbilityRequest abilityRequest; + abilityRequest.callerUid = 1; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.connect = new AbilityConnectCallback(); + std::shared_ptr callRecord = CallRecord::CreateCallRecord( + abilityRequest.callerUid, abilityRecord_->shared_from_this(), + abilityRequest.connect, abilityRequest.callerToken); + callRecord->SetCallState(CallState::REQUESTED); + callContainer->AddCallRecord(abilityRequest.connect, callRecord); + EXPECT_EQ(callContainer->callRecordMap_.size(), 1); + + auto mission = std::make_shared(0, abilityRecord_, "launcher"); + auto missionList = std::make_shared(); + missionList->AddMissionToTop(mission); + abilityRecord_->callContainer_ = callContainer; + + std::shared_ptr missionListMgr = std::make_shared(0); + missionListMgr->currentMissionLists_.push_front(missionList); + DelayedSingleton::GetInstance()->currentMissionListManager_ = missionListMgr; + callContainer->OnConnectionDied(abilityRequest.connect->AsObject()); + WaitUntilTaskFinished(); + + EXPECT_EQ(callContainer->callRecordMap_.size(), 0); +} +} // namespace AAFwk +} // namespace OHOS \ No newline at end of file diff --git a/services/abilitymgr/test/unittest/phone/call_record_test/BUILD.gn b/services/abilitymgr/test/unittest/phone/call_record_test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..0b38683cc116baab467122b3882448c4853abe78 --- /dev/null +++ b/services/abilitymgr/test/unittest/phone/call_record_test/BUILD.gn @@ -0,0 +1,60 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/aafwk/standard/aafwk.gni") + +module_output_path = "ability_runtime/ability_call_test" + +ohos_unittest("call_record_test") { + module_out_path = module_output_path + + include_dirs = [ + "${services_path}/abilitymgr/test/mock/libs/system_ability_mock", + "//foundation/communication/ipc/interfaces/innerkits/ipc_core/include", + "//foundation/communication/ipc/interfaces/innerkits/ipc_core/include", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy/include", + ] + + sources = [ + "//foundation/aafwk/standard/services/abilitymgr/test/mock/libs/appexecfwk_core/src/appmgr/mock_app_scheduler.cpp", + "call_record_test.cpp", + ] + + configs = [ "${services_path}/abilitymgr:abilityms_config" ] + + deps = [ + "${innerkits_path}/want:want", + "${services_path}/abilitymgr/test:abilityms_test_source", + "${services_path}/abilitymgr/test/mock/libs/appexecfwk_core:appexecfwk_appmgr_mock", + "${services_path}/common:perm_verification", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//foundation/aafwk/standard/frameworks/kits/ability/native:dummy_classes", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//third_party/googletest:gtest_main", + "//third_party/libpng:libpng", + "//utils/native/base:utils", + ] + + external_deps = [ + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] +} + +group("unittest") { + testonly = true + + deps = [ ":call_record_test" ] +} diff --git a/services/abilitymgr/test/unittest/phone/call_record_test/call_record_test.cpp b/services/abilitymgr/test/unittest/phone/call_record_test/call_record_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..c855068afac404d5876d5e10570abb71d62c8348 --- /dev/null +++ b/services/abilitymgr/test/unittest/phone/call_record_test/call_record_test.cpp @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "call_record.h" + +using namespace testing::ext; +using OHOS::sptr; + +namespace OHOS { +namespace AAFwk { +class CallRecordTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void CallRecordTest::SetUpTestCase(void) +{} +void CallRecordTest::TearDownTestCase(void) +{} +void CallRecordTest::TearDown() +{} + +void CallRecordTest::SetUp() +{} + +/* + * Feature: WindowInfo + * Function: OnRemoteDied + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions:NA + * CaseDescription: Verify funtion call called + */ +HWTEST_F(CallRecordTest, AAFWK_Call_Record, TestSize.Level1) +{ + static bool value = false; + + auto function = [] (const wptr &) { value = true;}; + AbilityCallRecipient abilityCallRecipient(function); + + wptr object = nullptr; + abilityCallRecipient.OnRemoteDied(object); + EXPECT_EQ(value, true); +} +} // namespace AAFwk +} // namespace OHOS \ No newline at end of file diff --git a/services/abilitymgr/test/unittest/phone/mission_list_manager_ut_test/BUILD.gn b/services/abilitymgr/test/unittest/phone/mission_list_manager_ut_test/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..fda9a0da7cdf294c1a550587b07cfcd51cdd3bf5 --- /dev/null +++ b/services/abilitymgr/test/unittest/phone/mission_list_manager_ut_test/BUILD.gn @@ -0,0 +1,73 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/aafwk/standard/aafwk.gni") + +module_output_path = "ability_runtime/abilitymgr" + +ohos_unittest("mission_list_manager_ut_test") { + module_out_path = module_output_path + + include_dirs = [ + "${services_path}/abilitymgr/test/mock/libs/system_ability_mock", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy/include", + ] + + sources = [ + "./mission_list_manager_ut_test.cpp", # add mock file + ] + + configs = [ + "${services_path}/abilitymgr:abilityms_config", + "${services_path}/abilitymgr/test/mock:aafwk_mock_config", + ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + deps = [ + "${innerkits_path}/want:want", + "${services_path}/abilitymgr/test:abilityms_test_source", + "${services_path}/abilitymgr/test/mock/libs/aakit:aakit_mock", + "${services_path}/abilitymgr/test/mock/libs/appexecfwk_core:appexecfwk_appmgr_mock", + "${services_path}/abilitymgr/test/mock/libs/appexecfwk_core:appexecfwk_bundlemgr_mock", + "${services_path}/common:perm_verification", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//foundation/aafwk/standard/frameworks/kits/ability/native:dummy_classes", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler:libeventhandler", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//third_party/libpng:libpng", + "//utils/native/base:utils", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "device_manager_base:devicemanagersdk", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "native_appdatamgr:native_appdatafwk", + "native_appdatamgr:native_dataability", + "native_appdatamgr:native_rdb", + ] +} + +group("unittest") { + testonly = true + + deps = [ ":mission_list_manager_ut_test" ] +} diff --git a/services/abilitymgr/test/unittest/phone/mission_list_manager_ut_test/mission_list_manager_ut_test.cpp b/services/abilitymgr/test/unittest/phone/mission_list_manager_ut_test/mission_list_manager_ut_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..017f5172a6b729da86647d097509d4dd60840d7e --- /dev/null +++ b/services/abilitymgr/test/unittest/phone/mission_list_manager_ut_test/mission_list_manager_ut_test.cpp @@ -0,0 +1,580 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include +#include + +#include +#include + +#include "ability_connect_callback_interface.h" +#include "ability_loader.h" +#include "ability_thread.h" +#define private public +#define protected public +#include "ability_record.h" +#include "call_record.h" +#include "mission_list.h" +#include "mission.h" +#include "mission_info_mgr.h" +#include "mission_list_manager.h" + +namespace OHOS { +namespace AAFwk { +using namespace testing::ext; +using namespace OHOS::AbilityRuntime; + +namespace { +} + +class MissionListManagerTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +public: + std::unique_ptr missionListMgr_ = nullptr; +}; + +void MissionListManagerTest::SetUpTestCase(void) +{} + +void MissionListManagerTest::TearDownTestCase(void) +{} + +void MissionListManagerTest::SetUp(void) +{} + +void MissionListManagerTest::TearDown(void) +{} + +class MissionListManagerTestStub : public IRemoteStub { +public: + MissionListManagerTestStub() {}; + virtual ~MissionListManagerTestStub() {}; + + virtual int OnRemoteRequest( + uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) + { + return 0; + }; + + virtual void OnAbilityConnectDone( + const AppExecFwk::ElementName &element, const sptr &remoteObject, int resultCode) {}; + + /** + * OnAbilityDisconnectDone, AbilityMs notify caller ability the result of disconnect. + * + * @param element, service ability's ElementName. + * @param resultCode, ERR_OK on success, others on failure. + */ + virtual void OnAbilityDisconnectDone(const AppExecFwk::ElementName &element, int resultCode) {}; +}; + +class MissionListManagerTestAbilityThreadStub : public AppExecFwk::AbilityThread { +public: + MissionListManagerTestAbilityThreadStub() {}; + ~MissionListManagerTestAbilityThreadStub() {}; + + sptr CallRequest() + { + sptr remote = new (std::nothrow) MissionListManagerTestStub(); + return remote->AsObject(); + } +}; + +/** + * @tc.number: MissionListManager_001 + * @tc.name: OnCallConnectDied + * @tc.desc: MissionListManager to process OnCallConnectDied success. + */ +HWTEST_F(MissionListManagerTest, MissionListManager_001, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "MissionListManager_001 begin"; + Want want; + AppExecFwk::AbilityInfo abilityInfo; + AppExecFwk::ApplicationInfo applicationInfo; + + int32_t callerUid; + sptr connCallback = new (std::nothrow) MissionListManagerTestStub(); + sptr callToken = nullptr; + AppExecFwk::ElementName element; + + std::shared_ptr missionListMgr = std::make_shared(0); + std::shared_ptr abilityRecord = + std::make_shared(want, abilityInfo, applicationInfo); + std::shared_ptr callRecord = + std::make_shared(callerUid, abilityRecord, connCallback, callToken); + std::shared_ptr missionList = std::make_shared(); + std::shared_ptr mission = std::make_shared(0, abilityRecord, ""); + std::shared_ptr callContainer = std::make_shared(); + + callContainer->AddCallRecord(connCallback, callRecord); + abilityRecord->callContainer_ = callContainer; + missionList->AddMissionToTop(mission); + missionListMgr->currentMissionLists_.push_front(missionList); + + auto testValue = static_cast(callContainer->callRecordMap_.size()); + EXPECT_EQ(1, testValue); + missionListMgr->OnCallConnectDied(callRecord); + + testValue = static_cast(callContainer->callRecordMap_.size()); + EXPECT_EQ(0, testValue); + GTEST_LOG_(INFO) << "MissionListManager_001 end"; +} + +/** + * @tc.number: MissionListManager_002 + * @tc.name: OnCallConnectDied + * @tc.desc: MissionListManager to process OnCallConnectDied success. + */ +HWTEST_F(MissionListManagerTest, MissionListManager_002, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "MissionListManager_002 begin"; + Want want; + AppExecFwk::AbilityInfo abilityInfo; + AppExecFwk::ApplicationInfo applicationInfo; + + int32_t callerUid; + sptr connCallback = new (std::nothrow) MissionListManagerTestStub(); + sptr callToken = nullptr; + AppExecFwk::ElementName element; + + std::shared_ptr missionListMgr = std::make_shared(0); + std::shared_ptr abilityRecord = + std::make_shared(want, abilityInfo, applicationInfo); + std::shared_ptr callRecord = + std::make_shared(callerUid, abilityRecord, connCallback, callToken); + std::shared_ptr missionList = std::make_shared(); + std::shared_ptr mission = std::make_shared(0, abilityRecord, ""); + std::shared_ptr callContainer = std::make_shared(); + + callContainer->AddCallRecord(connCallback, callRecord); + abilityRecord->callContainer_ = callContainer; + missionList->AddMissionToTop(mission); + missionListMgr->currentMissionLists_.push_front(missionList); + + auto testValue = static_cast(callContainer->callRecordMap_.size()); + EXPECT_EQ(1, testValue); + missionListMgr->OnCallConnectDied(nullptr); + + testValue = static_cast(callContainer->callRecordMap_.size()); + EXPECT_EQ(1, testValue); + GTEST_LOG_(INFO) << "MissionListManager_002 end"; +} + +/** + * @tc.number: MissionListManager_003 + * @tc.name: OnCallConnectDied + * @tc.desc: MissionListManager to process OnCallConnectDied success. + */ +HWTEST_F(MissionListManagerTest, MissionListManager_003, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "MissionListManager_003 begin"; + Want want; + AppExecFwk::AbilityInfo abilityInfo; + AppExecFwk::ApplicationInfo applicationInfo; + + sptr connCallback = new (std::nothrow) MissionListManagerTestStub(); + sptr connCallback1 = new (std::nothrow) MissionListManagerTestStub(); + sptr callToken = nullptr; + AppExecFwk::ElementName element; + + std::shared_ptr missionListMgr = std::make_shared(0); + std::shared_ptr abilityRecord = + std::make_shared(want, abilityInfo, applicationInfo); + std::shared_ptr callRecord = + std::make_shared(1, abilityRecord, connCallback, callToken); + std::shared_ptr callRecord1 = + std::make_shared(2, abilityRecord, connCallback1, callToken); + std::shared_ptr missionList = std::make_shared(); + std::shared_ptr mission = std::make_shared(0, abilityRecord, ""); + std::shared_ptr callContainer = std::make_shared(); + + callContainer->AddCallRecord(connCallback1, callRecord1); + abilityRecord->callContainer_ = callContainer; + missionList->AddMissionToTop(mission); + missionListMgr->currentMissionLists_.push_front(missionList); + + auto testValue = static_cast(callContainer->callRecordMap_.size()); + EXPECT_EQ(1, testValue); + missionListMgr->OnCallConnectDied(callRecord); + + testValue = static_cast(callContainer->callRecordMap_.size()); + EXPECT_EQ(1, testValue); + GTEST_LOG_(INFO) << "MissionListManager_003 end"; +} + +/** + * @tc.number: MissionListManager_004 + * @tc.name: CallAbilityLocked + * @tc.desc: MissionListManager to process CallAbilityLocked success. + */ +HWTEST_F(MissionListManagerTest, MissionListManager_004, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "MissionListManager_004 begin"; + + AbilityRequest abilityRequest; + std::shared_ptr missionListMgr = std::make_shared(0); + + int testRet = missionListMgr->CallAbilityLocked(abilityRequest); + + EXPECT_EQ(ERR_INVALID_VALUE, testRet); + GTEST_LOG_(INFO) << "MissionListManager_004 end"; +} + +/** + * @tc.number: MissionListManager_005 + * @tc.name: CallAbilityLocked + * @tc.desc: MissionListManager to process CallAbilityLocked success. + */ +HWTEST_F(MissionListManagerTest, MissionListManager_005, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "MissionListManager_005 begin"; + + AbilityRequest abilityRequest; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.abilityInfo.bundleName = "test_bundle"; + abilityRequest.abilityInfo.name = "test_name"; + abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SINGLETON; + + Want want; + AppExecFwk::AbilityInfo abilityInfo = abilityRequest.abilityInfo; + AppExecFwk::ApplicationInfo applicationInfo; + int32_t id; + std::string missionName = "#" + abilityRequest.abilityInfo.bundleName + ":" + abilityRequest.abilityInfo.name; + + std::shared_ptr missionListMgr = std::make_shared(0); + std::shared_ptr abilityRecord = + std::make_shared(want, abilityInfo, applicationInfo); + std::shared_ptr missionList = std::make_shared(); + std::shared_ptr mission = std::make_shared(id, abilityRecord, missionName); + std::shared_ptr callContainer = std::make_shared(); + sptr connCallback = new (std::nothrow) MissionListManagerTestStub(); + std::shared_ptr callRecord = std::make_shared(0, abilityRecord, connCallback, nullptr); + + callRecord->connCallback_ = connCallback; + callRecord->callRemoteObject_ = connCallback->AsObject(); + callRecord->SetCallState(CallState::INIT); + callContainer->AddCallRecord(connCallback, callRecord); + abilityRecord->callContainer_ = callContainer; + missionList->AddMissionToTop(mission); + missionListMgr->currentMissionLists_.push_front(missionList); + + int testRet = missionListMgr->CallAbilityLocked(abilityRequest); + + EXPECT_EQ(RESOLVE_CALL_ABILITY_INNER_ERR, testRet); + GTEST_LOG_(INFO) << "MissionListManager_005 end"; +} + +/** + * @tc.number: MissionListManager_006 + * @tc.name: CallAbilityLocked + * @tc.desc: MissionListManager to process CallAbilityLocked success. + */ +HWTEST_F(MissionListManagerTest, MissionListManager_006, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "MissionListManager_006 begin"; + + sptr connCallback = new (std::nothrow) MissionListManagerTestStub(); + AbilityRequest abilityRequest; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.abilityInfo.bundleName = "test_bundle"; + abilityRequest.abilityInfo.name = "test_name"; + abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SINGLETON; + abilityRequest.connect = connCallback; + Want want; + AppExecFwk::AbilityInfo abilityInfo = abilityRequest.abilityInfo; + AppExecFwk::ApplicationInfo applicationInfo; + int32_t id; + std::string missionName = "#" + abilityRequest.abilityInfo.bundleName + ":" + abilityRequest.abilityInfo.name; + + std::shared_ptr missionListMgr = std::make_shared(0); + std::shared_ptr abilityRecord = + std::make_shared(want, abilityInfo, applicationInfo); + std::shared_ptr missionList = std::make_shared(); + std::shared_ptr mission = std::make_shared(id, abilityRecord, missionName); + std::shared_ptr callContainer = std::make_shared(); + std::shared_ptr callRecord = std::make_shared(0, abilityRecord, connCallback, nullptr); + callRecord->connCallback_ = connCallback; + callRecord->callRemoteObject_ = connCallback->AsObject(); + callRecord->SetCallState(CallState::REQUESTED); + callContainer->AddCallRecord(connCallback, callRecord); + abilityRecord->callContainer_ = callContainer; + missionList->AddMissionToTop(mission); + missionListMgr->currentMissionLists_.push_front(missionList); + + int testRet = missionListMgr->CallAbilityLocked(abilityRequest); + + EXPECT_EQ(ERR_OK, testRet); + GTEST_LOG_(INFO) << "MissionListManager_006 end"; +} + +/** + * @tc.number: MissionListManager_007 + * @tc.name: ResolveAbility + * @tc.desc: MissionListManager to process ResolveAbility success. + */ +HWTEST_F(MissionListManagerTest, MissionListManager_007, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "MissionListManager_007 begin"; + + AbilityRequest abilityRequest; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + Want want; + AppExecFwk::AbilityInfo abilityInfo; + AppExecFwk::ApplicationInfo applicationInfo; + + std::shared_ptr missionListMgr = std::make_shared(0); + std::shared_ptr abilityRecord = + std::make_shared(want, abilityInfo, applicationInfo); + + int testRet = missionListMgr->ResolveAbility(abilityRecord, abilityRequest); + + EXPECT_EQ(ResolveResultType::NG_INNER_ERROR, testRet); + GTEST_LOG_(INFO) << "MissionListManager_007 end"; +} + + +/** + * @tc.number: MissionListManager_008 + * @tc.name: GetAbilityRecordByName + * @tc.desc: MissionListManager to process GetAbilityRecordByName success. + */ +HWTEST_F(MissionListManagerTest, MissionListManager_008, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "MissionListManager_008 begin"; + + AbilityRequest abilityRequest; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + AppExecFwk::ElementName element; + + std::shared_ptr missionListMgr = std::make_shared(0); + std::shared_ptr missionList = std::make_shared(); + + missionListMgr->currentMissionLists_.push_front(missionList); + missionListMgr->launcherList_ = missionList; + missionListMgr->defaultSingleList_ = missionList; + + auto testRet = missionListMgr->GetAbilityRecordByName(element); + + EXPECT_TRUE(nullptr == testRet); + GTEST_LOG_(INFO) << "MissionListManager_008 end"; +} + +/** + * @tc.number: MissionListManager_009 + * @tc.name: GetAbilityRecordByName + * @tc.desc: MissionListManager to process GetAbilityRecordByName success. + */ +HWTEST_F(MissionListManagerTest, MissionListManager_009, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "MissionListManager_009 begin"; + + AbilityRequest abilityRequest; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + Want want; + AppExecFwk::AbilityInfo abilityInfo; + AppExecFwk::ApplicationInfo applicationInfo; + AppExecFwk::ElementName element; + + std::shared_ptr missionListMgr = std::make_shared(0); + std::shared_ptr abilityRecord = + std::make_shared(want, abilityInfo, applicationInfo); + std::shared_ptr missionList = std::make_shared(); + std::shared_ptr mission = std::make_shared(0, abilityRecord, ""); + + missionList->AddMissionToTop(mission); + missionListMgr->currentMissionLists_.push_front(missionList); + + auto testRet = missionListMgr->GetAbilityRecordByName(element); + + EXPECT_TRUE(nullptr != testRet); + GTEST_LOG_(INFO) << "MissionListManager_009 end"; +} + +/** + * @tc.number: MissionListManager_010 + * @tc.name: ResolveAbility + * @tc.desc: MissionListManager to process ResolveAbility success. + */ +HWTEST_F(MissionListManagerTest, MissionListManager_010, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "MissionListManager_010 begin"; + + sptr connCallback = new (std::nothrow) MissionListManagerTestStub(); + AbilityRequest abilityRequest; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.connect = connCallback; + Want want; + AppExecFwk::AbilityInfo abilityInfo; + AppExecFwk::ApplicationInfo applicationInfo; + + std::shared_ptr missionListMgr = std::make_shared(0); + std::shared_ptr abilityRecord = + std::make_shared(want, abilityInfo, applicationInfo); + std::shared_ptr callRecord = std::make_shared(0, abilityRecord, connCallback, nullptr); + std::shared_ptr callContainer = std::make_shared(); + + callRecord->connCallback_ = connCallback; + callRecord->callRemoteObject_ = connCallback->AsObject(); + callRecord->SetCallState(CallState::REQUESTED); + callContainer->AddCallRecord(connCallback, callRecord); + abilityRecord->callContainer_ = callContainer; + + int testRet = missionListMgr->ResolveAbility(abilityRecord, abilityRequest); + + EXPECT_EQ(ResolveResultType::OK_HAS_REMOTE_OBJ, testRet); + GTEST_LOG_(INFO) << "MissionListManager_010 end"; +} + +/** + * @tc.number: MissionListManager_011 + * @tc.name: ResolveAbility + * @tc.desc: MissionListManager to process ResolveAbility success. + */ +HWTEST_F(MissionListManagerTest, MissionListManager_011, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "MissionListManager_011 begin"; + + sptr connCallback = new (std::nothrow) MissionListManagerTestStub(); + AbilityRequest abilityRequest; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.connect = connCallback; + Want want; + AppExecFwk::AbilityInfo abilityInfo; + AppExecFwk::ApplicationInfo applicationInfo; + + std::shared_ptr missionListMgr = std::make_shared(0); + std::shared_ptr abilityRecord = + std::make_shared(want, abilityInfo, applicationInfo); + std::shared_ptr callRecord = std::make_shared(0, abilityRecord, connCallback, nullptr); + std::shared_ptr callContainer = std::make_shared(); + + callRecord->connCallback_ = connCallback; + callRecord->callRemoteObject_ = connCallback->AsObject(); + callRecord->SetCallState(CallState::INIT); + callContainer->AddCallRecord(connCallback, callRecord); + abilityRecord->callContainer_ = callContainer; + abilityRecord->isReady_ = true; + abilityRecord->scheduler_ = new (std::nothrow) MissionListManagerTestAbilityThreadStub(); + + int testRet = missionListMgr->ResolveAbility(abilityRecord, abilityRequest); + + EXPECT_EQ(ResolveResultType::OK_HAS_REMOTE_OBJ, testRet); + GTEST_LOG_(INFO) << "MissionListManager_011 end"; +} + +/** + * @tc.number: MissionListManager_012 + * @tc.name: ResolveAbility + * @tc.desc: MissionListManager to process ResolveAbility success. + */ +HWTEST_F(MissionListManagerTest, MissionListManager_012, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "MissionListManager_012 begin"; + + sptr connCallback = new (std::nothrow) MissionListManagerTestStub(); + AbilityRequest abilityRequest; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.connect = connCallback; + Want want; + AppExecFwk::AbilityInfo abilityInfo; + AppExecFwk::ApplicationInfo applicationInfo; + + std::shared_ptr missionListMgr = std::make_shared(0); + std::shared_ptr abilityRecord = + std::make_shared(want, abilityInfo, applicationInfo); + std::shared_ptr callRecord = std::make_shared(0, abilityRecord, connCallback, nullptr); + std::shared_ptr callContainer = std::make_shared(); + + callRecord->connCallback_ = connCallback; + callRecord->callRemoteObject_ = connCallback->AsObject(); + callRecord->SetCallState(CallState::INIT); + callContainer->AddCallRecord(connCallback, callRecord); + abilityRecord->callContainer_ = callContainer; + abilityRecord->isReady_ = false; + + int testRet = missionListMgr->ResolveAbility(abilityRecord, abilityRequest); + + EXPECT_EQ(ResolveResultType::OK_NO_REMOTE_OBJ, testRet); + GTEST_LOG_(INFO) << "MissionListManager_012 end"; +} + +/** + * @tc.number: MissionListManager_013 + * @tc.name: ResolveLocked + * @tc.desc: MissionListManager to process ResolveLocked success. + */ +HWTEST_F(MissionListManagerTest, MissionListManager_013, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "MissionListManager_013 begin"; + AbilityRequest abilityRequest; + abilityRequest.callType = AbilityCallType::INVALID_TYPE; + + std::shared_ptr missionListMgr = std::make_shared(0); + + int testRet = missionListMgr->ResolveLocked(abilityRequest); + + EXPECT_EQ(RESOLVE_CALL_ABILITY_INNER_ERR, testRet); + GTEST_LOG_(INFO) << "MissionListManager_013 end"; +} + + +/** + * @tc.number: MissionListManager_014 + * @tc.name: ResolveLocked + * @tc.desc: MissionListManager to process ResolveLocked success. + */ +HWTEST_F(MissionListManagerTest, MissionListManager_014, Function | MediumTest | Level1) +{ + GTEST_LOG_(INFO) << "MissionListManager_014 begin"; + + + sptr connCallback = new (std::nothrow) MissionListManagerTestStub(); + AbilityRequest abilityRequest; + abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE; + abilityRequest.abilityInfo.bundleName = "test_bundle"; + abilityRequest.abilityInfo.name = "test_name"; + abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SINGLETON; + abilityRequest.connect = connCallback; + Want want; + AppExecFwk::AbilityInfo abilityInfo = abilityRequest.abilityInfo; + AppExecFwk::ApplicationInfo applicationInfo; + int32_t id; + std::string missionName = "#" + abilityRequest.abilityInfo.bundleName + ":" + abilityRequest.abilityInfo.name; + + std::shared_ptr missionListMgr = std::make_shared(0); + std::shared_ptr abilityRecord = + std::make_shared(want, abilityInfo, applicationInfo); + std::shared_ptr missionList = std::make_shared(); + std::shared_ptr mission = std::make_shared(id, abilityRecord, missionName); + std::shared_ptr callContainer = std::make_shared(); + std::shared_ptr callRecord = std::make_shared(0, abilityRecord, connCallback, nullptr); + callRecord->connCallback_ = connCallback; + callRecord->callRemoteObject_ = connCallback->AsObject(); + callRecord->SetCallState(CallState::REQUESTED); + callContainer->AddCallRecord(connCallback, callRecord); + abilityRecord->callContainer_ = callContainer; + missionList->AddMissionToTop(mission); + missionListMgr->currentMissionLists_.push_front(missionList); + + int testRet = missionListMgr->ResolveLocked(abilityRequest); + + EXPECT_EQ(ERR_OK, testRet); + GTEST_LOG_(INFO) << "MissionListManager_014 end"; +} +} // namespace AAFwk +} // namespace OHOS \ No newline at end of file diff --git a/services/abilitymgr/test/unittest/phone/mission_list_test/BUILD.gn b/services/abilitymgr/test/unittest/phone/mission_list_test/BUILD.gn index d2f8baf9eb0c03f0c7183e40a07c03f8d7531f2d..0611c386a63ae1b3587ca102923da09750980251 100644 --- a/services/abilitymgr/test/unittest/phone/mission_list_test/BUILD.gn +++ b/services/abilitymgr/test/unittest/phone/mission_list_test/BUILD.gn @@ -14,7 +14,7 @@ import("//build/test.gni") import("//foundation/aafwk/standard/aafwk.gni") -module_output_path = "ability_runtime/abilitymgr" +module_output_path = "ability_runtime/ability_call_test" ohos_unittest("mission_list_test") { module_out_path = module_output_path @@ -63,8 +63,36 @@ ohos_unittest("mission_list_test") { ] } +ohos_unittest("mission_list_test_call") { + module_out_path = module_output_path + + sources = [ + "mission_list_test_call.cpp", # add mock file + ] + + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + deps = [ + "${innerkits_path}/want:want", + "${services_path}/abilitymgr/test:abilityms_test_source", + "${services_path}/common:perm_verification", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//foundation/aafwk/standard/frameworks/kits/ability/native:dummy_classes", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler:libeventhandler", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//third_party/googletest:gtest_main", + "//third_party/libpng:libpng", + ] + + external_deps = [ "hiviewdfx_hilog_native:libhilog" ] +} + group("unittest") { testonly = true - deps = [ ":mission_list_test" ] + deps = [ ":mission_list_test_call" ] } diff --git a/services/abilitymgr/test/unittest/phone/mission_list_test/mission_list_test_call.cpp b/services/abilitymgr/test/unittest/phone/mission_list_test/mission_list_test_call.cpp new file mode 100644 index 0000000000000000000000000000000000000000..830ac9a10287a58eaa41fc9a4ea0b71a1cb895df --- /dev/null +++ b/services/abilitymgr/test/unittest/phone/mission_list_test/mission_list_test_call.cpp @@ -0,0 +1,156 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "ability_info.h" +#include "mission.h" +#include "mission_list.h" + +using namespace testing::ext; +using namespace OHOS::AppExecFwk; + +namespace { + const std::string DEVICE_ID = "15010038475446345206a332922cb765"; + const std::string INVALID_DEVICE_ID = "88880038475446345206a332922c8888"; + const std::string BUNDLE_NAME = "testBundle"; + const std::string INVALID_BUNDLE_NAME = "invalidBundle"; + const std::string NAME = ".testMainAbility"; + const std::string INVALID_NAME = "invalid.testMainAbility"; +} + +namespace OHOS { +namespace AAFwk { +class MissionListTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void MissionListTest::SetUpTestCase(void) +{} +void MissionListTest::TearDownTestCase(void) +{} +void MissionListTest::SetUp(void) +{} +void MissionListTest::TearDown(void) +{} + +/* + * Feature: MissionList + * Function: GetAbilityRecordByName + * SubFunction: NA + * FunctionPoints: MissionList GetAbilityRecordByName + * EnvConditions: NA + * CaseDescription: Verify GetAbilityRecordByName + */ +HWTEST_F(MissionListTest, mission_list_get_ability_record_by_name_001, TestSize.Level1) +{ + AppExecFwk::AbilityInfo abilityInfo; + abilityInfo.deviceId = DEVICE_ID; + abilityInfo.bundleName = BUNDLE_NAME; + abilityInfo.name = NAME; + Want want; + AppExecFwk::ApplicationInfo applicationInfo; + std::shared_ptr abilityRecord = std::make_shared(want, abilityInfo, applicationInfo); + + auto mission = std::make_shared(0, abilityRecord, "launcher"); + auto missionList = std::make_shared(); + missionList->AddMissionToTop(mission); + + AppExecFwk::ElementName localElement(DEVICE_ID, BUNDLE_NAME, NAME); + EXPECT_EQ(abilityRecord, missionList->GetAbilityRecordByName(localElement)); +} + +/* + * Feature: MissionList + * Function: GetAbilityRecordByName + * SubFunction: NA + * FunctionPoints: MissionList GetAbilityRecordByName + * EnvConditions: NA + * CaseDescription: Verify GetAbilityRecordByName + */ +HWTEST_F(MissionListTest, mission_list_get_ability_record_by_name_002, TestSize.Level1) +{ + AppExecFwk::AbilityInfo abilityInfo; + abilityInfo.deviceId = DEVICE_ID; + abilityInfo.bundleName = BUNDLE_NAME; + abilityInfo.name = NAME; + Want want; + AppExecFwk::ApplicationInfo applicationInfo; + std::shared_ptr abilityRecord = std::make_shared(want, abilityInfo, applicationInfo); + + auto mission = std::make_shared(0, abilityRecord, "launcher"); + auto missionList = std::make_shared(); + missionList->AddMissionToTop(mission); + + AppExecFwk::ElementName localElement(INVALID_DEVICE_ID, BUNDLE_NAME, NAME); + EXPECT_EQ(nullptr, missionList->GetAbilityRecordByName(localElement)); +} + +/* + * Feature: MissionList + * Function: GetAbilityRecordByName + * SubFunction: NA + * FunctionPoints: MissionList GetAbilityRecordByName + * EnvConditions: NA + * CaseDescription: Verify GetAbilityRecordByName + */ +HWTEST_F(MissionListTest, mission_list_get_ability_record_by_name_003, TestSize.Level1) +{ + AppExecFwk::AbilityInfo abilityInfo; + abilityInfo.deviceId = DEVICE_ID; + abilityInfo.bundleName = BUNDLE_NAME; + abilityInfo.name = NAME; + Want want; + AppExecFwk::ApplicationInfo applicationInfo; + std::shared_ptr abilityRecord = std::make_shared(want, abilityInfo, applicationInfo); + + auto mission = std::make_shared(0, abilityRecord, "launcher"); + auto missionList = std::make_shared(); + missionList->AddMissionToTop(mission); + + AppExecFwk::ElementName localElement(DEVICE_ID, INVALID_BUNDLE_NAME, NAME); + EXPECT_EQ(nullptr, missionList->GetAbilityRecordByName(localElement)); +} + +/* + * Feature: MissionList + * Function: GetAbilityRecordByName + * SubFunction: NA + * FunctionPoints: MissionList GetAbilityRecordByName + * EnvConditions: NA + * CaseDescription: Verify GetAbilityRecordByName + */ +HWTEST_F(MissionListTest, mission_list_get_ability_record_by_name_004, TestSize.Level1) +{ + AppExecFwk::AbilityInfo abilityInfo; + abilityInfo.deviceId = DEVICE_ID; + abilityInfo.bundleName = BUNDLE_NAME; + abilityInfo.name = NAME; + Want want; + AppExecFwk::ApplicationInfo applicationInfo; + std::shared_ptr abilityRecord = std::make_shared(want, abilityInfo, applicationInfo); + + auto mission = std::make_shared(0, abilityRecord, "launcher"); + auto missionList = std::make_shared(); + missionList->AddMissionToTop(mission); + + AppExecFwk::ElementName localElement(DEVICE_ID, BUNDLE_NAME, INVALID_NAME); + EXPECT_EQ(nullptr, missionList->GetAbilityRecordByName(localElement)); +} +} // namespace AAFwk +} // namespace OHOS \ No newline at end of file diff --git a/services/test/BUILD.gn b/services/test/BUILD.gn index 42d989e53933455c8b7f56fea362a2b0ed63195c..d3303e4cefeff1efe460e76cd47186fe653c98a1 100644 --- a/services/test/BUILD.gn +++ b/services/test/BUILD.gn @@ -44,8 +44,10 @@ group("moduletest") { testonly = true deps = [ + "moduletest/ability_mgr_module_account_test:moduletest", "moduletest/ability_mgr_service_test:moduletest", "moduletest/ability_record_test:moduletest", + "moduletest/call_module_test:moduletest", # "moduletest/ability_stack_test:moduletest", "moduletest/common/ams:moduletest", @@ -54,7 +56,11 @@ group("moduletest") { "moduletest/ipc_ability_mgr_test:moduletest", "moduletest/ipc_ability_scheduler_test:moduletest", "moduletest/module_test_dump_util:module_test_dump_util", + "moduletest/on_new_want_module_test:moduletest", "moduletest/panding_want_manager_test:moduletest", + "moduletest/running_infos_module_test:moduletest", + "moduletest/start_option_display_id_test:moduletest", + "moduletest/static_start_ability_test:moduletest", "//third_party/jsoncpp:jsoncpp", ] } diff --git a/services/test/mock/include/mock_app_mgr_client.h b/services/test/mock/include/mock_app_mgr_client.h index c7ba6fdf679d031afd6861a0110726d3114f2a19..6277e5e76edf7c391933ac576b45c9fbe848f0fa 100644 --- a/services/test/mock/include/mock_app_mgr_client.h +++ b/services/test/mock/include/mock_app_mgr_client.h @@ -34,6 +34,9 @@ public: MOCK_METHOD1(KillProcessesByUserId, AppMgrResultCode(int32_t userId)); MOCK_METHOD4(CompelVerifyPermission, int(const std::string &permission, int pid, int uid, std::string &message)); MOCK_METHOD1(AbilityAttachTimeOut, void(const sptr &token)); + MOCK_METHOD2(GetRunningProcessInfoByToken, void((const sptr &token, + AppExecFwk::RunningProcessInfo &info))); + MOCK_METHOD1(GetAllRunningProcesses, AppMgrResultCode(std::vector &info)); AppMgrResultCode AbilityBehaviorAnalysis(const sptr &token, const sptr &preToken, const int32_t visibility, const int32_t perceptibility, const int32_t connectionState) override; diff --git a/services/test/mock/include/mock_bundle_mgr.h b/services/test/mock/include/mock_bundle_mgr.h index 7d6a92b32791d90bce78916e273d087a64367519..e7c8ffea07fdf2463beefcad5a56ea8f16419481 100644 --- a/services/test/mock/include/mock_bundle_mgr.h +++ b/services/test/mock/include/mock_bundle_mgr.h @@ -37,8 +37,16 @@ const std::string COM_IX_HIDATA = "com.ix.hiData"; const std::string COM_IX_PHONE = "com.ix.hiPhone"; const std::string COM_IX_TV = "com.ix.hiTV"; const std::string COM_IX_Film = "com.ix.hiFilm"; +const std::string COM_IX_HIBACKGROUNDMUSIC = "com.ix.hiBackgroundMusic"; +const std::string COM_IX_HIBACKGROUNDDATA = "com.ix.hiBackgroundData"; +const std::string COM_IX_HISINGLEMUSIC = "com.ix.hiSingleMusicInfo"; +const std::string COM_OHOS_Test = "com.ohos.test"; +const std::string COM_IX_HIACCOUNT = "com.ix.hiAccount"; +const std::string COM_IX_HIACCOUNTSERVICE = "com.ix.hiAccountService"; constexpr int32_t MAX_SYS_UID = 2899; constexpr int32_t ROOT_UID = 0; +const int32_t BASE_USER_RANGE = 200000; +const int32_t MOCK_MAIN_UID = 20000000; auto HiWordInfo = [](std::string bundleName, AbilityInfo &abilityInfo, ElementName &elementTemp) { abilityInfo.name = elementTemp.GetAbilityName(); @@ -191,6 +199,102 @@ auto HiFilmInfo = [](std::string bundleName, AbilityInfo &abilityInfo, ElementNa } return true; }; +auto HiBAckgroundMusicInfo = [](std::string bundleName, AbilityInfo &abilityInfo, ElementName &elementTemp) { + abilityInfo.name = elementTemp.GetAbilityName(); + abilityInfo.bundleName = elementTemp.GetBundleName(); + abilityInfo.applicationInfo.bundleName = elementTemp.GetBundleName(); + abilityInfo.applicationInfo.singleUser = true; + abilityInfo.applicationName = "hiBackgroundMusic"; + abilityInfo.applicationInfo.name = "hiBackgroundMusic"; + abilityInfo.type = AbilityType::SERVICE; + abilityInfo.process = "p4"; + return true; +}; + +auto HiBAckgroundDataInfo = [](std::string bundleName, AbilityInfo &abilityInfo, ElementName &elementTemp) { + abilityInfo.name = elementTemp.GetAbilityName(); + abilityInfo.bundleName = elementTemp.GetBundleName(); + abilityInfo.applicationInfo.bundleName = elementTemp.GetBundleName(); + abilityInfo.applicationInfo.singleUser = true; + abilityInfo.applicationName = "hiBackgroundData"; + abilityInfo.applicationInfo.name = "hiBackgroundData"; + abilityInfo.type = AbilityType::SERVICE; + abilityInfo.process = "p4"; + return true; +}; + +auto HiSingleMusicInfo = [](std::string bundleName, AbilityInfo &abilityInfo, ElementName &elementTemp) { + abilityInfo.name = elementTemp.GetAbilityName(); + abilityInfo.bundleName = elementTemp.GetBundleName(); + abilityInfo.applicationInfo.bundleName = elementTemp.GetBundleName(); + abilityInfo.applicationInfo.singleUser = true; + abilityInfo.applicationName = "hiSingleMusic"; + abilityInfo.applicationInfo.name = "hiSingleMusic"; + abilityInfo.type = AbilityType::PAGE; + abilityInfo.process = "p3"; + if (elementTemp.GetAbilityName() == "SingleMusicAbility") { + abilityInfo.launchMode = LaunchMode::STANDARD; + } + if (elementTemp.GetAbilityName() == "SingleMusicTopAbility") { + abilityInfo.launchMode = LaunchMode::SINGLETON; + } + return true; +}; + +auto TestInfo = [](std::string bundleName, AbilityInfo &abilityInfo, ElementName &elementTemp) { + abilityInfo.name = elementTemp.GetAbilityName(); + abilityInfo.bundleName = elementTemp.GetBundleName(); + abilityInfo.applicationInfo.bundleName = elementTemp.GetBundleName(); + abilityInfo.applicationName = "com.ohos.test"; + abilityInfo.applicationInfo.name = "com.ohos.test"; + abilityInfo.moduleName = ".MyApplication"; + abilityInfo.package = "com.ohos.test"; + abilityInfo.type = AbilityType::PAGE; + abilityInfo.applicationInfo.isLauncherApp = false; + abilityInfo.kind = "page"; + abilityInfo.process = "p10"; + abilityInfo.labelId = 10001; + abilityInfo.label = "$string:label"; + abilityInfo.descriptionId = 10002; + abilityInfo.description = "$string:mainability_description"; + abilityInfo.iconId = 10003; + abilityInfo.iconPath = "$media:icon"; + abilityInfo.theme = "mytheme"; + abilityInfo.readPermission = "readPermission"; + abilityInfo.writePermission = "writePermission"; + abilityInfo.resourcePath = "/data/app/com.ohos.test"; + abilityInfo.srcPath = "/resources/base/profile"; + abilityInfo.srcLanguage = "C++"; + abilityInfo.isLauncherAbility = false; + abilityInfo.isNativeAbility = false; + abilityInfo.enabled = false; + abilityInfo.supportPipMode = false; + abilityInfo.formEnabled = false; + return true; +}; +auto HiAccountInfo = [](std::string bundleName, AbilityInfo &abilityInfo, ElementName &elementTemp) { + abilityInfo.name = elementTemp.GetAbilityName(); + abilityInfo.bundleName = elementTemp.GetBundleName(); + abilityInfo.applicationInfo.bundleName = elementTemp.GetBundleName(); + abilityInfo.applicationInfo.uid = MOCK_MAIN_UID; + abilityInfo.applicationName = "AccountTest"; + abilityInfo.applicationInfo.name = "AccountTest"; + abilityInfo.type = AbilityType::PAGE; + abilityInfo.applicationInfo.isLauncherApp = true; + return true; +}; + +auto HiAccountServiceInfo = [](std::string bundleName, AbilityInfo &abilityInfo, ElementName &elementTemp) { + abilityInfo.name = elementTemp.GetAbilityName(); + abilityInfo.bundleName = elementTemp.GetBundleName(); + abilityInfo.applicationInfo.bundleName = elementTemp.GetBundleName(); + abilityInfo.applicationInfo.uid = MOCK_MAIN_UID; + abilityInfo.applicationName = "AccountServiceTest"; + abilityInfo.applicationInfo.name = "AccountServiceTest"; + abilityInfo.type = AbilityType::SERVICE; + abilityInfo.applicationInfo.isLauncherApp = true; + return true; +}; } // namespace class BundleMgrProxy : public IRemoteProxy { public: @@ -270,7 +374,6 @@ public: MOCK_METHOD2(QueryWantAbility, int(const AAFwk::Want &want, std::vector &abilityInfos)); MOCK_METHOD3(GetApplicationInfos, bool(const ApplicationFlag flag, const int userId, std::vector &appInfos)); - MOCK_METHOD3(GetBundleInfos, bool(const BundleFlag flag, std::vector &bundleInfos, int32_t userId)); MOCK_METHOD2(GetBundleNameForUid, bool(const int uid, std::string &bundleName)); MOCK_METHOD2(GetBundleGids, bool(const std::string &bundleName, std::vector &gids)); MOCK_METHOD1(GetAppType, std::string(const std::string &bundleName)); @@ -372,6 +475,13 @@ public: { return true; } + virtual bool GetBundleInfos( + const BundleFlag flag, + std::vector &bundleInfos, + int32_t userId = Constants::UNSPECIFIED_USERID) + { + return false; + } BundleMgrService() { abilityInfoMap_.emplace(COM_IX_HIWORLD, HiWordInfo); @@ -383,6 +493,12 @@ public: abilityInfoMap_.emplace(COM_IX_PHONE, HiPhoneInfo); abilityInfoMap_.emplace(COM_IX_TV, HiTVInfo); abilityInfoMap_.emplace(COM_IX_Film, HiFilmInfo); + abilityInfoMap_.emplace(COM_IX_HIBACKGROUNDMUSIC, HiBAckgroundMusicInfo); + abilityInfoMap_.emplace(COM_IX_HIBACKGROUNDDATA, HiBAckgroundDataInfo); + abilityInfoMap_.emplace(COM_IX_HISINGLEMUSIC, HiSingleMusicInfo); + abilityInfoMap_.emplace(COM_OHOS_Test, TestInfo); + abilityInfoMap_.emplace(COM_IX_HIACCOUNT, HiAccountInfo); + abilityInfoMap_.emplace(COM_IX_HIACCOUNTSERVICE, HiAccountServiceInfo); } virtual ~BundleMgrService() diff --git a/services/test/mock/src/mock_bundle_mgr.cpp b/services/test/mock/src/mock_bundle_mgr.cpp index 390ba3a2a7162e4a321cfa32128c8e99738d1e5d..419d6ef5756fbfa19b608edb8abfe218b585849e 100644 --- a/services/test/mock/src/mock_bundle_mgr.cpp +++ b/services/test/mock/src/mock_bundle_mgr.cpp @@ -22,6 +22,9 @@ using namespace OHOS::AAFwk; namespace OHOS { namespace AppExecFwk { +namespace { +const int32_t ERROR_USER_ID_U256 = 256; +} int BundleMgrProxy::QueryWantAbility( const AAFwk::Want &__attribute__((unused)) want, std::vector &__attribute__((unused)) abilityInfos) @@ -82,7 +85,12 @@ bool BundleMgrService::GetBundleInfo( bool BundleMgrService::QueryAbilityInfo(const AAFwk::Want &want, int32_t flags, int32_t userId, AbilityInfo &abilityInfo) { - return QueryAbilityInfo(want, abilityInfo); + auto flag = QueryAbilityInfo(want, abilityInfo); + if (userId == ERROR_USER_ID_U256) { + abilityInfo.applicationInfo.singleUser = false; + } + return flag; + } bool BundleMgrService::QueryAbilityInfo(const AAFwk::Want &want, AbilityInfo &abilityInfo) @@ -109,9 +117,15 @@ bool BundleMgrService::QueryAbilityInfo(const AAFwk::Want &want, AbilityInfo &ab return true; } } - if (std::string::npos != elementTemp.GetBundleName().find("service")) { + if (std::string::npos != elementTemp.GetBundleName().find("Service")) { abilityInfo.type = AppExecFwk::AbilityType::SERVICE; } + if (std::string::npos != elementTemp.GetBundleName().find("Data")) { + abilityInfo.type = AppExecFwk::AbilityType::DATA; + } + if (std::string::npos != elementTemp.GetBundleName().find("Extension")) { + abilityInfo.type = AppExecFwk::AbilityType::EXTENSION; + } abilityInfo.name = elementTemp.GetAbilityName(); abilityInfo.bundleName = elementTemp.GetBundleName(); abilityInfo.applicationName = elementTemp.GetBundleName(); @@ -131,8 +145,9 @@ bool BundleMgrService::QueryAbilityInfo(const AAFwk::Want &want, AbilityInfo &ab bool BundleMgrService::GetApplicationInfo( const std::string &appName, const ApplicationFlag flag, const int userId, ApplicationInfo &appInfo) { - appInfo.name = "test_app"; - appInfo.bundleName = "com.ix.hiMusic"; + appInfo.name = appName; + appInfo.bundleName = appName; + appInfo.uid = userId * BASE_USER_RANGE; return true; } diff --git a/services/test/moduletest/ability_mgr_module_account_test/BUILD.gn b/services/test/moduletest/ability_mgr_module_account_test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..728c5234a0c691c6d638c32671cc00cc0b5b2bd7 --- /dev/null +++ b/services/test/moduletest/ability_mgr_module_account_test/BUILD.gn @@ -0,0 +1,131 @@ +# Copyright (c) 2021-2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/aafwk/standard/aafwk.gni") + +module_output_path = "ability_runtime/mstabilitymgrservice" + +ohos_moduletest("ability_mgr_module_account_test") { + module_out_path = module_output_path + + include_dirs = [ + "${services_path}/test/mock/include", + "//third_party/jsoncpp/include", + "//foundation/aafwk/standard/frameworks/kits/ability/native/include/distributed_ability_runtime", + "//foundation/aafwk/standard/interfaces/innerkits/dataobs_manager/include", + "//base/hiviewdfx/hicollie/interfaces/native/innerkits/include/xcollie", + ] + + sources = [ "ability_mgr_module_account_test.cpp" ] + sources += [ + "//foundation/aafwk/standard/services/abilitymgr/src/ability_connect_callback_stub.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_connect_manager.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_event_handler.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_manager_proxy.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_manager_service.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_manager_stub.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_mission_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_record.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_record_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_scheduler_proxy.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_scheduler_stub.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_stack_manager.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_token_stub.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/call_container.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/call_record.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/caller_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/connection_record.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/data_ability_manager.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/data_ability_record.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/launch_param.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/lifecycle_deal.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/lifecycle_state_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_description_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_option.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_record.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_record_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_snapshot.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_stack.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_stack_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/pending_want_key.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/pending_want_manager.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/pending_want_record.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/power_storage.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/sender_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/stack_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/want_receiver_stub.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/want_sender_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/want_sender_stub.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/wants_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/test/mock/libs/sa_mgr/src/sa_mgr_client_mock.cpp", + "//foundation/aafwk/standard/services/test/mock/src/mock_app_mgr_client.cpp", + "//foundation/aafwk/standard/services/test/mock/src/mock_bundle_mgr.cpp", + ] + + configs = [ + "${services_path}/test:aafwk_module_test_config", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager_public_config", + "//foundation/aafwk/standard/services/abilitymgr/test/mock/libs/sa_mgr:sa_mgr_mock_config", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base_sdk_config", + "${aafwk_path}/interfaces/innerkits/app_manager:appmgr_sdk_config", + ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + deps = [ + "${aafwk_path}/interfaces/innerkits/app_manager:app_manager", + "${innerkits_path}/uri_permission:uri_permission_mgr", + "${innerkits_path}/want:want", + "${services_path}/common:perm_verification", + "//base/account/os_account/frameworks/osaccount/native:os_account_innerkits", + "//base/global/i18n_standard/frameworks/intl:intl_util", + "//base/startup/syspara_lite/interfaces/innerkits/native/syspara:syspara", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//foundation/aafwk/standard/frameworks/kits/ability/native:dummy_classes", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", + "//foundation/ace/ace_engine/interfaces/innerkits/ui_service_manager:ui_service_mgr", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_core:appexecfwk_core", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler:libeventhandler", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//foundation/distributedschedule/safwk/interfaces/innerkits/safwk:system_ability_fwk", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy:samgr_proxy", + "//foundation/multimedia/image_standard/interfaces/innerkits:image_native", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//third_party/jsoncpp:jsoncpp", + "//third_party/libpng:libpng", + "//utils/native/base:utils", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "bytrace_standard:bytrace_core", + "ces_standard:cesfwk_core", + "ces_standard:cesfwk_innerkits", + "dsoftbus_standard:softbus_client", + "hicollie_native:libhicollie", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "native_appdatamgr:native_appdatafwk", + "native_appdatamgr:native_dataability", + "native_appdatamgr:native_rdb", + ] +} + +group("moduletest") { + testonly = true + deps = [ ":ability_mgr_module_account_test" ] +} diff --git a/services/test/moduletest/ability_mgr_module_account_test/ability_mgr_module_account_test.cpp b/services/test/moduletest/ability_mgr_module_account_test/ability_mgr_module_account_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..acc398dc693ddc1bd148a307a2fc184014704497 --- /dev/null +++ b/services/test/moduletest/ability_mgr_module_account_test/ability_mgr_module_account_test.cpp @@ -0,0 +1,878 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +#include +#include + +#define private public +#define protected public +#include "sa_mgr_client.h" +#include "mock_ability_connect_callback_stub.h" +#include "mock_ability_scheduler.h" +#include "mock_app_mgr_client.h" +#include "mock_bundle_mgr.h" +#include "ability_record_info.h" +#include "ability_manager_errors.h" +#include "sa_mgr_client.h" +#include "system_ability_definition.h" +#include "ability_manager_service.h" +#include "ability_connect_callback_proxy.h" +#include "ability_config.h" +#include "pending_want_manager.h" +#include "pending_want_record.h" +#undef private +#undef protected +#include "wants_info.h" +#include "want_receiver_stub.h" +#include "want_sender_stub.h" +#include "os_account_manager.h" + +using namespace std::placeholders; +using namespace testing::ext; +using namespace OHOS::AppExecFwk; +using OHOS::iface_cast; +using OHOS::IRemoteObject; +using OHOS::sptr; +using testing::_; +using testing::Invoke; +using testing::Return; + +namespace OHOS { +namespace AAFwk { +namespace { +const int32_t MOCK_MAIN_USER_ID = 100; +const int32_t ERROR_USER_ID_U256 = 256; +} // namespace +class AbilityMgrModuleAccountTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + void WaitAMS(); + bool MockAppClent(); + Want CreateWant(const std::string &abilityName, const std::string &bundleName); + AbilityInfo CreateAbilityInfo(const std::string &name, const std::string &appName, const std::string &bundleName); + void CreateAbilityRequest(const std::string &abilityName, const std::string bundleName, Want &want, + std::shared_ptr &curMissionStack, sptr &recordToken); + void MockServiceAbilityLoadHandlerInner(bool &testResult, const std::string &bundleName, + const std::string &abilityName, sptr &testToken); + ApplicationInfo CreateAppInfo(const std::string &appName, const std::string &name); + inline static std::shared_ptr abilityMgrServ_ {nullptr}; + inline static std::shared_ptr mockAppMgrClient_ {nullptr}; + sptr scheduler_ {nullptr}; + inline static bool doOnce_ = false; +}; + +bool AbilityMgrModuleAccountTest::MockAppClent() +{ + if (!mockAppMgrClient_) { + GTEST_LOG_(INFO) << "MockAppClent::1"; + return false; + } + + if (!abilityMgrServ_->appScheduler_) { + GTEST_LOG_(INFO) << "MockAppClent::2"; + return false; + } + + abilityMgrServ_->appScheduler_->appMgrClient_.reset(mockAppMgrClient_.get()); + return true; +} + +Want AbilityMgrModuleAccountTest::CreateWant(const std::string &abilityName, const std::string &bundleName) +{ + ElementName element; + element.SetDeviceID(""); + element.SetAbilityName(abilityName); + element.SetBundleName(bundleName); + Want want; + want.SetElement(element); + return want; +} + +AbilityInfo AbilityMgrModuleAccountTest::CreateAbilityInfo( + const std::string &name, const std::string &appName, const std::string &bundleName) +{ + AbilityInfo abilityInfo; + abilityInfo.visible = true; + abilityInfo.name = name; + abilityInfo.applicationName = appName; + abilityInfo.bundleName = bundleName; + abilityInfo.applicationInfo.bundleName = bundleName; + abilityInfo.applicationInfo.name = name; + abilityInfo.type = AbilityType::PAGE; + abilityInfo.applicationInfo.isLauncherApp = false; + + return abilityInfo; +} + +ApplicationInfo AbilityMgrModuleAccountTest::CreateAppInfo(const std::string &appName, const std::string &bundleName) +{ + ApplicationInfo appInfo; + appInfo.name = appName; + appInfo.bundleName = bundleName; + + return appInfo; +} + +void AbilityMgrModuleAccountTest::CreateAbilityRequest(const std::string &abilityName, const std::string bundleName, + Want &want, std::shared_ptr &curMissionStack, sptr &recordToken) +{ + Want want2 = CreateWant(abilityName, bundleName); + AbilityRequest abilityRequest2; + abilityRequest2.want = want2; + abilityRequest2.abilityInfo.type = OHOS::AppExecFwk::AbilityType::PAGE; + abilityRequest2.abilityInfo = CreateAbilityInfo(abilityName, bundleName, bundleName); + + std::shared_ptr abilityRecord2 = AbilityRecord::CreateAbilityRecord(abilityRequest2); + abilityRecord2->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE); + std::shared_ptr mission = std::make_shared(bundleName); + mission->AddAbilityRecordToTop(abilityRecord2); + auto stackManager_ = abilityMgrServ_->GetStackManager(); + curMissionStack = stackManager_->GetCurrentMissionStack(); + curMissionStack->AddMissionRecordToTop(mission); + recordToken = abilityRecord2->GetToken(); + + want = CreateWant(abilityName, bundleName); + AbilityRequest abilityRequest; + abilityRequest.want = want; + abilityRequest.abilityInfo = + CreateAbilityInfo(abilityName, bundleName, bundleName); + abilityRequest.abilityInfo.type = OHOS::AppExecFwk::AbilityType::SERVICE; + abilityRequest.appInfo = CreateAppInfo(bundleName, bundleName); + abilityMgrServ_->RemoveAllServiceRecord(); +} + +void AbilityMgrModuleAccountTest::MockServiceAbilityLoadHandlerInner( + bool &testResult, const std::string &bundleName, const std::string &abilityName, sptr &testToken) +{ + auto mockHandler = [&testResult, &bundleName, &abilityName, &testToken](const sptr &token, + const sptr &preToken, + const AbilityInfo &abilityInfo, + const ApplicationInfo &appInfo, + const Want &want) { + testToken = token; + testResult = !!testToken && abilityInfo.bundleName == bundleName && abilityInfo.name == abilityName && + appInfo.bundleName == bundleName; + return AppMgrResultCode::RESULT_OK; + }; + + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(1).WillOnce(Invoke(mockHandler)); +} + +void AbilityMgrModuleAccountTest::WaitAMS() +{ + const uint32_t maxRetryCount = 1000; + const uint32_t sleepTime = 1000; + uint32_t count = 0; + if (!abilityMgrServ_) { + return; + } + auto handler = abilityMgrServ_->GetEventHandler(); + if (!handler) { + return; + } + std::atomic taskCalled(false); + auto f = [&taskCalled]() { taskCalled.store(true); }; + if (handler->PostTask(f)) { + while (!taskCalled.load()) { + ++count; + if (count >= maxRetryCount) { + break; + } + usleep(sleepTime); + } + } +} + +void AbilityMgrModuleAccountTest::SetUpTestCase() +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest SetUpTestCase called"; + OHOS::DelayedSingleton::GetInstance()->RegisterSystemAbility( + OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new BundleMgrService()); + abilityMgrServ_ = OHOS::DelayedSingleton::GetInstance(); + mockAppMgrClient_ = std::make_shared(); + abilityMgrServ_->OnStart(); + abilityMgrServ_->StartUser(MOCK_MAIN_USER_ID); +} + +void AbilityMgrModuleAccountTest::TearDownTestCase() +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest TearDownTestCase called"; + abilityMgrServ_->OnStop(); + mockAppMgrClient_.reset(); + OHOS::DelayedSingleton::DestroyInstance(); +} + +void AbilityMgrModuleAccountTest::SetUp() +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest SetUp called"; + scheduler_ = new MockAbilityScheduler(); + if (!doOnce_) { + doOnce_ = true; + MockAppClent(); + } + WaitAMS(); +} + +void AbilityMgrModuleAccountTest::TearDown() +{} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_StartAbilityInner_001 + * SubFunction: NA + * FunctionPoints: Start single PageAbility with 0 user authentication StartAbilityInner interface + * EnvConditions: NA + * CaseDescription: terminate ability. + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_StartAbilityInner_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbilityInner_001 start"; + Want want; + ElementName element("", "com.ix.hiSingleMusicInfo", "SingleMusicAbility"); + want.SetElement(element); + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(1).WillOnce(Return(AppMgrResultCode::RESULT_OK)); + auto result = abilityMgrServ_->StartAbilityInner(want, nullptr, -1); + WaitAMS(); + EXPECT_EQ(OHOS::ERR_OK, result); + + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbilityInner_001 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_StartAbilityInner_002 + * SubFunction: NA + * FunctionPoints: Start single ServiceAbility with 0 user authentication StartAbilityInner interface + * EnvConditions: NA + * CaseDescription: terminate ability. + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_StartAbilityInner_002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbilityInner_002 start"; + Want want; + ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic"); + want.SetElement(element); + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(1).WillOnce(Return(AppMgrResultCode::RESULT_OK)); + auto result = abilityMgrServ_->StartAbilityInner(want, nullptr, -1); + WaitAMS(); + EXPECT_EQ(OHOS::ERR_OK, result); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbilityInner_002 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_StartAbilityInner_003 + * SubFunction: NA + * FunctionPoints: Start single PageAbility with 100 user authentication StartAbilityInner interface + * EnvConditions: NA + * CaseDescription: terminate ability. + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_StartAbilityInner_003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbilityInner_003 start"; + Want want; + ElementName element("", "com.ix.hiSingleMusicInfo", "SingleMusicAbility"); + want.SetElement(element); + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(1).WillOnce(Return(AppMgrResultCode::RESULT_OK)); + auto result = abilityMgrServ_->StartAbilityInner(want, nullptr, -1, -1, MOCK_MAIN_USER_ID); + WaitAMS(); + EXPECT_EQ(OHOS::ERR_OK, result); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbilityInner_003 start"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_StartAbilityInner_004 + * SubFunction: NA + * FunctionPoints: Start single ServiceAbility with 100 user authentication StartAbilityInner interface + * EnvConditions: NA + * CaseDescription: terminate ability. + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_StartAbilityInner_004, TestSize.Level1) +{ + Want want; + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbilityInner_004 start"; + ElementName element("", "com.ix.hiBackgroundData", "hiBackgroundData"); + want.SetElement(element); + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(1).WillOnce(Return(AppMgrResultCode::RESULT_OK)); + auto result = abilityMgrServ_->StartAbilityInner(want, nullptr, -1, -1, MOCK_MAIN_USER_ID); + WaitAMS(); + EXPECT_EQ(OHOS::ERR_OK, result); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbilityInner_004 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_StartAbilityInner_005 + * SubFunction: NA + * FunctionPoints: AbilityManagerService StartAbilityInner + * EnvConditions: NA + * CaseDescription: Start single PageAbility with error user authentication StartAbilityInner interface + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_StartAbilityInner_005, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbilityInner_005 start"; + Want want; + ElementName element("", "com.ix.hiSingleMusicInfo", "SingleMusicAbility"); + want.SetElement(element); + auto result = abilityMgrServ_->StartAbilityInner(want, nullptr, -1, -1, ERROR_USER_ID_U256); + WaitAMS(); + EXPECT_NE(OHOS::ERR_OK, result); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbilityInner_005 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_StartAbilityInner_006 + * SubFunction: NA + * FunctionPoints: AbilityManagerService StartAbilityInner + * EnvConditions: NA + * CaseDescription: Start single ServiceAbility with error user authentication StartAbilityInner interface + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_StartAbilityInner_006, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbilityInner_006 start"; + Want want; + ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic"); + want.SetElement(element); + auto result = abilityMgrServ_->StartAbilityInner(want, nullptr, -1, -1, ERROR_USER_ID_U256); + WaitAMS(); + EXPECT_NE(OHOS::ERR_OK, result); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbilityInner_006 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_StartAbility_001 + * SubFunction: NA + * FunctionPoints: AbilityManagerService StartAbility + * EnvConditions: NA + * CaseDescription: Start single PageAbility with 0 user authentication StartAbility interface + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_StartAbility_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbility_001 start"; + Want want; + ElementName element("", "com.ix.hiSingleMusicInfo", "SingleMusicAbility"); + want.SetElement(element); + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(1).WillOnce(Return(AppMgrResultCode::RESULT_OK)); + StartOptions abilityStartOptions; + auto result = abilityMgrServ_->StartAbility(want, abilityStartOptions, nullptr, 0, -1); + WaitAMS(); + EXPECT_EQ(OHOS::ERR_OK, result); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbility_001 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_StartAbility_002 + * SubFunction: NA + * FunctionPoints: AbilityManagerService StartAbility + * EnvConditions: NA + * CaseDescription: Start single ServiceAbility with 0 user authentication StartAbility interface + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_StartAbility_002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbility_002 start"; + Want want; + ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic"); + want.SetElement(element); + StartOptions abilityStartOptions; + auto result = abilityMgrServ_->StartAbility(want, abilityStartOptions, nullptr, 0, -1); + WaitAMS(); + EXPECT_NE(OHOS::ERR_OK, result); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbility_002 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_StartAbility_003 + * SubFunction: NA + * FunctionPoints: AbilityManagerService StartAbility + * EnvConditions: NA + * CaseDescription: Start single PageAbility with 100 user authentication StartAbility interface + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_StartAbility_003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbility_003 start"; + Want want; + ElementName element("", "com.ix.hiSingleMusicInfo", "SingleMusicAbility"); + want.SetElement(element); + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(1).WillOnce(Return(AppMgrResultCode::RESULT_OK)); + StartOptions abilityStartOptions; + auto result = abilityMgrServ_->StartAbility(want, abilityStartOptions, nullptr, MOCK_MAIN_USER_ID, -1); + WaitAMS(); + EXPECT_EQ(OHOS::ERR_OK, result); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbility_003 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_StartAbility_004 + * SubFunction: NA + * FunctionPoints: AbilityManagerService StartAbility + * EnvConditions: NA + * CaseDescription: Start single ServiceAbility with 100 user authentication StartAbility interface + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_StartAbility_004, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbility_004 start"; + Want want; + ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic"); + want.SetElement(element); + StartOptions abilityStartOptions; + auto result = abilityMgrServ_->StartAbility(want, abilityStartOptions, nullptr, MOCK_MAIN_USER_ID, -1); + WaitAMS(); + EXPECT_NE(OHOS::ERR_OK, result); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbility_004 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_StartAbility_005 + * SubFunction: NA + * FunctionPoints: AbilityManagerService StartAbility + * EnvConditions: NA + * CaseDescription: Start single PageAbility with error user authentication StartAbility interface + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_StartAbility_005, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbility_005 start"; + Want want; + ElementName element("", "com.ix.hiSingleMusicInfo", "SingleMusicAbility"); + want.SetElement(element); + StartOptions abilityStartOptions; + auto result = abilityMgrServ_->StartAbility(want, abilityStartOptions, nullptr, ERROR_USER_ID_U256, -1); + WaitAMS(); + EXPECT_NE(OHOS::ERR_OK, result); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbility_005 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_StartAbility_006 + * SubFunction: NA + * FunctionPoints: AbilityManagerService StartAbility + * EnvConditions: NA + * CaseDescription: Start single ServiceAbility with error user authentication StartAbility interface + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_StartAbility_006, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbility_006 start"; + Want want; + ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic"); + want.SetElement(element); + StartOptions abilityStartOptions; + auto result = abilityMgrServ_->StartAbility(want, abilityStartOptions, nullptr, ERROR_USER_ID_U256, -1); + WaitAMS(); + EXPECT_NE(OHOS::ERR_OK, result); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbility_006 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_StartAbility_007 + * SubFunction: NA + * FunctionPoints: AbilityManagerService StartAbility + * EnvConditions: NA + * CaseDescription: Specify a user to start a page ability + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_StartAbility_007, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbility_007 start"; + auto topAbility = abilityMgrServ_->GetListManagerByUserId(MOCK_MAIN_USER_ID)->GetCurrentTopAbilityLocked(); + if (topAbility) { + topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND_NEW); + } + Want want; + ElementName element("", "com.ix.hiAccount", "AccountTest"); + want.SetElement(element); + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(1).WillOnce(Return(AppMgrResultCode::RESULT_OK)); + int result = abilityMgrServ_->StartAbility(want, MOCK_MAIN_USER_ID, -1); + EXPECT_EQ(ERR_OK, result); + + topAbility = abilityMgrServ_->GetListManagerByUserId(MOCK_MAIN_USER_ID)->GetCurrentTopAbilityLocked(); + sptr token = nullptr; + if (topAbility) { + token = topAbility->GetToken(); + } + sptr scheduler = new MockAbilityScheduler(); + EXPECT_TRUE(scheduler); + EXPECT_CALL(*mockAppMgrClient_, UpdateAbilityState(_, _)).Times(1); + auto resultFunction = abilityMgrServ_->AttachAbilityThread(scheduler, token); + EXPECT_EQ(resultFunction, ERR_OK); + + topAbility = abilityMgrServ_->GetListManagerByUserId(MOCK_MAIN_USER_ID)->GetCurrentTopAbilityLocked(); + EXPECT_CALL(*scheduler, ScheduleAbilityTransaction(_, _)).Times(1); + abilityMgrServ_->OnAbilityRequestDone( + topAbility->GetToken(), (int32_t)OHOS::AppExecFwk::AbilityState::ABILITY_STATE_FOREGROUND); + EXPECT_EQ(OHOS::AAFwk::AbilityState::FOREGROUNDING_NEW, topAbility->GetAbilityState()); + + AppInfo appInfo; + appInfo.processName = topAbility->GetAbilityInfo().process; + appInfo.state = AppState::FOREGROUND; + abilityMgrServ_->OnAppStateChanged(appInfo); + PacMap saveData; + abilityMgrServ_->AbilityTransitionDone(topAbility->GetToken(), + AbilityLifeCycleState::ABILITY_STATE_FOREGROUND_NEW, saveData); + + WaitAMS(); + EXPECT_EQ(OHOS::AAFwk::AbilityState::FOREGROUND_NEW, topAbility->GetAbilityState()); + testing::Mock::AllowLeak(scheduler); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbility_007 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_StartAbility_006 + * SubFunction: NA + * FunctionPoints: AbilityManagerService StartAbility + * EnvConditions: NA + * CaseDescription: Do not specify a user to start a page ability + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_StartAbility_008, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbility_008 start"; + auto topAbility = abilityMgrServ_->GetListManagerByUserId(MOCK_MAIN_USER_ID)->GetCurrentTopAbilityLocked(); + if (topAbility) { + topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND_NEW); + } + Want want; + ElementName element("", "com.ix.hiAccount", "AccountTest"); + want.SetElement(element); + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(1).WillOnce(Return(AppMgrResultCode::RESULT_OK)); + int result = abilityMgrServ_->StartAbility(want); + EXPECT_EQ(ERR_OK, result); + + topAbility = abilityMgrServ_->GetListManagerByUserId(MOCK_MAIN_USER_ID)->GetCurrentTopAbilityLocked(); + sptr token = nullptr; + if (topAbility) { + token = topAbility->GetToken(); + } + sptr scheduler = new MockAbilityScheduler(); + EXPECT_TRUE(scheduler); + EXPECT_CALL(*mockAppMgrClient_, UpdateAbilityState(_, _)).Times(1); + auto resultFunction = abilityMgrServ_->AttachAbilityThread(scheduler, token); + EXPECT_EQ(resultFunction, ERR_OK); + + topAbility = abilityMgrServ_->GetListManagerByUserId(MOCK_MAIN_USER_ID)->GetCurrentTopAbilityLocked(); + EXPECT_CALL(*scheduler, ScheduleAbilityTransaction(_, _)).Times(1); + abilityMgrServ_->OnAbilityRequestDone( + topAbility->GetToken(), (int32_t)OHOS::AppExecFwk::AbilityState::ABILITY_STATE_FOREGROUND); + EXPECT_EQ(OHOS::AAFwk::AbilityState::FOREGROUNDING_NEW, topAbility->GetAbilityState()); + + AppInfo appInfo; + appInfo.processName = topAbility->GetAbilityInfo().process; + appInfo.state = AppState::FOREGROUND; + abilityMgrServ_->OnAppStateChanged(appInfo); + PacMap saveData; + abilityMgrServ_->AbilityTransitionDone(topAbility->GetToken(), + AbilityLifeCycleState::ABILITY_STATE_FOREGROUND_NEW, saveData); + + WaitAMS(); + EXPECT_EQ(OHOS::AAFwk::AbilityState::FOREGROUND_NEW, topAbility->GetAbilityState()); + testing::Mock::AllowLeak(scheduler); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StartAbility_008 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_ConnectAbility_001 + * SubFunction: NA + * FunctionPoints: AbilityManagerService ConnectAbility + * EnvConditions: NA + * CaseDescription: Start single ServiceAbility with 0 user authentication ConnectAbility interface + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_ConnectAbility_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_ConnectAbility_001 start"; + Want want; + ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic"); + want.SetElement(element); + sptr stub(new MockAbilityConnectCallbackStub()); + const sptr callback(new AbilityConnectionProxy(stub)); + auto result = abilityMgrServ_->ConnectAbility(want, callback, nullptr, 0); + EXPECT_EQ(OHOS::ERR_OK, result); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_ConnectAbility_001 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_ConnectAbility_002 + * SubFunction: NA + * FunctionPoints: AbilityManagerService ConnectAbility + * EnvConditions: NA + * CaseDescription: Start single ServiceAbility with 100 user authentication ConnectAbility interface + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_ConnectAbility_002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_ConnectAbility_002 start"; + Want want; + ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic"); + want.SetElement(element); + sptr stub(new MockAbilityConnectCallbackStub()); + const sptr callback(new AbilityConnectionProxy(stub)); + auto result = abilityMgrServ_->ConnectAbility(want, callback, nullptr, MOCK_MAIN_USER_ID); + EXPECT_EQ(OHOS::ERR_OK, result); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_ConnectAbility_002 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_ConnectAbility_003 + * SubFunction: NA + * FunctionPoints: AbilityManagerService ConnectAbility + * EnvConditions: NA + * CaseDescription: Start single ServiceAbility with error user authentication ConnectAbility interface + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_ConnectAbility_003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_ConnectAbility_003 start"; + Want want; + ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic"); + want.SetElement(element); + sptr stub(new MockAbilityConnectCallbackStub()); + const sptr callback(new AbilityConnectionProxy(stub)); + auto result = abilityMgrServ_->ConnectAbility(want, callback, nullptr, ERROR_USER_ID_U256); + EXPECT_NE(OHOS::ERR_OK, result); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_ConnectAbility_003 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_ConnectAbility_004 + * SubFunction: NA + * FunctionPoints: AbilityManagerService ConnectAbility + * EnvConditions: NA + * CaseDescription: Specify a user to bind a Serviceability + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_ConnectAbility_004, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_ConnectAbility_004 start"; + std::string abilityName = "AccountServiceTest"; + std::string bundleName = "com.ix.hiAccountService"; + + Want want; + std::shared_ptr curMissionStack; + sptr recordToken; + CreateAbilityRequest(abilityName, bundleName, want, curMissionStack, recordToken); + + sptr stub(new MockAbilityConnectCallbackStub()); + const sptr callback(new AbilityConnectionProxy(stub)); + + bool testResult = false; + sptr testToken; + MockServiceAbilityLoadHandlerInner(testResult, bundleName, abilityName, testToken); + + int result = abilityMgrServ_->ConnectAbility(want, callback, recordToken, MOCK_MAIN_USER_ID); + EXPECT_EQ(OHOS::ERR_OK, result); + + EXPECT_EQ((std::size_t)1, abilityMgrServ_->connectManager_->connectMap_.size()); + EXPECT_EQ((std::size_t)1, abilityMgrServ_->connectManager_->serviceMap_.size()); + std::shared_ptr record = + abilityMgrServ_->GetConnectManagerByUserId(MOCK_MAIN_USER_ID)->GetServiceRecordByToken(testToken); + EXPECT_TRUE(record); + ElementName element; + + std::shared_ptr connectRecord = record->GetConnectRecordList().front(); + EXPECT_TRUE(connectRecord); + + sptr scheduler = new MockAbilityScheduler(); + EXPECT_TRUE(scheduler); + + EXPECT_CALL(*mockAppMgrClient_, UpdateAbilityState(_, _)).Times(3); + abilityMgrServ_->AttachAbilityThread(scheduler, record->GetToken()); + EXPECT_TRUE(record->isReady_); + + EXPECT_CALL(*scheduler, ScheduleAbilityTransaction(_, _)).Times(1); + abilityMgrServ_->OnAbilityRequestDone( + record->GetToken(), (int32_t)OHOS::AppExecFwk::AbilityState::ABILITY_STATE_FOREGROUND); + EXPECT_EQ(OHOS::AAFwk::AbilityState::INACTIVATING, record->GetAbilityState()); + + EXPECT_CALL(*scheduler, ScheduleConnectAbility(_)).Times(1); + PacMap saveData; + abilityMgrServ_->AbilityTransitionDone(record->GetToken(), AbilityLifeCycleState::ABILITY_STATE_INACTIVE, saveData); + EXPECT_TRUE(record->GetConnectingRecord()); + EXPECT_EQ(OHOS::AAFwk::ConnectionState::CONNECTING, connectRecord->GetConnectState()); + + EXPECT_CALL(*stub, OnAbilityConnectDone(_, _, _)).Times(1); + abilityMgrServ_->ScheduleConnectAbilityDone(record->GetToken(), nullptr); + + EXPECT_EQ(OHOS::AAFwk::ConnectionState::CONNECTED, connectRecord->GetConnectState()); + EXPECT_EQ(OHOS::AAFwk::AbilityState::ACTIVE, record->GetAbilityState()); + + abilityMgrServ_->RemoveAllServiceRecord(); + curMissionStack->RemoveAll(); + + testing::Mock::AllowLeak(scheduler); + testing::Mock::AllowLeak(stub); + testing::Mock::AllowLeak(callback); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_ConnectAbility_004 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_ConnectAbility_005 + * SubFunction: NA + * FunctionPoints: AbilityManagerService ConnectAbility + * EnvConditions: NA + * CaseDescription: Do not specify a user to bind a Serviceability + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_ConnectAbility_005, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_ConnectAbility_005 start"; + std::string abilityName = "AccountServiceTest"; + std::string bundleName = "com.ix.hiAccountService"; + + Want want; + std::shared_ptr curMissionStack; + sptr recordToken; + CreateAbilityRequest(abilityName, bundleName, want, curMissionStack, recordToken); + + sptr stub(new MockAbilityConnectCallbackStub()); + const sptr callback(new AbilityConnectionProxy(stub)); + + bool testResult = false; + sptr testToken; + MockServiceAbilityLoadHandlerInner(testResult, bundleName, abilityName, testToken); + + int result = abilityMgrServ_->ConnectAbility(want, callback, recordToken); + EXPECT_EQ(OHOS::ERR_OK, result); + + EXPECT_EQ((std::size_t)1, abilityMgrServ_->connectManager_->connectMap_.size()); + EXPECT_EQ((std::size_t)1, abilityMgrServ_->connectManager_->serviceMap_.size()); + std::shared_ptr record = + abilityMgrServ_->GetConnectManagerByUserId(MOCK_MAIN_USER_ID)->GetServiceRecordByToken(testToken); + EXPECT_TRUE(record); + ElementName element; + + std::shared_ptr connectRecord = record->GetConnectRecordList().front(); + EXPECT_TRUE(connectRecord); + + sptr scheduler = new MockAbilityScheduler(); + EXPECT_TRUE(scheduler); + + EXPECT_CALL(*mockAppMgrClient_, UpdateAbilityState(_, _)).Times(3); + abilityMgrServ_->AttachAbilityThread(scheduler, record->GetToken()); + EXPECT_TRUE(record->isReady_); + + EXPECT_CALL(*scheduler, ScheduleAbilityTransaction(_, _)).Times(1); + abilityMgrServ_->OnAbilityRequestDone( + record->GetToken(), (int32_t)OHOS::AppExecFwk::AbilityState::ABILITY_STATE_FOREGROUND); + EXPECT_EQ(OHOS::AAFwk::AbilityState::INACTIVATING, record->GetAbilityState()); + + EXPECT_CALL(*scheduler, ScheduleConnectAbility(_)).Times(1); + PacMap saveData; + abilityMgrServ_->AbilityTransitionDone(record->GetToken(), AbilityLifeCycleState::ABILITY_STATE_INACTIVE, saveData); + EXPECT_TRUE(record->GetConnectingRecord()); + EXPECT_EQ(OHOS::AAFwk::ConnectionState::CONNECTING, connectRecord->GetConnectState()); + + EXPECT_CALL(*stub, OnAbilityConnectDone(_, _, _)).Times(1); + abilityMgrServ_->ScheduleConnectAbilityDone(record->GetToken(), nullptr); + + EXPECT_EQ(OHOS::AAFwk::ConnectionState::CONNECTED, connectRecord->GetConnectState()); + EXPECT_EQ(OHOS::AAFwk::AbilityState::ACTIVE, record->GetAbilityState()); + + abilityMgrServ_->RemoveAllServiceRecord(); + curMissionStack->RemoveAll(); + + testing::Mock::AllowLeak(scheduler); + testing::Mock::AllowLeak(stub); + testing::Mock::AllowLeak(callback); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_ConnectAbility_005 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_StopServiceAbility_001 + * SubFunction: NA + * FunctionPoints: AbilityManagerService StopServiceAbility + * EnvConditions: NA + * CaseDescription: Use single ServiceAbility with 0 user authentication StopServiceAbility interface + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_StopServiceAbility_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StopServiceAbility_001 start"; + Want want; + ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic"); + want.SetElement(element); + sptr stub(new MockAbilityConnectCallbackStub()); + const sptr callback(new AbilityConnectionProxy(stub)); + auto result = abilityMgrServ_->ConnectAbility(want, callback, nullptr, 0); + EXPECT_EQ(OHOS::ERR_OK, result); + EXPECT_CALL(*stub, OnAbilityDisconnectDone(_, _)).Times(1); + result = abilityMgrServ_->StopServiceAbility(want, 0); + EXPECT_EQ(OHOS::ERR_OK, result); + testing::Mock::AllowLeak(stub); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StopServiceAbility_001 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_StopServiceAbility_002 + * SubFunction: NA + * FunctionPoints: AbilityManagerService StopServiceAbility + * EnvConditions: NA + * CaseDescription: Use single ServiceAbility with 100 user authentication StopServiceAbility interface + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_StopServiceAbility_002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StopServiceAbility_002 start"; + Want want; + ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic"); + want.SetElement(element); + sptr stub(new MockAbilityConnectCallbackStub()); + const sptr callback(new AbilityConnectionProxy(stub)); + auto result = abilityMgrServ_->ConnectAbility(want, callback, nullptr, MOCK_MAIN_USER_ID); + EXPECT_EQ(OHOS::ERR_OK, result); + EXPECT_CALL(*stub, OnAbilityDisconnectDone(_, _)).Times(1); + result = abilityMgrServ_->StopServiceAbility(want, MOCK_MAIN_USER_ID); + EXPECT_EQ(OHOS::ERR_OK, result); + testing::Mock::AllowLeak(stub); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StopServiceAbility_002 end"; +} + +/* + * Feature: AaFwk + * Function: AbilityMgrModuleAccountTest_StopServiceAbility_003 + * SubFunction: NA + * FunctionPoints: AbilityManagerService StopServiceAbility + * EnvConditions: NA + * CaseDescription: Use single ServiceAbility with error user authentication StopServiceAbility interface + */ +HWTEST_F(AbilityMgrModuleAccountTest, AbilityMgrModuleAccountTest_StopServiceAbility_003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StopServiceAbility_003 start"; + Want want; + ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic"); + want.SetElement(element); + sptr stub(new MockAbilityConnectCallbackStub()); + const sptr callback(new AbilityConnectionProxy(stub)); + auto result = abilityMgrServ_->ConnectAbility(want, callback, nullptr, ERROR_USER_ID_U256); + EXPECT_NE(OHOS::ERR_OK, result); + result = abilityMgrServ_->StopServiceAbility(want, ERROR_USER_ID_U256); + EXPECT_NE(OHOS::ERR_OK, result); + GTEST_LOG_(INFO) << "AbilityMgrModuleAccountTest AbilityMgrModuleAccountTest_StopServiceAbility_003 end"; +} +} // namespace AAFwk +} // namespace OHOS diff --git a/services/test/moduletest/ability_mgr_service_test/BUILD.gn b/services/test/moduletest/ability_mgr_service_test/BUILD.gn index e25767356bc7e761868b105515811de9f5c1dad4..8938b6d6aa3c2849e8319b1d2ce9c0f9919294cf 100644 --- a/services/test/moduletest/ability_mgr_service_test/BUILD.gn +++ b/services/test/moduletest/ability_mgr_service_test/BUILD.gn @@ -92,6 +92,7 @@ ohos_moduletest("ability_mgr_module_test") { "${services_path}/common:perm_verification", "//base/account/os_account/frameworks/osaccount/native:os_account_innerkits", "//base/global/i18n_standard/frameworks/intl:intl_util", + "//base/startup/syspara_lite/interfaces/innerkits/native/syspara:syspara", "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", "//foundation/aafwk/standard/frameworks/kits/ability/native:dummy_classes", "//foundation/aafwk/standard/services/abilitymgr:abilityms", diff --git a/services/test/moduletest/ability_stack_test/BUILD.gn b/services/test/moduletest/ability_stack_test/BUILD.gn index 84467eb03d224c18d85ff93cbd4b127e3bffc95a..77a6672ba847739b24c5e5a10a8af1a1cc2c0472 100644 --- a/services/test/moduletest/ability_stack_test/BUILD.gn +++ b/services/test/moduletest/ability_stack_test/BUILD.gn @@ -94,6 +94,7 @@ ohos_moduletest("ability_stack_module_test") { "${services_path}/common:perm_verification", "//base/account/os_account/frameworks/osaccount/native:os_account_innerkits", "//base/global/i18n_standard/frameworks/intl:intl_util", + "//base/startup/syspara_lite/interfaces/innerkits/native/syspara:syspara", "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", "//foundation/aafwk/standard/frameworks/kits/ability/native:dummy_classes", "//foundation/aafwk/standard/services/abilitymgr:abilityms", diff --git a/services/test/moduletest/call_module_test/BUILD.gn b/services/test/moduletest/call_module_test/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..b4d21519c44ccb1e86f4bff1827637691e22f305 --- /dev/null +++ b/services/test/moduletest/call_module_test/BUILD.gn @@ -0,0 +1,72 @@ +# Copyright (c) 2021-2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import("//build/test.gni") +import("//foundation/aafwk/standard/aafwk.gni") + +module_output_path = "ability_runtime/ability_call_test" + +ohos_moduletest("call_ability_service_module_test") { + module_out_path = module_output_path + + include_dirs = [ + "//foundation/aafwk/standard/services/test/mock/include", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy/include", + "//foundation/distributedschedule/samgr/adapter/interfaces/innerkits/include/", + "//foundation/aafwk/standard/interfaces/innerkits/app_manager/include/appmgr", + "//foundation/aafwk/standard/frameworks/kits/ability/native/test/mock/include", + ] + + sources = [ + # add mock file + "//foundation/aafwk/standard/services/abilitymgr/test/mock/libs/appexecfwk_core/src/appmgr/mock_app_scheduler.cpp", + "call_ability_service_module_test.cpp", + ] + + configs = [ "${services_path}/abilitymgr:abilityms_config" ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + deps = [ + "${innerkits_path}/want:want", + "${services_path}/abilitymgr/test:abilityms_test_source", + "${services_path}/abilitymgr/test/mock/libs/aakit:aakit_mock", + "${services_path}/abilitymgr/test/mock/libs/appexecfwk_core:appexecfwk_appmgr_mock", + "${services_path}/abilitymgr/test/mock/libs/appexecfwk_core:appexecfwk_bundlemgr_mock", + "${services_path}/common:perm_verification", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//foundation/aafwk/standard/frameworks/kits/ability/native:dummy_classes", + "//foundation/aafwk/standard/interfaces/innerkits/app_manager:app_manager", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler:libeventhandler", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//third_party/libpng:libpng", + "//utils/native/base:utils", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "device_manager_base:devicemanagersdk", + "dsoftbus_standard:softbus_client", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] +} + +group("moduletest") { + testonly = true + deps = [ ":call_ability_service_module_test" ] +} diff --git a/services/test/moduletest/call_module_test/call_ability_service_module_test.cpp b/services/test/moduletest/call_module_test/call_ability_service_module_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b26ca1d75f6d66a9f25f86161bf03cf64ae16c7f --- /dev/null +++ b/services/test/moduletest/call_module_test/call_ability_service_module_test.cpp @@ -0,0 +1,202 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#define private public +#define protected public +#include "ability_manager_service.h" +#include "ability_event_handler.h" +#undef private +#undef protected + +#include "app_process_data.h" +#include "system_ability_definition.h" +#include "ability_manager_errors.h" +#include "ability_scheduler.h" +#include "sa_mgr_client.h" +#include "mock_ability_connect_callback.h" +#include "mock_ability_token.h" +#include "mock_bundle_mgr.h" +#include "if_system_ability_manager.h" +#include "iservice_registry.h" + +using namespace testing; +using namespace testing::ext; +using namespace OHOS::AppExecFwk; + +namespace { + const std::string DEVICE_ID = "15010038475446345206a332922cb765"; + const std::string BUNDLE_NAME = "testBundle"; + const std::string NAME = ".testMainAbility"; +} + +namespace OHOS { +namespace AAFwk { +static void WaitUntilTaskFinished() +{ + const uint32_t maxRetryCount = 1000; + const uint32_t sleepTime = 1000; + uint32_t count = 0; + auto handler = OHOS::DelayedSingleton::GetInstance()->GetEventHandler(); + std::atomic taskCalled(false); + auto f = [&taskCalled]() { taskCalled.store(true); }; + if (handler->PostTask(f)) { + while (!taskCalled.load()) { + ++count; + if (count >= maxRetryCount) { + break; + } + usleep(sleepTime); + } + } +} + +#define SLEEP(milli) std::this_thread::sleep_for(std::chrono::seconds(milli)) + +namespace { +const std::string WaitUntilTaskFinishedByTimer = "BundleMgrService"; +} // namespace + +class AbilityManagerServiceTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); + void OnStartAms(); + void OnStopAms(); + int StartAbility(const Want &want); + static constexpr int TEST_WAIT_TIME = 100000; + +public: + AbilityRequest abilityRequest_; + std::shared_ptr abilityRecord_ {nullptr}; + std::shared_ptr abilityMs_ = DelayedSingleton::GetInstance(); +}; + +int AbilityManagerServiceTest::StartAbility(const Want &want) +{ + int ref = -1; + auto topAbility = abilityMs_->GetStackManager()->GetCurrentTopAbility(); + if (topAbility) { + topAbility->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE); + } + ref = abilityMs_->StartAbility(want); + WaitUntilTaskFinished(); + return ref; +} + +void AbilityManagerServiceTest::OnStartAms() +{ + if (abilityMs_) { + if (abilityMs_->state_ == ServiceRunningState::STATE_RUNNING) { + return; + } + + abilityMs_->state_ = ServiceRunningState::STATE_RUNNING; + + abilityMs_->eventLoop_ = AppExecFwk::EventRunner::Create(AbilityConfig::NAME_ABILITY_MGR_SERVICE); + EXPECT_TRUE(abilityMs_->eventLoop_); + + abilityMs_->handler_ = std::make_shared(abilityMs_->eventLoop_, abilityMs_); + abilityMs_->connectManager_ = std::make_shared(); + abilityMs_->connectManagers_.emplace(0, abilityMs_->connectManager_); + EXPECT_TRUE(abilityMs_->handler_); + EXPECT_TRUE(abilityMs_->connectManager_); + + abilityMs_->dataAbilityManager_ = std::make_shared(); + abilityMs_->dataAbilityManagers_.emplace(0, abilityMs_->dataAbilityManager_); + EXPECT_TRUE(abilityMs_->dataAbilityManager_); + + abilityMs_->amsConfigResolver_ = std::make_shared(); + EXPECT_TRUE(abilityMs_->amsConfigResolver_); + abilityMs_->amsConfigResolver_->Parse(); + + abilityMs_->pendingWantManager_ = std::make_shared(); + EXPECT_TRUE(abilityMs_->pendingWantManager_); + + abilityMs_->currentMissionListManager_ = std::make_shared(0); + abilityMs_->currentMissionListManager_->Init(); + int userId = abilityMs_->GetUserId(); + abilityMs_->SetStackManager(userId, true); + EXPECT_TRUE(abilityMs_->GetStackManager()); + abilityMs_->stackManagers_.emplace(0, abilityMs_->GetStackManager()); + abilityMs_->eventLoop_->Run(); + return; + } + + GTEST_LOG_(INFO) << "OnStart fail"; +} + +void AbilityManagerServiceTest::OnStopAms() +{ + abilityMs_->OnStop(); +} + +void AbilityManagerServiceTest::SetUpTestCase() +{ + OHOS::DelayedSingleton::GetInstance()->RegisterSystemAbility( + OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new BundleMgrService()); +} + +void AbilityManagerServiceTest::TearDownTestCase() +{ + OHOS::DelayedSingleton::DestroyInstance(); +} + +void AbilityManagerServiceTest::SetUp() +{ + OnStartAms(); + WaitUntilTaskFinished(); + if (abilityRecord_ == nullptr) { + abilityRequest_.appInfo.bundleName = "data.client.bundle"; + abilityRequest_.abilityInfo.name = "ClientAbility"; + abilityRequest_.abilityInfo.type = AbilityType::DATA; + abilityRecord_ = AbilityRecord::CreateAbilityRecord(abilityRequest_); + } +} + +void AbilityManagerServiceTest::TearDown() +{ + OnStopAms(); +} + +/** + * @tc.name: CheckCallPermissions_001 + * @tc.desc: Verify function CheckCallPermissions return RESOLVE_CALL_NO_PERMISSIONS + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AbilityManagerServiceTest, CheckCallPermissions_001, TestSize.Level1) +{ + abilityRequest_.callerUid = 0; + EXPECT_EQ(RESOLVE_CALL_NO_PERMISSIONS, abilityMs_->CheckCallPermissions(abilityRequest_)); +} + +/** + * @tc.name: CheckCallPermissions_002 + * @tc.desc: Verify function CheckCallPermissions return ERR_OK + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AbilityManagerServiceTest, CheckCallPermissions_002, TestSize.Level1) +{ + abilityRequest_.callerUid = 1000; + abilityRequest_.abilityInfo.type = AppExecFwk::AbilityType::PAGE; + abilityRequest_.abilityInfo.launchMode = AppExecFwk::LaunchMode::SINGLETON; + EXPECT_EQ(ERR_OK, abilityMs_->CheckCallPermissions(abilityRequest_)); +} +} +} \ No newline at end of file diff --git a/services/test/moduletest/common/ams/BUILD.gn b/services/test/moduletest/common/ams/BUILD.gn index 5259503d20aa15707ade0143d3f800dd6a97d796..6813c43e6d5295fed83bdc92eaa9ab2627e1c570 100755 --- a/services/test/moduletest/common/ams/BUILD.gn +++ b/services/test/moduletest/common/ams/BUILD.gn @@ -70,10 +70,12 @@ ohos_source_set("appmgr_mst_source") { cflags += [ "-DBINDER_IPC_32BIT" ] } public_deps = [ + "${aafwk_path}/interfaces/innerkits/ability_manager:ability_manager", "${aafwk_path}/interfaces/innerkits/app_manager:app_manager", "${appexecfwk_path}/common:libappexecfwk_common", "${appexecfwk_path}/libs/libeventhandler:libeventhandler_target", "${innerkits_path}/uri_permission:uri_permission_mgr", + "${services_path}/common:perm_verification", "//base/account/os_account/frameworks/osaccount/native:os_account_innerkits", "//base/security/permission/interfaces/innerkits/permission_standard/permissionsdk:libpermissionsdk_standard", "//foundation/aafwk/standard/interfaces/innerkits/app_manager:app_manager", @@ -92,6 +94,7 @@ ohos_source_set("appmgr_mst_source") { "bytrace_standard:bytrace_core", "ces_standard:cesfwk_core", "ces_standard:cesfwk_innerkits", + "hicollie_native:libhicollie", "hisysevent_native:libhisysevent", "hiviewdfx_hilog_native:libhilog", "ipc:ipc_core", @@ -106,6 +109,7 @@ group("moduletest") { "app_life_cycle_test:moduletest", "app_mgr_service_test:moduletest", "app_recent_list_test:moduletest", + "app_running_processes_info_module_test:moduletest", "app_running_record_test:moduletest", "app_service_flow_test:moduletest", "ipc_ams_mgr_test:moduletest", @@ -114,5 +118,6 @@ group("moduletest") { "service_app_spawn_client_test:moduletest", "service_event_drive_test:moduletest", "service_start_process_test:moduletest", + "specified_ability_service_test:moduletest", ] } diff --git a/services/test/moduletest/common/ams/app_life_cycle_test/BUILD.gn b/services/test/moduletest/common/ams/app_life_cycle_test/BUILD.gn index 3d24e62bff461dd90bdd7ef2d1ff89a6b96357d6..868eaa1e9c8af8a0ea7cac3c18a39d2df20c0ca6 100755 --- a/services/test/moduletest/common/ams/app_life_cycle_test/BUILD.gn +++ b/services/test/moduletest/common/ams/app_life_cycle_test/BUILD.gn @@ -28,12 +28,16 @@ ohos_moduletest("AmsAppLifeCycleModuleTest") { deps = [ "${services_path}/common:perm_verification", "${services_path}/test/moduletest/common/ams:appmgr_mst_source", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", ] - external_deps = [ "ipc:ipc_core" ] + external_deps = [ + "ipc:ipc_core", + "samgr_standard:samgr_proxy", + ] } group("moduletest") { testonly = true - # deps = [ ":AmsAppLifeCycleModuleTest" ] + deps = [ ":AmsAppLifeCycleModuleTest" ] } diff --git a/services/test/moduletest/common/ams/app_life_cycle_test/ams_app_life_cycle_module_test.cpp b/services/test/moduletest/common/ams/app_life_cycle_test/ams_app_life_cycle_module_test.cpp index 2e1ec26087bc88cc31c9d2e1188ba8ebcb803a40..16b9b75b909092ea413d166544f4f85cda11f8e8 100755 --- a/services/test/moduletest/common/ams/app_life_cycle_test/ams_app_life_cycle_module_test.cpp +++ b/services/test/moduletest/common/ams/app_life_cycle_test/ams_app_life_cycle_module_test.cpp @@ -21,6 +21,7 @@ #include #include #include "app_launch_data.h" +#include "app_mgr_interface.h" #include "iremote_object.h" #include "app_state_callback_proxy.h" #include "app_log_wrapper.h" @@ -31,6 +32,8 @@ #include "mock_app_spawn_client.h" #include "mock_app_spawn_socket.h" #include "mock_iapp_state_callback.h" +#include "system_ability_definition.h" +#include "sys_mgr_client.h" using namespace testing::ext; using testing::_; @@ -860,66 +863,6 @@ HWTEST_F(AmsAppLifeCycleModuleTest, StateChange_009, TestSize.Level3) } } -/* - * Feature: Ams - * Function: AppLifeCycle - * SubFunction: NA - * FunctionPoints: test get and stop all process. - * EnvConditions: system running normally - * CaseDescription: 1.call loadAbility API to start 100 app - * 2.stop all process - */ -HWTEST_F(AmsAppLifeCycleModuleTest, StateChange_010, TestSize.Level3) -{ - pid_t pid = 1025; - EXPECT_NE(serviceInner_, nullptr); - CHECK_POINTER_IS_NULLPTR(serviceInner_); - std::shared_ptr appRunningRecord = nullptr; - int32_t recordId[APPLICATION_NUM]; - sptr mockAppScheduler[APPLICATION_NUM]; - - TestProcessInfo testProcessInfo; - for (int i = 0; i < APPLICATION_NUM; i++) { - mockAppScheduler[i] = new MockAppScheduler(); - - char index[32]; - int ref = snprintf_s(index, sizeof(index), sizeof(index) - 1, "%d", i); - EXPECT_TRUE(ref > 0); - char name[128]; - ref = snprintf_s(name, sizeof(name), sizeof(name) - 1, "com.ohos.test.helloworld%d", i); - EXPECT_TRUE(ref > 0); - auto abilityInfo = GetAbilityInfo(index, "MainAbility", index, name); - auto appInfo = GetApplicationInfo(name); - auto token = new (std::nothrow) MockAbilityToken(); - pid += i; - - testProcessInfo.pid = pid; - testProcessInfo.isStart = false; - - appRunningRecord = - StartProcessAndLoadAbility(mockAppScheduler[i], token, abilityInfo, appInfo, testProcessInfo); - EXPECT_TRUE(appRunningRecord); - - ChangeAbilityStateAfterAppStart(mockAppScheduler[i], testProcessInfo.pid); - - recordId[i] = appRunningRecord->GetRecordId(); - - CheckState(appRunningRecord, token, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY); - ChangeAbilityStateToForegroud(mockAppScheduler[i], appRunningRecord, token); - - ChangeAbilityStateToBackGroud(mockAppScheduler[i], appRunningRecord, token); - CheckState( - appRunningRecord, token, AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND); - EXPECT_CALL(*mockAppScheduler[i], ScheduleProcessSecurityExit()).Times(1); - } - - sptr bundleMgr = new BundleMgrService(); - serviceInner_->SetBundleManager(bundleMgr.GetRefPtr()); - std::vector allRunningProcessInfo; - serviceInner_->GetAllRunningProcesses(allRunningProcessInfo); - EXPECT_EQ(allRunningProcessInfo.size(), size_t(APPLICATION_NUM)); -} - /* * Feature: Ams * Function: AppLifeCycle @@ -1397,55 +1340,6 @@ HWTEST_F(AmsAppLifeCycleModuleTest, AbilityBehaviorAnalysis_06, TestSize.Level1) EXPECT_EQ(abilityRecord_1->GetConnectionState(), connectionState); } -/* - * Feature: AbilityMgr - * Function: StartResidentProcess - * SubFunction: NA - * FunctionPoints: NA - * EnvConditions: NA - * CaseDescription: NA - */ -HWTEST_F(AmsAppLifeCycleModuleTest, StartResidentProcess_01, TestSize.Level1) -{ - pid_t pid = 123; - sptr token = GetAbilityToken(); - std::string appName = "KeepAliveApp"; - std::string proc = "KeepAliveApplication"; - int uid = 2100; - - std::vector infos; - BundleInfo info; - info.name = proc; - info.uid = uid; - - ApplicationInfo appInfo; - appInfo.name = "KeepAliveApp"; - appInfo.bundleName = "KeepAliveApplication"; - appInfo.uid = 2100; - - info.applicationInfo = appInfo; - HapModuleInfo hapModuleInfo; - hapModuleInfo.name = "Module"; - HapModuleInfo hapModuleInfo1; - hapModuleInfo1.name = "Module1"; - info.hapModuleInfos.push_back(hapModuleInfo); - info.hapModuleInfos.push_back(hapModuleInfo1); - - infos.push_back(info); - - sptr mockAppScheduler = new MockAppScheduler(); - - auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, info); - EXPECT_FALSE(appRecord); - - StartAppProcess(pid); - serviceInner_->StartResidentProcess(infos, -1); - appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, info); - EXPECT_TRUE(appRecord); - pid_t newPid = appRecord->GetPriorityObject()->GetPid(); - EXPECT_TRUE(newPid == pid); -} - /* * Feature: AbilityMgr * Function: LoadAbility @@ -1777,5 +1671,529 @@ HWTEST_F(AmsAppLifeCycleModuleTest, KillApplication_003, TestSize.Level1) auto appMap1 = serviceInner_->appRunningManager_->GetAppRunningRecordMap(); EXPECT_EQ(0, static_cast(appMap1.size())); } + +/* + * Feature: AbilityMgr + * Function: UpdateConfiguration + * SubFunction: NA + * FunctionPoints: Environmental Change Notification + * EnvConditions: NA + * CaseDescription: Start two apps and then make environment change notifications + */ +HWTEST_F(AmsAppLifeCycleModuleTest, UpdateConfiguration_001, TestSize.Level1) +{ + EXPECT_NE(serviceInner_, nullptr); + CHECK_POINTER_IS_NULLPTR(serviceInner_); + pid_t pid_0 = 1024; + pid_t pid_1 = 2048; + sptr token_0 = new (std::nothrow) MockAbilityToken(); + sptr token_1 = new (std::nothrow) MockAbilityToken(); + auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld0"); + auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld0"); + auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p2", "com.ohos.test.helloworld0"); + auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld0"); + sptr mockAppScheduler = new (std::nothrow) MockAppScheduler(); + sptr mockAppScheduler1 = new (std::nothrow) MockAppScheduler(); + TestProcessInfo testProcessInfo; + + testProcessInfo.pid = pid_0; + testProcessInfo.isStart = false; + auto appRunningRecord_0 = + StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo); + + testProcessInfo.pid = pid_1; + testProcessInfo.isStart = false; + auto appRunningRecord_1 = + StartProcessAndLoadAbility(mockAppScheduler1, token_1, abilityInfo_1, appInfo_1, testProcessInfo); + ChangeAbilityStateAfterAppStart(mockAppScheduler, pid_0); + CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY); + ChangeAbilityStateAfterAppStart(mockAppScheduler1, pid_1); + CheckState(appRunningRecord_1, token_1, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY); + + auto testLanguge = std::string("ch-zh"); + auto configUpdate = [testLanguge](const Configuration &config) { + auto l = config.GetItem(GlobalConfigurationKey::SYSTEM_LANGUAGE); + EXPECT_TRUE(testLanguge == l); + }; + + Configuration config; + config.AddItem(GlobalConfigurationKey::SYSTEM_LANGUAGE, testLanguge); + + auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap(); + EXPECT_EQ(2, static_cast(appMap.size())); + + EXPECT_CALL(*mockAppScheduler, ScheduleConfigurationUpdated(_)) + .Times(1) + .WillOnce(testing::Invoke(configUpdate)); + EXPECT_CALL(*mockAppScheduler1, ScheduleConfigurationUpdated(_)) + .Times(1) + .WillOnce(testing::Invoke(configUpdate)); + + serviceInner_->UpdateConfiguration(config); +} + +/* + * Feature: AbilityMgr + * Function: UpdateConfiguration + * SubFunction: NA + * FunctionPoints: Environmental Change Notification + * EnvConditions: NA + * CaseDescription: Verify duplicate notification conditions + */ +HWTEST_F(AmsAppLifeCycleModuleTest, UpdateConfiguration_002, TestSize.Level1) +{ + EXPECT_NE(serviceInner_, nullptr); + CHECK_POINTER_IS_NULLPTR(serviceInner_); + pid_t pid_0 = 1024; + pid_t pid_1 = 2048; + sptr token_0 = new (std::nothrow) MockAbilityToken(); + sptr token_1 = new (std::nothrow) MockAbilityToken(); + auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld0"); + auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld0"); + auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p2", "com.ohos.test.helloworld0"); + auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld0"); + sptr mockAppScheduler = new (std::nothrow) MockAppScheduler(); + sptr mockAppScheduler1 = new (std::nothrow) MockAppScheduler(); + TestProcessInfo testProcessInfo; + + testProcessInfo.pid = pid_0; + testProcessInfo.isStart = false; + auto appRunningRecord_0 = + StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo); + + testProcessInfo.pid = pid_1; + testProcessInfo.isStart = false; + auto appRunningRecord_1 = + StartProcessAndLoadAbility(mockAppScheduler1, token_1, abilityInfo_1, appInfo_1, testProcessInfo); + ChangeAbilityStateAfterAppStart(mockAppScheduler, pid_0); + CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY); + ChangeAbilityStateAfterAppStart(mockAppScheduler1, pid_1); + CheckState(appRunningRecord_1, token_1, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY); + + auto testLanguge = std::string("ch-zh"); + auto again = std::string("Russian"); + auto displayId = 10; + auto configUpdate = [testLanguge, displayId](const Configuration &config) { + auto l = config.GetItem(displayId, GlobalConfigurationKey::SYSTEM_LANGUAGE); + EXPECT_TRUE(testLanguge == l); + }; + + auto configUpdateAgain = [again, displayId](const Configuration &config) { + auto l = config.GetItem(displayId, GlobalConfigurationKey::SYSTEM_LANGUAGE); + EXPECT_TRUE(again == l); + }; + + Configuration config; + config.AddItem(displayId, GlobalConfigurationKey::SYSTEM_LANGUAGE, testLanguge); + + auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap(); + EXPECT_EQ(2, static_cast(appMap.size())); + + EXPECT_CALL(*mockAppScheduler, ScheduleConfigurationUpdated(_)) + .Times(2) + .WillOnce(testing::Invoke(configUpdate)) + .WillOnce(testing::Invoke(configUpdateAgain)); + + EXPECT_CALL(*mockAppScheduler1, ScheduleConfigurationUpdated(_)) + .Times(2) + .WillOnce(testing::Invoke(configUpdate)) + .WillOnce(testing::Invoke(configUpdateAgain)); + + serviceInner_->UpdateConfiguration(config); + + config.AddItem(displayId, GlobalConfigurationKey::SYSTEM_LANGUAGE, again); + + serviceInner_->UpdateConfiguration(config); +} + +/* + * Feature: AbilityMgr + * Function: UpdateConfiguration + * SubFunction: NA + * FunctionPoints: Environmental Change Notification + * EnvConditions: NA + * CaseDescription: Two types of notifications + */ +HWTEST_F(AmsAppLifeCycleModuleTest, UpdateConfiguration_003, TestSize.Level1) +{ + EXPECT_NE(serviceInner_, nullptr); + CHECK_POINTER_IS_NULLPTR(serviceInner_); + pid_t pid_0 = 1024; + pid_t pid_1 = 2048; + sptr token_0 = new (std::nothrow) MockAbilityToken(); + sptr token_1 = new (std::nothrow) MockAbilityToken(); + auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld0"); + auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld0"); + auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p2", "com.ohos.test.helloworld0"); + auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld0"); + sptr mockAppScheduler = new (std::nothrow) MockAppScheduler(); + sptr mockAppScheduler1 = new (std::nothrow) MockAppScheduler(); + TestProcessInfo testProcessInfo; + + testProcessInfo.pid = pid_0; + testProcessInfo.isStart = false; + auto appRunningRecord_0 = + StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo); + + testProcessInfo.pid = pid_1; + testProcessInfo.isStart = false; + auto appRunningRecord_1 = + StartProcessAndLoadAbility(mockAppScheduler1, token_1, abilityInfo_1, appInfo_1, testProcessInfo); + ChangeAbilityStateAfterAppStart(mockAppScheduler, pid_0); + CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY); + ChangeAbilityStateAfterAppStart(mockAppScheduler1, pid_1); + CheckState(appRunningRecord_1, token_1, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY); + + auto testLanguge = std::string("ch-zh"); + auto displayId = 10; + auto configUpdate = [testLanguge, displayId](const Configuration &config) { + auto ld = config.GetItem(displayId, GlobalConfigurationKey::SYSTEM_LANGUAGE); + auto l = config.GetItem(displayId, GlobalConfigurationKey::SYSTEM_LANGUAGE); + EXPECT_TRUE(testLanguge == ld); + EXPECT_TRUE(testLanguge == l); + }; + + Configuration config; + config.AddItem(displayId, GlobalConfigurationKey::SYSTEM_LANGUAGE, testLanguge); + config.AddItem(GlobalConfigurationKey::SYSTEM_LANGUAGE, testLanguge); + + auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap(); + EXPECT_EQ(2, static_cast(appMap.size())); + + EXPECT_CALL(*mockAppScheduler, ScheduleConfigurationUpdated(_)) + .Times(1) + .WillOnce(testing::Invoke(configUpdate)); + + EXPECT_CALL(*mockAppScheduler1, ScheduleConfigurationUpdated(_)) + .Times(1) + .WillOnce(testing::Invoke(configUpdate)); + + serviceInner_->UpdateConfiguration(config); +} + +/* + * Feature: AbilityMgr + * Function: LoadResidentProcess + * SubFunction: NA + * FunctionPoints: start resident process + * EnvConditions: NA + * CaseDescription: Start a resident process normally + */ +HWTEST_F(AmsAppLifeCycleModuleTest, LoadResidentProcess_001, TestSize.Level1) +{ + pid_t pid = 123; + sptr token = GetAbilityToken(); + std::string appName = "KeepAliveApp"; + std::string proc = "KeepAliveApplication"; + int uid = 2100; + + std::vector infos; + BundleInfo info; + info.name = proc; + info.uid = uid; + + ApplicationInfo appInfo; + appInfo.name = "KeepAliveApp"; + appInfo.bundleName = "KeepAliveApplication"; + appInfo.uid = 2100; + + info.applicationInfo = appInfo; + HapModuleInfo hapModuleInfo; + hapModuleInfo.name = "Module"; + HapModuleInfo hapModuleInfo1; + hapModuleInfo1.name = "Module1"; + info.hapModuleInfos.push_back(hapModuleInfo); + info.hapModuleInfos.push_back(hapModuleInfo1); + + infos.push_back(info); + + sptr mockAppScheduler = new MockAppScheduler(); + + auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, info); + EXPECT_FALSE(appRecord); + + StartAppProcess(pid); + serviceInner_->StartResidentProcess(infos, -1); + appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, info); + EXPECT_TRUE(appRecord); + pid_t newPid = appRecord->GetPriorityObject()->GetPid(); + EXPECT_TRUE(newPid == pid); +} + +/* + * Feature: AbilityMgr + * Function: LoadResidentProcess + * SubFunction: NA + * FunctionPoints: start resident process + * EnvConditions: NA + * CaseDescription: Start multiple resident processes + */ +HWTEST_F(AmsAppLifeCycleModuleTest, LoadResidentProcess_002, TestSize.Level1) +{ + std::vector infos; + pid_t pid = 123; + std::string appName = "KeepAliveApp"; + std::string proc = "KeepAliveApplication"; + int uid = 2100; + + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "KeepAliveApplication"; + BundleInfo info; + info.name = proc; + info.uid = uid; + info.isKeepAlive = true; + info.appId = "com.ohos.test.helloworld_code123"; + info.hapModuleInfos.push_back(hapModuleInfo); + + ApplicationInfo appInfo; + appInfo.name = appName; + appInfo.bundleName = proc; + appInfo.uid = 2100; + info.applicationInfo = appInfo; + + pid_t pid1 = 1234; + int appUid1 = 2101; + std::string appName1 = "KeepAliveApp1"; + std::string proc1 = "KeepAliveApplication1"; + + HapModuleInfo hapModuleInfo1; + hapModuleInfo1.moduleName = proc1; + + ApplicationInfo appInfo1; + appInfo1.name = appName1; + appInfo1.bundleName = proc1; + appInfo1.uid = appUid1; + + BundleInfo info1; + info1.name = proc1; + info1.uid = appUid1; + info1.isKeepAlive = true; + info1.appId = "com.ohos.test.helloworld_code123"; + info1.hapModuleInfos.push_back(hapModuleInfo1); + info1.applicationInfo = appInfo1; + + infos.push_back(info); + infos.push_back(info1); + + MockAppSpawnClient *mockClientPtr = new (std::nothrow) MockAppSpawnClient(); + EXPECT_TRUE(mockClientPtr); + EXPECT_CALL(*mockClientPtr, StartProcess(_, _)) + .Times(2) + .WillOnce(DoAll(SetArgReferee<1>(pid), Return(ERR_OK))) + .WillOnce(DoAll(SetArgReferee<1>(pid1), Return(ERR_OK))); + EXPECT_CALL(*mockAppStateCallbackStub_, OnAppStateChanged(_)).Times(2); + + serviceInner_->SetAppSpawnClient(std::unique_ptr(mockClientPtr)); + + // start process + serviceInner_->StartResidentProcess(infos, -1); + auto recordMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap(); + EXPECT_TRUE(recordMap.size() == 2); +} + +/* + * Feature: AbilityMgr + * Function: RestartResidentProcess + * SubFunction: NA + * FunctionPoints: Resident process exception recovery + * EnvConditions: NA + * CaseDescription: Start the resident process and let it die abnormally, then resume + */ +HWTEST_F(AmsAppLifeCycleModuleTest, RestartResidentProcess_001, TestSize.Level1) +{ + pid_t pid = 123; + pid_t pid1 = 1254; + std::string appName = "KeepAliveApp"; + std::string proc = "KeepAliveApplication"; + int uid = 2100; + + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "KeepAliveApplication"; + std::vector infos; + BundleInfo info; + info.name = proc; + info.uid = uid; + info.appId = "com.ohos.test.helloworld_code123"; + info.hapModuleInfos.push_back(hapModuleInfo); + + ApplicationInfo appInfo; + appInfo.name = "KeepAliveApp"; + appInfo.bundleName = "KeepAliveApplication"; + appInfo.uid = 2100; + info.applicationInfo = appInfo; + infos.push_back(info); + + MockAppSpawnClient *mockClientPtr = new (std::nothrow) MockAppSpawnClient(); + EXPECT_TRUE(mockClientPtr); + EXPECT_CALL(*mockClientPtr, StartProcess(_, _)).Times(2) + .WillOnce(DoAll(SetArgReferee<1>(pid), Return(ERR_OK))) + .WillOnce(DoAll(SetArgReferee<1>(pid1), Return(ERR_OK))); + + EXPECT_CALL(*mockAppStateCallbackStub_, OnAppStateChanged(_)).Times(2); + serviceInner_->SetAppSpawnClient(std::unique_ptr(mockClientPtr)); + sptr mockAppScheduler = new (std::nothrow) MockAppScheduler(); + sptr client = iface_cast(mockAppScheduler.GetRefPtr()); + + // start process + serviceInner_->StartResidentProcess(infos, -1); + auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, info); + EXPECT_TRUE(appRecord); + + EXPECT_TRUE(appRecord->GetUid() == uid); + EXPECT_TRUE(appRecord->GetProcessName() == proc); + EXPECT_TRUE(appRecord->IsKeepAliveApp()); + + serviceInner_->AttachApplication(pid, client); + + serviceInner_->OnRemoteDied(mockAppScheduler, false); + appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, info); + EXPECT_FALSE(appRecord); + + sleep(1); + appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, info); + EXPECT_TRUE(appRecord); +} + +/* + * Feature: AbilityMgr + * Function: RestartResidentProcess + * SubFunction: NA + * FunctionPoints: Resident process exception recovery + * EnvConditions: NA + * CaseDescription: Start an ordinary process, it should not be pulled up after abnormal death + */ +HWTEST_F(AmsAppLifeCycleModuleTest, RestartResidentProcess_002, TestSize.Level1) +{ + pid_t pid_0 = 1024; + + sptr token_0 = new (std::nothrow) MockAbilityToken(); + auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld103"); + auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld103"); + + sptr mockAppScheduler = new (std::nothrow) MockAppScheduler(); + TestProcessInfo testProcessInfo; + + testProcessInfo.pid = pid_0; + testProcessInfo.isStart = false; + auto appRunningRecord_0 = + StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo); + EXPECT_TRUE(appRunningRecord_0); + + sptr client = iface_cast(mockAppScheduler.GetRefPtr()); + serviceInner_->AttachApplication(pid_0, client); + serviceInner_->OnRemoteDied(mockAppScheduler, false); + + sleep(1); + auto recordMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap(); + EXPECT_TRUE(recordMap.empty()); +} + +/* + * Feature: AbilityMgr + * Function: RestartResidentProcess + * SubFunction: NA + * FunctionPoints: Resident process exception recovery + * EnvConditions: NA + * CaseDescription: 1.start a normal process + * 2.start a resident process + * 3.make both processes die + */ +HWTEST_F(AmsAppLifeCycleModuleTest, RestartResidentProcess_003, TestSize.Level1) +{ + pid_t pid_0 = 1024; + + sptr token_0 = new (std::nothrow) MockAbilityToken(); + auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld103"); + auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld103"); + + sptr mockAppScheduler = new (std::nothrow) MockAppScheduler(); + TestProcessInfo testProcessInfo; + + testProcessInfo.pid = pid_0; + testProcessInfo.isStart = false; + auto appRunningRecord_0 = + StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo); + EXPECT_TRUE(appRunningRecord_0); + + pid_t pid = 123; + std::string appName = "KeepAliveApp"; + std::string proc = "KeepAliveApplication"; + int uid = 2100; + + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "KeepAliveApplication"; + std::vector infos; + BundleInfo info; + info.name = proc; + info.uid = uid; + info.isKeepAlive = true; + info.appId = "com.ohos.test.helloworld_code123"; + info.hapModuleInfos.push_back(hapModuleInfo); + + ApplicationInfo appInfo; + appInfo.name = "KeepAliveApp"; + appInfo.bundleName = "KeepAliveApplication"; + appInfo.uid = 2100; + info.applicationInfo = appInfo; + infos.push_back(info); + + MockAppSpawnClient *mockClientPtr = new (std::nothrow) MockAppSpawnClient(); + EXPECT_TRUE(mockClientPtr); + EXPECT_CALL(*mockClientPtr, StartProcess(_, _)) + .Times(2) + .WillOnce(DoAll(SetArgReferee<1>(pid), Return(ERR_OK))) + .WillOnce(DoAll(SetArgReferee<1>(pid+1), Return(ERR_OK))); + EXPECT_CALL(*mockAppStateCallbackStub_, OnAppStateChanged(_)).Times(2); + + serviceInner_->SetAppSpawnClient(std::unique_ptr(mockClientPtr)); + + // start process + serviceInner_->StartResidentProcess(infos, -1); + auto residentRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, info); + EXPECT_TRUE(residentRecord); + + sptr client = iface_cast(mockAppScheduler.GetRefPtr()); + serviceInner_->AttachApplication(pid_0, client); + + sptr mockAppSchedulerResident = new (std::nothrow) MockAppScheduler(); + EXPECT_CALL(*mockAppSchedulerResident, ScheduleLaunchApplication(_, _)).Times(1); + sptr residentClient = iface_cast(mockAppSchedulerResident.GetRefPtr()); + serviceInner_->AttachApplication(pid, residentClient); + + serviceInner_->OnRemoteDied(mockAppScheduler, false); + serviceInner_->OnRemoteDied(mockAppSchedulerResident, false); + + auto recordMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap(); + EXPECT_TRUE(recordMap.empty()); + + sleep(1); + auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, info); + EXPECT_TRUE(appRecord); +} + +/* + * Feature: AbilityMgr + * Function: KillProcessWithAccount + * SubFunction: NA + * FunctionPoints: Test KillProcessWithAccount + * EnvConditions: NA + * CaseDescription: Specify user to kill process + */ +HWTEST_F(AmsAppLifeCycleModuleTest, KillProcessWithAccount_001, TestSize.Level1) +{ + const std::string STRING_BUNDLE_NAME = "com.ix.hiworld"; + constexpr int ACCOUNT_ID = 100; + auto instance = DelayedSingleton::GetInstance(); + EXPECT_NE(instance, nullptr); + + auto object = instance->GetSystemAbility(APP_MGR_SERVICE_ID); + EXPECT_NE(object, nullptr); + + auto proxy = iface_cast(object); + EXPECT_NE(proxy, nullptr); + + ErrCode result = proxy->GetAmsMgr()->KillProcessWithAccount(STRING_BUNDLE_NAME, ACCOUNT_ID); + EXPECT_EQ(result, ERR_OK); +} } // namespace AppExecFwk } // namespace OHOS \ No newline at end of file diff --git a/services/test/moduletest/common/ams/app_running_processes_info_module_test/BUILD.gn b/services/test/moduletest/common/ams/app_running_processes_info_module_test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..70a4c2d34421bc8eee3d0d3224123f5468c8c605 --- /dev/null +++ b/services/test/moduletest/common/ams/app_running_processes_info_module_test/BUILD.gn @@ -0,0 +1,37 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/aafwk/standard/aafwk.gni") + +module_output_path = "ability_runtime/mstappmgrservice" + +ohos_moduletest("AppRunningProcessesInfoModuleTest") { + module_out_path = module_output_path + + include_dirs = [ + "//base/hiviewdfx/hilog/interfaces/native/innerkits/include/hilog/", + "//base/hiviewdfx/hilog/interfaces/native/innerkits/include", + ] + sources = [ "app_running_processes_info_module_test.cpp" ] + + deps = [ "${services_path}/test/moduletest/common/ams:appmgr_mst_source" ] + + external_deps = [ "ipc:ipc_core" ] +} + +group("moduletest") { + testonly = true + + deps = [ ":AppRunningProcessesInfoModuleTest" ] +} diff --git a/services/test/moduletest/common/ams/app_running_processes_info_module_test/app_running_processes_info_module_test.cpp b/services/test/moduletest/common/ams/app_running_processes_info_module_test/app_running_processes_info_module_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5965bdb0e12f8889401b1824f42a7d8aaecc07cb --- /dev/null +++ b/services/test/moduletest/common/ams/app_running_processes_info_module_test/app_running_processes_info_module_test.cpp @@ -0,0 +1,426 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#define private public +#include "app_running_record.h" +#undef private +#include +#include +#include "iremote_object.h" +#include "app_record_id.h" +#include "app_scheduler_proxy.h" +#include "app_scheduler_host.h" +#define private public +#include "app_mgr_service_inner.h" +#undef private +#include "mock_application.h" +#include "ability_info.h" +#include "application_info.h" +#include "mock_bundle_manager.h" +#include "mock_ability_token.h" +#include "mock_app_scheduler.h" +#include "mock_app_spawn_client.h" + +using namespace testing::ext; +using OHOS::iface_cast; +using OHOS::IRemoteObject; +using OHOS::sptr; +using testing::_; +using testing::Invoke; +using testing::InvokeWithoutArgs; + +namespace OHOS { +namespace AppExecFwk { +class AppRunningProcessesInfoModuleTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); + +protected: + std::string GetTestAppName(const unsigned long num) const + { + if (num < appName_.size()) { + return appName_[num]; + } + return ""; + } + + std::string GetTestAbilityName(const unsigned long num) const + { + if (num < abilityName_.size()) { + return abilityName_[num]; + } + return ""; + } + + void CheckLaunchApplication(const sptr &mockApplication, const unsigned long index, + std::shared_ptr record, const std::string &testPoint) const + { + EXPECT_TRUE(record != nullptr) << "record is nullptr!"; + sptr client = iface_cast(mockApplication); + record->SetApplicationClient(client); + + std::string applicationName(GetTestAppName(index)); + ApplicationInfo info; + info.name = applicationName; + std::string processInfoName(GetTestAppName(index)); + pid_t pidId = 123; + ProcessInfo processInfo(processInfoName, pidId); + + AppLaunchData launchData; + launchData.SetApplicationInfo(info); + launchData.SetProcessInfo(processInfo); + + EXPECT_CALL(*mockApplication, ScheduleLaunchApplication(_, _)) + .Times(1) + .WillOnce(Invoke(mockApplication.GetRefPtr(), &MockApplication::LaunchApplication)); + Configuration config; + record->LaunchApplication(config); + mockApplication->Wait(); + + bool isEqual = mockApplication->CompareAppLaunchData(launchData); + EXPECT_EQ(isEqual, true) << testPoint << ",fail"; + } + + void CheckAppRunningRecording(const std::shared_ptr appInfo, + const std::shared_ptr abilityInfo, const std::shared_ptr record, const int index, + RecordQueryResult &result) const + { + EXPECT_TRUE(service_ != nullptr) << "init service fail!"; + EXPECT_TRUE(appInfo != nullptr) << "appInfo is nullptr!"; + EXPECT_TRUE(abilityInfo != nullptr) << "abilityInfo is nullptr!"; + EXPECT_TRUE(record != nullptr) << "record is nullptr!"; + auto abilityRecord = record->GetAbilityRunningRecord(GetTestAbilityName(index)); + int32_t id = record->GetRecordId(); + auto name = record->GetName(); + sptr token = abilityRecord->GetToken(); + auto abilityName = abilityRecord->GetName(); + std::string processName = GetTestAppName(index); + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + + auto appRecordFromServ = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, processName, appInfo->uid, bundleInfo); + EXPECT_TRUE(appRecordFromServ); + auto abilityRecordFromServ = appRecordFromServ->GetAbilityRunningRecord(GetTestAbilityName(index)); + int32_t idFromServ = appRecordFromServ->GetRecordId(); + sptr tokenFromServ = abilityRecordFromServ->GetToken(); + auto nameFromServ = appRecordFromServ->GetName(); + auto abilityNameFromServ = abilityRecordFromServ->GetName(); + EXPECT_TRUE(id == idFromServ) << "fail, RecordId is not equal!"; + EXPECT_TRUE(tokenFromServ.GetRefPtr() == token.GetRefPtr()) << "fail, token is not equal!"; + EXPECT_EQ(name, nameFromServ) << "fail, app record name is not equal!"; + EXPECT_EQ(abilityName, abilityNameFromServ) << "fail, app record name is not equal!"; + } + + std::unique_ptr service_ {nullptr}; + sptr mockBundleMgr_ {nullptr}; + + sptr GetMockToken() const + { + return mockToken_; + } + +private: + std::vector appName_ = { + "test_app_name1", + "test_app_name2", + "test_app_name3", + "test_app_name4", + "test_app_name5", + }; + std::vector abilityName_ = { + "test_ability_name1", + "test_ability_name2", + "test_ability_name3", + "test_ability_name4", + "test_ability_name5", + }; + sptr mockToken_ {nullptr}; +}; + +void AppRunningProcessesInfoModuleTest::SetUpTestCase() +{} + +void AppRunningProcessesInfoModuleTest::TearDownTestCase() +{} + +void AppRunningProcessesInfoModuleTest::SetUp() +{ + service_.reset(new (std::nothrow) AppMgrServiceInner()); + mockToken_ = new (std::nothrow) MockAbilityToken(); + mockBundleMgr_ = new (std::nothrow) BundleMgrService(); + service_->SetBundleManager(mockBundleMgr_); +} + +void AppRunningProcessesInfoModuleTest::TearDown() +{} + +/* + * Feature: AppMgrServiceInner + * Function: GetRunningProcessInfoByToken + * SubFunction: NA + * FunctionPoints: get running process info by token. + * EnvConditions: NA + * CaseDescription: creat apprunningrecord, set record state, mock object, call query function. + */ +HWTEST_F(AppRunningProcessesInfoModuleTest, ApplicationStart_001, TestSize.Level1) +{ + // init AppRunningRecord + unsigned long index = 0L; + int uid = 100; + auto abilityInfo = std::make_shared(); + abilityInfo->name = GetTestAbilityName(index); + abilityInfo->applicationInfo.uid = uid; + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(index); + appInfo->uid = uid; + std::string processName = GetTestAppName(index); + RecordQueryResult result; + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + auto record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, nullptr); + record->SetUid(uid); + EXPECT_TRUE(record != nullptr) << ",create apprunningrecord fail!"; + + // check apprunningrecord + CheckAppRunningRecording(appInfo, abilityInfo, record, index, result); + + // LaunchApplication + sptr mockApplication(new MockApplication()); + std::string testPoint = "ApplicationStart_001"; + CheckLaunchApplication(mockApplication, index, record, testPoint); + + EXPECT_CALL(*mockApplication, ScheduleForegroundApplication()) + .Times(1) + .WillOnce(InvokeWithoutArgs(mockApplication.GetRefPtr(), &MockApplication::Post)); + // application enter in foreground and check the result + record->ScheduleForegroundRunning(); + mockApplication->Wait(); + + // update application state and check the state + record->SetState(ApplicationState::APP_STATE_FOREGROUND); + auto newRecord = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, processName, appInfo->uid, bundleInfo); + EXPECT_TRUE(newRecord); + newRecord->SetUid(uid); + auto stateFromRec = newRecord->GetState(); + EXPECT_EQ(stateFromRec, ApplicationState::APP_STATE_FOREGROUND); + + RunningProcessInfo info; + service_->GetRunningProcessInfoByToken(GetMockToken(), info); + EXPECT_TRUE(info.processName_ == processName); + EXPECT_TRUE(info.uid_ == uid); +} + +/* + * Feature: AppMgrServiceInner + * Function: GetAllRunningProcesses + * SubFunction: NA + * FunctionPoints: get running process info by token. + * EnvConditions: NA + * CaseDescription: creat apprunningrecord, set record state, mock object, call query function. + */ +HWTEST_F(AppRunningProcessesInfoModuleTest, ApplicationStart_002, TestSize.Level1) +{ + // init AppRunningRecord + unsigned long index = 0L; + int uid = 0; + auto abilityInfo = std::make_shared(); + abilityInfo->name = GetTestAbilityName(index); + abilityInfo->applicationInfo.uid = uid; + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(index); + appInfo->uid = uid; + std::string processName = GetTestAppName(index); + RecordQueryResult result; + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + auto record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, nullptr); + record->SetUid(uid); + EXPECT_TRUE(record != nullptr) << ",create apprunningrecord fail!"; + + // check apprunningrecord + CheckAppRunningRecording(appInfo, abilityInfo, record, index, result); + + // LaunchApplication + sptr mockApplication(new MockApplication()); + std::string testPoint = "ApplicationStart_001"; + CheckLaunchApplication(mockApplication, index, record, testPoint); + + EXPECT_CALL(*mockApplication, ScheduleForegroundApplication()) + .Times(1) + .WillOnce(InvokeWithoutArgs(mockApplication.GetRefPtr(), &MockApplication::Post)); + // application enter in foreground and check the result + record->ScheduleForegroundRunning(); + mockApplication->Wait(); + + // update application state and check the state + record->SetState(ApplicationState::APP_STATE_FOREGROUND); + auto newRecord = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, processName, appInfo->uid, bundleInfo); + EXPECT_TRUE(newRecord); + newRecord->SetUid(uid); + auto stateFromRec = newRecord->GetState(); + EXPECT_EQ(stateFromRec, ApplicationState::APP_STATE_FOREGROUND); + + std::vector info; + size_t infoCount {0}; + auto res = service_->GetAllRunningProcesses(info); + EXPECT_TRUE (res == ERR_OK); + EXPECT_TRUE(info.size() == infoCount); +} + +/* + * Feature: AppMgrServiceInner + * Function: GetAllRunningProcesses + * SubFunction: NA + * FunctionPoints: get running process info by token. + * EnvConditions: NA + * CaseDescription: creat two apprunningrecords, set record state, mock object, call query function. + */ +HWTEST_F(AppRunningProcessesInfoModuleTest, ApplicationStart_003, TestSize.Level1) +{ + // init AppRunningRecord + unsigned long index = 0L; + int uid = 0; + auto abilityInfo = std::make_shared(); + abilityInfo->name = GetTestAbilityName(index); + abilityInfo->applicationInfo.uid = uid; + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(index); + appInfo->uid = uid; + std::string processName = GetTestAppName(index); + RecordQueryResult result; + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + auto record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, nullptr); + record->SetUid(uid); + EXPECT_TRUE(record != nullptr) << ",create apprunningrecord fail!"; + + // check apprunningrecord + CheckAppRunningRecording(appInfo, abilityInfo, record, index, result); + + // LaunchApplication + sptr mockApplication(new MockApplication()); + std::string testPoint = "ApplicationStart_001"; + CheckLaunchApplication(mockApplication, index, record, testPoint); + + EXPECT_CALL(*mockApplication, ScheduleForegroundApplication()) + .Times(1) + .WillOnce(InvokeWithoutArgs(mockApplication.GetRefPtr(), &MockApplication::Post)); + // application enter in foreground and check the result + record->ScheduleForegroundRunning(); + mockApplication->Wait(); + + // update application state and check the state + record->SetState(ApplicationState::APP_STATE_FOREGROUND); + auto newRecord = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, processName, appInfo->uid, bundleInfo); + EXPECT_TRUE(newRecord); + newRecord->SetUid(uid); + auto stateFromRec = newRecord->GetState(); + EXPECT_EQ(stateFromRec, ApplicationState::APP_STATE_FOREGROUND); + + index = 1L; + auto abilityInfo2 = std::make_shared(); + abilityInfo2->name = GetTestAbilityName(index); + abilityInfo2->applicationInfo.uid = uid; + auto appInfo2 = std::make_shared(); + appInfo2->name = GetTestAppName(index); + appInfo2->uid = uid; + std::string processName2 = GetTestAppName(index); + BundleInfo bundleInfo2; + HapModuleInfo hapModuleInfo2; + EXPECT_TRUE(service_->GetBundleAndHapInfo(*abilityInfo2, appInfo2, bundleInfo2, hapModuleInfo2)); + sptr mockToken = new (std::nothrow) MockAbilityToken(); + auto record2 = service_->CreateAppRunningRecord( + mockToken, nullptr, appInfo2, abilityInfo2, processName2, bundleInfo2, hapModuleInfo2, nullptr); + record2->SetUid(uid); + EXPECT_TRUE(record != nullptr) << ",create apprunningrecord fail!"; + + std::vector info; + size_t infoCount {0}; + auto res = service_->GetAllRunningProcesses(info); + EXPECT_TRUE (res == ERR_OK); + EXPECT_TRUE(info.size() == infoCount); +} + +/* + * Feature: AppMgrServiceInner + * Function: GetRunningProcessInfoByToken + * SubFunction: NA + * FunctionPoints: get running process info by token. + * EnvConditions: NA + * CaseDescription: creat apprunningrecords, set record state, mock object, call query function. + */ +HWTEST_F(AppRunningProcessesInfoModuleTest, ApplicationStart_004, TestSize.Level1) +{ + // init AppRunningRecord + unsigned long index = 0L; + int uid = 0; + auto abilityInfo = std::make_shared(); + abilityInfo->name = GetTestAbilityName(index); + abilityInfo->applicationInfo.uid = uid; + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(index); + appInfo->uid = uid; + std::string processName = GetTestAppName(index); + RecordQueryResult result; + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + auto record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, nullptr); + record->SetUid(uid); + EXPECT_TRUE(record != nullptr) << ",create apprunningrecord fail!"; + + CheckAppRunningRecording(appInfo, abilityInfo, record, index, result); + + sptr mockApplication(new MockApplication()); + std::string testPoint = "ApplicationStart_001"; + CheckLaunchApplication(mockApplication, index, record, testPoint); + + EXPECT_CALL(*mockApplication, ScheduleForegroundApplication()) + .Times(1) + .WillOnce(InvokeWithoutArgs(mockApplication.GetRefPtr(), &MockApplication::Post)); + // application enter in foreground and check the result + record->ScheduleForegroundRunning(); + mockApplication->Wait(); + + // update application state and check the state + record->SetState(ApplicationState::APP_STATE_BACKGROUND); + auto newRecord = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, processName, appInfo->uid, bundleInfo); + EXPECT_TRUE(newRecord); + newRecord->SetUid(uid); + auto stateFromRec = newRecord->GetState(); + EXPECT_EQ(stateFromRec, ApplicationState::APP_STATE_BACKGROUND); + + RunningProcessInfo info; + service_->appRunningManager_->GetRunningProcessInfoByToken(GetMockToken(), info); + EXPECT_TRUE(info.processName_ == processName); + EXPECT_TRUE(info.uid_ == uid); +} +} // namespace AppExecFwk +} // namespace OHOS \ No newline at end of file diff --git a/services/test/moduletest/common/ams/app_running_record_test/ams_app_running_record_module_test.cpp b/services/test/moduletest/common/ams/app_running_record_test/ams_app_running_record_module_test.cpp index c4c5d25242a281e7f7be044b782d66693a7b14d6..887ebe7cab49a82914f2b8b7d2b0b9b9acfd0382 100644 --- a/services/test/moduletest/common/ams/app_running_record_test/ams_app_running_record_module_test.cpp +++ b/services/test/moduletest/common/ams/app_running_record_test/ams_app_running_record_module_test.cpp @@ -513,5 +513,147 @@ HWTEST_F(AmsAppRunningRecordModuleTest, ApplicationStatusChange_006, TestSize.Le auto stateFromRec = record->GetState(); EXPECT_EQ(stateFromRec, ApplicationState::APP_STATE_TERMINATED); } + +/* + * Feature: StartSpecifiedAbility + * Function: AppManagerService + * SubFunction: ApprunningRecord + * FunctionPoints: not set Specified flag,start ability + * EnvConditions: system running normally + * CaseDescription:When the process exists and the moduleRecord exists, + * calling StartSpecifiedAbility will call the ScheduleAcceptWant method once + */ +HWTEST_F(AmsAppRunningRecordModuleTest, StartSpecifiedAbility_001, TestSize.Level2) +{ + EXPECT_TRUE(service_ != nullptr) << "init service fail!"; + + unsigned long index = 0; + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(index); + appInfo->bundleName = GetTestAppName(index); + appInfo->uid = 10003; + auto abilityInfo = std::make_shared(); + abilityInfo->name = GetTestAbilityName(index); + abilityInfo->applicationInfo = *appInfo; + std::string processName = GetTestAppName(index); + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + EXPECT_TRUE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + auto record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, nullptr); + EXPECT_TRUE(record != nullptr) << "create apprunningrecord fail!"; + + // LaunchApplication + sptr mockApplication(new MockApplication()); + std::string testPoint = "StartSpecifiedAbility_001"; + CheckLaunchApplication(mockApplication, index, record, testPoint); + + EXPECT_CALL(*mockApplication, ScheduleAcceptWant(_, _)) + .Times(1) + .WillOnce(InvokeWithoutArgs(mockApplication.GetRefPtr(), &MockApplication::Post)); + + Want want; + want.SetElementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + service_->StartSpecifiedAbility(want, *abilityInfo); + + mockApplication->Wait(); + EXPECT_TRUE(record->IsStartSpecifiedAbility()); +} + +/* + * Feature: StartSpecifiedAbility + * Function: AppManagerService + * SubFunction: ApprunningRecord + * FunctionPoints: not set Specified flag,start ability + * EnvConditions: system running normally + * CaseDescription:When the process exists and the moduleRecord does not exist, + * calling StartSpecifiedAbility will call the ScheduleAbilityStage method once + */ +HWTEST_F(AmsAppRunningRecordModuleTest, StartSpecifiedAbility_002, TestSize.Level2) +{ + EXPECT_TRUE(service_ != nullptr) << "init service fail!"; + + unsigned long index = 0; + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(index); + appInfo->bundleName = GetTestAppName(index); + appInfo->uid = 10003; + auto abilityInfo = std::make_shared(); + abilityInfo->name = GetTestAbilityName(index); + abilityInfo->applicationInfo = *appInfo; + std::string processName = GetTestAppName(index); + BundleInfo bundleInfo; + HapModuleInfo hapModuleInfo; + hapModuleInfo.moduleName = "moduleName1"; + EXPECT_TRUE(service_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo)); + auto record = service_->CreateAppRunningRecord( + GetMockToken(), nullptr, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, nullptr); + EXPECT_TRUE(record != nullptr) << "create apprunningrecord fail!"; + + auto abilityInfo1 = std::make_shared(); + abilityInfo1->name = GetTestAbilityName(index + 1); + abilityInfo1->applicationInfo = *appInfo; + + // LaunchApplication + sptr mockApplication(new MockApplication()); + std::string testPoint = "StartSpecifiedAbility_001"; + CheckLaunchApplication(mockApplication, index, record, testPoint); + + EXPECT_CALL(*mockApplication, ScheduleAbilityStage(_)) + .Times(1) + .WillOnce(InvokeWithoutArgs(mockApplication.GetRefPtr(), &MockApplication::Post)); + + Want want; + want.SetElementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + service_->StartSpecifiedAbility(want, *abilityInfo1); + + mockApplication->Wait(); + EXPECT_TRUE(record->IsStartSpecifiedAbility()); +} + +/* + * Feature: StartSpecifiedAbility + * Function: AppManagerService + * SubFunction: ApprunningRecord + * FunctionPoints: not set Specified flag,start ability + * EnvConditions: system running normally + * CaseDescription:When the process does not exist, call StartSpecifiedAbility, ScheduleAbilityStage and + * ScheduleAcceptWant methods will not be called, and there is a module information + */ +HWTEST_F(AmsAppRunningRecordModuleTest, StartSpecifiedAbility_003, TestSize.Level2) +{ + EXPECT_TRUE(service_ != nullptr) << "init service fail!"; + + unsigned long index = 0; + auto appInfo = std::make_shared(); + appInfo->name = GetTestAppName(index); + appInfo->bundleName = GetTestAppName(index); + appInfo->uid = 10003; + appInfo->process = GetTestAppName(index); + auto abilityInfo = std::make_shared(); + abilityInfo->name = GetTestAbilityName(index); + abilityInfo->applicationInfo = *appInfo; + + // LaunchApplication + sptr mockApplication(new MockApplication()); + + EXPECT_CALL(*mockApplication, ScheduleAcceptWant(_, _)) + .Times(0) + .WillOnce(InvokeWithoutArgs(mockApplication.GetRefPtr(), &MockApplication::Post)); + + EXPECT_CALL(*mockApplication, ScheduleAbilityStage(_)) + .Times(0) + .WillOnce(InvokeWithoutArgs(mockApplication.GetRefPtr(), &MockApplication::Post)); + + Want want; + want.SetElementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + service_->StartSpecifiedAbility(want, *abilityInfo); + mockApplication->Wait(); + + BundleInfo bundleInfo; + auto appRecord = service_->appRunningManager_->CheckAppRunningRecordIsExist( + appInfo->name, GetTestAppName(index), appInfo->uid, bundleInfo); + EXPECT_TRUE(appRecord->GetModules().size() == 1); +} } // namespace AppExecFwk } // namespace OHOS \ No newline at end of file diff --git a/services/test/moduletest/common/ams/specified_ability_service_test/BUILD.gn b/services/test/moduletest/common/ams/specified_ability_service_test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..9d27752489fffdef10601ee25aa634fd427d627e --- /dev/null +++ b/services/test/moduletest/common/ams/specified_ability_service_test/BUILD.gn @@ -0,0 +1,95 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/aafwk/standard/aafwk.gni") + +module_output_path = "ability_runtime/mstabilitymgrservice" + +ohos_moduletest("specified_ability_service_test") { + module_out_path = module_output_path + + include_dirs = [ + "${services_path}/test/mock/include", + "//third_party/jsoncpp/include", + "//foundation/aafwk/standard/frameworks/kits/ability/native/include/distributed_ability_runtime", + "//foundation/aafwk/standard/interfaces/innerkits/dataobs_manager/include", + "//base/hiviewdfx/hicollie/interfaces/native/innerkits/include/xcollie", + ] + + sources = [ "specified_ability_service_test.cpp" ] + sources += [ + "//foundation/aafwk/standard/services/abilitymgr/src/ability_manager_proxy.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_manager_service.cpp", + "//foundation/aafwk/standard/services/abilitymgr/test/mock/libs/sa_mgr/src/sa_mgr_client_mock.cpp", + "//foundation/aafwk/standard/services/common/src/permission_verification.cpp", + "//foundation/aafwk/standard/services/test/mock/src/mock_app_mgr_client.cpp", + "//foundation/aafwk/standard/services/test/mock/src/mock_bundle_mgr.cpp", + "//foundation/distributedhardware/devicemanager/test/unittest/mock/parameter.cpp", + ] + + configs = [ + "${services_path}/test:aafwk_module_test_config", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager_public_config", + "//foundation/aafwk/standard/services/abilitymgr/test/mock/libs/sa_mgr:sa_mgr_mock_config", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base_sdk_config", + "${aafwk_path}/interfaces/innerkits/app_manager:appmgr_sdk_config", + ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + deps = [ + "${aafwk_path}/interfaces/innerkits/app_manager:app_manager", + "${innerkits_path}/uri_permission:uri_permission_mgr", + "${innerkits_path}/want:want", + "//base/account/os_account/frameworks/osaccount/native:os_account_innerkits", + "//base/global/i18n_standard/frameworks/intl:intl_util", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//foundation/aafwk/standard/frameworks/kits/ability/native:dummy_classes", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", + "//foundation/ace/ace_engine/interfaces/innerkits/ui_service_manager:ui_service_mgr", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_core:appexecfwk_core", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler:libeventhandler", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//foundation/distributedschedule/safwk/interfaces/innerkits/safwk:system_ability_fwk", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy:samgr_proxy", + "//foundation/multimedia/image_standard/interfaces/innerkits:image_native", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//third_party/jsoncpp:jsoncpp", + "//third_party/libpng:libpng", + "//utils/native/base:utils", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "bytrace_standard:bytrace_core", + "ces_standard:cesfwk_core", + "ces_standard:cesfwk_innerkits", + "dsoftbus_standard:softbus_client", + "hicollie_native:libhicollie", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "native_appdatamgr:native_appdatafwk", + "native_appdatamgr:native_dataability", + "native_appdatamgr:native_rdb", + ] +} + +group("moduletest") { + testonly = true + + deps = [ ":specified_ability_service_test" ] +} diff --git a/services/test/moduletest/common/ams/specified_ability_service_test/specified_ability_service_test.cpp b/services/test/moduletest/common/ams/specified_ability_service_test/specified_ability_service_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..49be07b7022484dd8e78d475ccc9873ff5ede4d2 --- /dev/null +++ b/services/test/moduletest/common/ams/specified_ability_service_test/specified_ability_service_test.cpp @@ -0,0 +1,251 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +#include +#include + +#define private public +#define protected public +#include "sa_mgr_client.h" +#include "mock_ability_connect_callback_stub.h" +#include "mock_ability_scheduler.h" +#include "mock_app_mgr_client.h" +#include "mock_bundle_mgr.h" +#include "ability_record_info.h" +#include "ability_manager_errors.h" +#include "sa_mgr_client.h" +#include "system_ability_definition.h" +#include "ability_manager_service.h" +#include "ability_connect_callback_proxy.h" +#include "ability_config.h" +#include "pending_want_manager.h" +#include "pending_want_record.h" +#undef private +#undef protected +#include "wants_info.h" +#include "want_receiver_stub.h" +#include "want_sender_stub.h" +#include "os_account_manager.h" + +using namespace std::placeholders; +using namespace testing::ext; +using namespace OHOS::AppExecFwk; +using OHOS::iface_cast; +using OHOS::IRemoteObject; +using OHOS::sptr; +using testing::_; +using testing::Invoke; +using testing::Return; + +namespace OHOS { +namespace AAFwk { +class SpecifiedAbilityServiceTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + Want CreateWant(const std::string &entity); + AbilityInfo CreateAbilityInfo(const std::string &name, const std::string &appName, const std::string &bundleName); + ApplicationInfo CreateAppInfo(const std::string &appName, const std::string &name); + bool MockAppClent(); + void WaitAMS(); + + inline static std::shared_ptr mockAppMgrClient_ {nullptr}; + inline static std::shared_ptr abilityMgrServ_ {nullptr}; + sptr scheduler_ {nullptr}; + inline static bool doOnce_ = false; // In order for mock to execute once +}; + +Want SpecifiedAbilityServiceTest::CreateWant(const std::string &entity) +{ + Want want; + if (!entity.empty()) { + want.AddEntity(entity); + } + return want; +} + +AbilityInfo SpecifiedAbilityServiceTest::CreateAbilityInfo( + const std::string &name, const std::string &appName, const std::string &bundleName) +{ + AbilityInfo abilityInfo; + abilityInfo.visible = true; + abilityInfo.name = name; + abilityInfo.applicationName = appName; + abilityInfo.bundleName = bundleName; + abilityInfo.applicationInfo.bundleName = bundleName; + abilityInfo.applicationName = "hiMusic"; + abilityInfo.applicationInfo.name = "hiMusic"; + abilityInfo.type = AbilityType::PAGE; + abilityInfo.applicationInfo.isLauncherApp = false; + + return abilityInfo; +} + +ApplicationInfo SpecifiedAbilityServiceTest::CreateAppInfo(const std::string &appName, const std::string &bundleName) +{ + ApplicationInfo appInfo; + appInfo.name = appName; + appInfo.bundleName = bundleName; + + return appInfo; +} + +bool SpecifiedAbilityServiceTest::MockAppClent() +{ + if (!mockAppMgrClient_) { + GTEST_LOG_(INFO) << "MockAppClent::1"; + return false; + } + + if (!abilityMgrServ_->appScheduler_) { + GTEST_LOG_(INFO) << "MockAppClent::2"; + return false; + } + + abilityMgrServ_->appScheduler_->appMgrClient_.reset(mockAppMgrClient_.get()); + return true; +} + +void SpecifiedAbilityServiceTest::WaitAMS() +{ + const uint32_t maxRetryCount = 1000; + const uint32_t sleepTime = 1000; + uint32_t count = 0; + if (!abilityMgrServ_) { + return; + } + auto handler = abilityMgrServ_->GetEventHandler(); + if (!handler) { + return; + } + std::atomic taskCalled(false); + auto f = [&taskCalled]() { taskCalled.store(true); }; + if (handler->PostTask(f)) { + while (!taskCalled.load()) { + ++count; + if (count >= maxRetryCount) { + break; + } + usleep(sleepTime); + } + } +} + +void SpecifiedAbilityServiceTest::SetUpTestCase(void) +{ + OHOS::DelayedSingleton::GetInstance()->RegisterSystemAbility( + OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new (std::nothrow) BundleMgrService()); + abilityMgrServ_ = OHOS::DelayedSingleton::GetInstance(); + mockAppMgrClient_ = std::make_shared(); +} + +void SpecifiedAbilityServiceTest::TearDownTestCase(void) +{ + abilityMgrServ_->OnStop(); + mockAppMgrClient_.reset(); +} + +void SpecifiedAbilityServiceTest::SetUp(void) +{ + scheduler_ = new MockAbilityScheduler(); + if (!doOnce_) { + doOnce_ = true; + MockAppClent(); + } + WaitAMS(); +} + +void SpecifiedAbilityServiceTest::TearDown(void) +{} + +/** + * @tc.name: OnAcceptWantResponse_001 + * @tc.desc: test OnAcceptWantResponse + * @tc.type: FUNC + * @tc.require: AR000GJUND + */ +HWTEST_F(SpecifiedAbilityServiceTest, OnAcceptWantResponse_001, TestSize.Level1) +{ + std::string abilityName = "MusicAbility"; + std::string appName = "test_app"; + std::string bundleName = "com.ix.hiMusic"; + + AbilityRequest abilityRequest; + abilityRequest.want = CreateWant(""); + abilityRequest.abilityInfo = CreateAbilityInfo(abilityName + "1", appName, bundleName); + abilityRequest.appInfo = CreateAppInfo(appName, bundleName); + + std::shared_ptr abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest); + abilityRecord->SetAbilityState(OHOS::AAFwk::AbilityState::FOREGROUND_NEW); + + abilityMgrServ_->InitMissionListManager(11, true); + Want want; + want.SetElementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + EXPECT_TRUE(abilityMgrServ_->currentMissionListManager_); + abilityMgrServ_->currentMissionListManager_->EnqueueWaittingAbility(abilityRequest); + abilityMgrServ_->OnAcceptWantResponse(want, "flag"); + + EXPECT_EQ(false, abilityRecord->IsNewWant()); +} + +/** + * @tc.name: OnAcceptWantResponse_002 + * @tc.desc: test OnAcceptWantResponse + * @tc.type: FUNC + * @tc.require: AR000GJUND + */ +HWTEST_F(SpecifiedAbilityServiceTest, OnAcceptWantResponse_002, TestSize.Level1) +{ + std::string abilityName = "MusicAbility"; + std::string appName = "test_app"; + std::string bundleName = "com.ix.hiMusic"; + + AbilityRequest abilityRequest; + abilityRequest.want = CreateWant(""); + abilityRequest.abilityInfo = CreateAbilityInfo(abilityName + "1", appName, bundleName); + abilityRequest.appInfo = CreateAppInfo(appName, bundleName); + + std::shared_ptr abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest); + abilityRecord->SetAbilityState(OHOS::AAFwk::AbilityState::FOREGROUND_NEW); + abilityRecord->SetSpecifiedFlag("flag"); + + std::shared_ptr missionRecord = std::make_shared(bundleName); + missionRecord->AddAbilityRecordToTop(abilityRecord); + abilityRecord->SetMissionRecord(missionRecord); + + abilityRequest.callerToken = abilityRecord->GetToken(); + auto manager = abilityMgrServ_->currentMissionListManager_; + manager->Init(); + auto mission = std::make_shared(11, abilityRecord, "missionName"); + manager->defaultStandardList_->AddMissionToTop(mission); + + abilityMgrServ_->InitMissionListManager(11, true); + Want want; + want.SetElementName("DemoDeviceId", "DemoBundleName", "DemoAbilityName"); + EXPECT_TRUE(abilityMgrServ_->currentMissionListManager_); + abilityMgrServ_->currentMissionListManager_->EnqueueWaittingAbility(abilityRequest); + abilityMgrServ_->OnAcceptWantResponse(want, "flag"); + + EXPECT_EQ(true, abilityRecord->IsNewWant()); +} +} // namespace AAFwk +} // namespace OHOS diff --git a/services/test/moduletest/on_new_want_module_test/BUILD.gn b/services/test/moduletest/on_new_want_module_test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..4293e83b35f91e1955c6bfd0518beaa9d127f72a --- /dev/null +++ b/services/test/moduletest/on_new_want_module_test/BUILD.gn @@ -0,0 +1,94 @@ +# Copyright (c) 2021-2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/aafwk/standard/aafwk.gni") + +module_output_path = "ability_runtime/mstabilitymgrservice" + +ohos_moduletest("on_new_want_module_test") { + module_out_path = module_output_path + + include_dirs = [ + "${services_path}/test/mock/include", + "//third_party/jsoncpp/include", + "//foundation/aafwk/standard/frameworks/kits/ability/native/include/distributed_ability_runtime", + "//foundation/aafwk/standard/interfaces/innerkits/dataobs_manager/include", + "//base/hiviewdfx/hicollie/interfaces/native/innerkits/include/xcollie", + ] + + sources = [ "on_new_want_module_test.cpp" ] + sources += [ + "//foundation/aafwk/standard/services/abilitymgr/src/ability_manager_service.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_list.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_list_manager.cpp", + "//foundation/aafwk/standard/services/common/src/permission_verification.cpp", + "//foundation/distributedhardware/devicemanager/test/unittest/mock/parameter.cpp", + ] + + configs = [ + "${services_path}/test:aafwk_module_test_config", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager_public_config", + "//foundation/aafwk/standard/services/abilitymgr/test/mock/libs/sa_mgr:sa_mgr_mock_config", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base_sdk_config", + "${aafwk_path}/interfaces/innerkits/app_manager:appmgr_sdk_config", + ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + deps = [ + "${aafwk_path}/interfaces/innerkits/app_manager:app_manager", + "${innerkits_path}/uri_permission:uri_permission_mgr", + "${innerkits_path}/want:want", + "//base/account/os_account/frameworks/osaccount/native:os_account_innerkits", + "//base/global/i18n_standard/frameworks/intl:intl_util", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//foundation/aafwk/standard/frameworks/kits/ability/native:dummy_classes", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", + "//foundation/ace/ace_engine/interfaces/innerkits/ui_service_manager:ui_service_mgr", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_core:appexecfwk_core", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler:libeventhandler", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//foundation/distributedschedule/safwk/interfaces/innerkits/safwk:system_ability_fwk", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy:samgr_proxy", + "//foundation/multimedia/image_standard/interfaces/innerkits:image_native", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//third_party/jsoncpp:jsoncpp", + "//third_party/libpng:libpng", + "//utils/native/base:utils", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "bytrace_standard:bytrace_core", + "ces_standard:cesfwk_core", + "ces_standard:cesfwk_innerkits", + "dsoftbus_standard:softbus_client", + "hicollie_native:libhicollie", + "hisysevent_native:libhisysevent", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "native_appdatamgr:native_appdatafwk", + "native_appdatamgr:native_dataability", + "native_appdatamgr:native_rdb", + ] +} + +group("moduletest") { + testonly = true + + deps = [ ":on_new_want_module_test" ] +} diff --git a/services/test/moduletest/on_new_want_module_test/on_new_want_module_test.cpp b/services/test/moduletest/on_new_want_module_test/on_new_want_module_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a46b32fe1a1a3c0acc2ea76e9e6ee8033f230eb5 --- /dev/null +++ b/services/test/moduletest/on_new_want_module_test/on_new_want_module_test.cpp @@ -0,0 +1,181 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include +#include + +#define private public +#include "ability_manager_service.h" +#include "mission_list_manager.h" +#undef private +#include "ability_util.h" +#include "mission_list.h" + +using namespace testing::ext; +using namespace OHOS::AppExecFwk; +using OHOS::iface_cast; +using OHOS::sptr; +using testing::_; +using testing::Invoke; +using testing::Return; + +namespace OHOS { +namespace AAFwk { +class OnNewWantModuleTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); + AbilityInfo CreateAbilityInfo( + const std::string &name, const std::string &appName, const std::string &bundleName, bool mode); + ApplicationInfo CreateAppInfo(const std::string &appName, const std::string &name); + inline static std::shared_ptr abilityMgrServ_ {nullptr}; +}; + +AbilityInfo OnNewWantModuleTest::CreateAbilityInfo( + const std::string &name, const std::string &appName, const std::string &bundleName, bool mode) +{ + AbilityInfo abilityInfo; + abilityInfo.visible = true; + abilityInfo.name = name; + abilityInfo.applicationName = appName; + abilityInfo.bundleName = bundleName; + abilityInfo.applicationInfo.bundleName = bundleName; + abilityInfo.applicationName = "com.ix.hiMusic"; + abilityInfo.applicationInfo.name = "com.ix.hiMusic"; + abilityInfo.type = AbilityType::PAGE; + abilityInfo.applicationInfo.isLauncherApp = false; + + if (mode) { + abilityInfo.launchMode = LaunchMode::SINGLETON; + } else { + abilityInfo.launchMode = LaunchMode::STANDARD; + } + + return abilityInfo; +} + +ApplicationInfo OnNewWantModuleTest::CreateAppInfo(const std::string &appName, const std::string &bundleName) +{ + ApplicationInfo appInfo; + appInfo.name = appName; + appInfo.bundleName = bundleName; + + return appInfo; +} + +void OnNewWantModuleTest::SetUpTestCase() +{ + abilityMgrServ_ = OHOS::DelayedSingleton::GetInstance(); +} + +void OnNewWantModuleTest::TearDownTestCase() +{ + abilityMgrServ_->OnStop(); +} + +void OnNewWantModuleTest::SetUp() +{} + +void OnNewWantModuleTest::TearDown() +{} + +/* + * Feature: MissionListManager + * Function: Startability + * SubFunction: NA + * FunctionPoints: NA + * CaseDescription:Start the singleton ability multiple times, and the ability is marked with newwant + */ +HWTEST_F(OnNewWantModuleTest, Startability_001, TestSize.Level1) +{ + int userId = 100; + auto missionListManager = std::make_shared(userId); + EXPECT_TRUE(missionListManager); + + std::string abilityName = "MusicAbility"; + std::string appName = "test_app"; + std::string bundleName = "com.ix.hiMusic"; + + Want want; + ElementName element("device", "com.ix.hiMusic", "MusicAbility"); + want.SetElement(element); + + AbilityRequest abilityRequest; + abilityRequest.want = want; + abilityRequest.abilityInfo = CreateAbilityInfo(abilityName, appName, bundleName, true); + abilityRequest.appInfo = CreateAppInfo(appName, bundleName); + abilityRequest.compatibleVersion = 8; + + std::shared_ptr abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest); + abilityRecord->SetAbilityState(OHOS::AAFwk::AbilityState::FOREGROUND_NEW); + + std::string missionName = + AbilityUtil::ConvertBundleNameSingleton(abilityRequest.abilityInfo.bundleName, abilityRequest.abilityInfo.name); + std::shared_ptr mission = std::make_shared(1, abilityRecord, missionName); + + missionListManager->Init(); + missionListManager->launcherList_->AddMissionToTop(mission); + missionListManager->StartAbility(abilityRequest); + + EXPECT_TRUE(abilityRecord->IsNewWant()); +} + +/* + * Feature: MissionListManager + * Function: Startability + * SubFunction: NA + * FunctionPoints: NA + * CaseDescription:Start standard ability multiple times, ability has no newwant mark + */ +HWTEST_F(OnNewWantModuleTest, Startability_002, TestSize.Level1) +{ + int userId = 100; + auto missionListManager = std::make_shared(userId); + EXPECT_TRUE(missionListManager); + + std::string abilityName = "MusicAbility"; + std::string appName = "test_app"; + std::string bundleName = "com.ix.hiMusic"; + + Want want; + ElementName element("device", "com.ix.hiMusic", "MusicAbility"); + want.SetElement(element); + + AbilityRequest abilityRequest; + abilityRequest.want = want; + abilityRequest.abilityInfo = CreateAbilityInfo(abilityName, appName, bundleName, false); + abilityRequest.appInfo = CreateAppInfo(appName, bundleName); + abilityRequest.compatibleVersion = 8; + + std::shared_ptr abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest); + abilityRecord->SetAbilityState(OHOS::AAFwk::AbilityState::FOREGROUND_NEW); + + std::string missionName = + AbilityUtil::ConvertBundleNameSingleton(abilityRequest.abilityInfo.bundleName, abilityRequest.abilityInfo.name); + std::shared_ptr mission = std::make_shared(1, abilityRecord, missionName); + + missionListManager->Init(); + missionListManager->launcherList_->AddMissionToTop(mission); + missionListManager->StartAbility(abilityRequest); + + EXPECT_EQ(abilityRecord->IsNewWant(), false); +} +} // namespace AAFwk +} // namespace OHOS diff --git a/services/test/moduletest/running_infos_module_test/BUILD.gn b/services/test/moduletest/running_infos_module_test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..c0e24fc3d313ef98942a8280b56888bf1c96ca3c --- /dev/null +++ b/services/test/moduletest/running_infos_module_test/BUILD.gn @@ -0,0 +1,129 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/aafwk/standard/aafwk.gni") + +module_output_path = "ability_runtime/mstabilitymgrservice" + +ohos_moduletest("running_infos_module_test") { + module_out_path = module_output_path + + include_dirs = [ + "${services_path}/test/mock/include", + "//third_party/jsoncpp/include", + "//foundation/aafwk/standard/frameworks/kits/ability/native/include/distributed_ability_runtime", + "//foundation/aafwk/standard/interfaces/innerkits/dataobs_manager/include", + ] + + sources = [ "running_infos_module_test.cpp" ] + sources += [ + "//foundation/aafwk/standard/services/abilitymgr/src/ability_connect_callback_stub.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_connect_manager.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_event_handler.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_manager_proxy.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_manager_service.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_manager_stub.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_mission_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_record.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_record_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_scheduler_proxy.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_scheduler_stub.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_stack_manager.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_token_stub.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/caller_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/connection_record.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/data_ability_manager.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/data_ability_record.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/launch_param.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/lifecycle_deal.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/lifecycle_state_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_description_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_option.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_record.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_record_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_snapshot.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_stack.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_stack_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/pending_want_key.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/pending_want_manager.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/pending_want_record.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/power_storage.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/sender_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/stack_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/want_receiver_stub.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/want_sender_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/want_sender_stub.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/wants_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/test/mock/libs/sa_mgr/src/sa_mgr_client_mock.cpp", + "//foundation/aafwk/standard/services/test/mock/src/mock_app_mgr_client.cpp", + "//foundation/aafwk/standard/services/test/mock/src/mock_bundle_mgr.cpp", + ] + + configs = [ + "${services_path}/test:aafwk_module_test_config", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager_public_config", + "//foundation/aafwk/standard/services/abilitymgr/test/mock/libs/sa_mgr:sa_mgr_mock_config", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base_sdk_config", + "${aafwk_path}/interfaces/innerkits/app_manager:appmgr_sdk_config", + ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + deps = [ + "${aafwk_path}/interfaces/innerkits/app_manager:app_manager", + "${innerkits_path}/uri_permission:uri_permission_mgr", + "${innerkits_path}/want:want", + "${services_path}/common:perm_verification", + "//base/account/os_account/frameworks/osaccount/native:os_account_innerkits", + "//base/global/i18n_standard/frameworks/intl:intl_util", + "//base/startup/syspara_lite/interfaces/innerkits/native/syspara:syspara", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//foundation/aafwk/standard/frameworks/kits/ability/native:dummy_classes", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", + "//foundation/ace/ace_engine/interfaces/innerkits/ui_service_manager:ui_service_mgr", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_core:appexecfwk_core", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler:libeventhandler", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//foundation/distributedschedule/safwk/interfaces/innerkits/safwk:system_ability_fwk", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy:samgr_proxy", + "//foundation/multimedia/image_standard/interfaces/innerkits:image_native", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//third_party/jsoncpp:jsoncpp", + "//third_party/libpng:libpng", + "//utils/native/base:utils", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "bytrace_standard:bytrace_core", + "ces_standard:cesfwk_core", + "ces_standard:cesfwk_innerkits", + "dsoftbus_standard:softbus_client", + "hicollie_native:libhicollie", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "native_appdatamgr:native_appdatafwk", + "native_appdatamgr:native_dataability", + "native_appdatamgr:native_rdb", + ] +} + +group("moduletest") { + testonly = true + + deps = [ ":running_infos_module_test" ] +} diff --git a/services/test/moduletest/running_infos_module_test/running_infos_module_test.cpp b/services/test/moduletest/running_infos_module_test/running_infos_module_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..6fd87087cf341a4532058c2928146133209188c4 --- /dev/null +++ b/services/test/moduletest/running_infos_module_test/running_infos_module_test.cpp @@ -0,0 +1,477 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +#include +#include + +#define private public +#define protected public +#include "sa_mgr_client.h" +#include "mock_ability_connect_callback_stub.h" +#include "mock_ability_scheduler.h" +#include "mock_app_mgr_client.h" +#include "mock_bundle_mgr.h" +#include "ability_record_info.h" +#include "ability_manager_errors.h" +#include "sa_mgr_client.h" +#include "system_ability_definition.h" +#include "ability_manager_service.h" +#include "ability_connect_callback_proxy.h" +#include "ability_config.h" +#include "pending_want_manager.h" +#include "pending_want_record.h" +#undef private +#undef protected +#include "wants_info.h" +#include "want_receiver_stub.h" +#include "want_sender_stub.h" + +using namespace std::placeholders; +using namespace testing::ext; +using namespace OHOS::AppExecFwk; +using OHOS::iface_cast; +using OHOS::IRemoteObject; +using OHOS::sptr; +using testing::_; +using testing::Invoke; +using testing::Return; + +namespace OHOS { +namespace AAFwk { +namespace { +const int32_t MOCK_MAIN_USER_ID = 100; + +static void WaitUntilTaskFinished() +{ + const uint32_t maxRetryCount = 1000; + const uint32_t sleepTime = 1000; + uint32_t count = 0; + auto handler = OHOS::DelayedSingleton::GetInstance()->GetEventHandler(); + std::atomic taskCalled(false); + auto f = [&taskCalled]() { taskCalled.store(true); }; + if (handler->PostTask(f)) { + while (!taskCalled.load()) { + ++count; + if (count >= maxRetryCount) { + break; + } + usleep(sleepTime); + } + } +} +} // namespace +class RunningInfosModuleTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + void OnStartAms(); + void OnStopAms(); + Want CreateWant(const std::string &abilityName, const std::string &bundleName); + + inline static std::shared_ptr abilityMgrServ_ {nullptr}; + inline static MockAppMgrClient *mockAppMgrClient_ = nullptr; +}; + +Want RunningInfosModuleTest::CreateWant(const std::string &abilityName, const std::string &bundleName) +{ + ElementName element; + element.SetDeviceID("device"); + element.SetAbilityName(abilityName); + element.SetBundleName(bundleName); + Want want; + want.SetElement(element); + return want; +} + +void RunningInfosModuleTest::OnStartAms() +{ + if (abilityMgrServ_) { + if (abilityMgrServ_->state_ == ServiceRunningState::STATE_RUNNING) { + return; + } + + abilityMgrServ_->state_ = ServiceRunningState::STATE_RUNNING; + abilityMgrServ_->useNewMission_ = true; + + abilityMgrServ_->eventLoop_ = AppExecFwk::EventRunner::Create(AbilityConfig::NAME_ABILITY_MGR_SERVICE); + EXPECT_TRUE(abilityMgrServ_->eventLoop_); + + abilityMgrServ_->handler_ = std::make_shared(abilityMgrServ_->eventLoop_, abilityMgrServ_); + EXPECT_TRUE(abilityMgrServ_->handler_); + + // init user controller. + abilityMgrServ_->userController_ = std::make_shared(); + EXPECT_TRUE(abilityMgrServ_->userController_); + abilityMgrServ_->userController_->Init(); + int userId = MOCK_MAIN_USER_ID; + abilityMgrServ_->userController_->SetCurrentUserId(userId); + abilityMgrServ_->InitConnectManager(userId, true); + abilityMgrServ_->InitDataAbilityManager(userId, true); + abilityMgrServ_->InitPendWantManager(userId, true); + abilityMgrServ_->systemDataAbilityManager_ = std::make_shared(); + EXPECT_TRUE(abilityMgrServ_->systemDataAbilityManager_); + + abilityMgrServ_->amsConfigResolver_ = std::make_shared(); + EXPECT_TRUE(abilityMgrServ_->amsConfigResolver_); + abilityMgrServ_->amsConfigResolver_->Parse(); + abilityMgrServ_->useNewMission_ = abilityMgrServ_->amsConfigResolver_->IsUseNewMission(); + + abilityMgrServ_->SetStackManager(userId, true); + abilityMgrServ_->InitMissionListManager(userId, true); + abilityMgrServ_->connectManager_->SetEventHandler(abilityMgrServ_->handler_); + abilityMgrServ_->eventLoop_->Run(); + auto topAbility = abilityMgrServ_->GetListManagerByUserId(MOCK_MAIN_USER_ID)->GetCurrentTopAbilityLocked(); + if (topAbility) { + topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND_NEW); + } + WaitUntilTaskFinished(); + return; + } + + GTEST_LOG_(INFO) << "OnStart fail"; +} + +void RunningInfosModuleTest::OnStopAms() +{ + abilityMgrServ_->eventLoop_.reset(); + abilityMgrServ_->handler_.reset(); + abilityMgrServ_->state_ = ServiceRunningState::STATE_NOT_START; +} + +void RunningInfosModuleTest::SetUpTestCase() +{ + OHOS::DelayedSingleton::GetInstance()->RegisterSystemAbility( + OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new BundleMgrService()); + auto appScheduler = DelayedSingleton::GetInstance(); + mockAppMgrClient_ = new MockAppMgrClient(); + if (mockAppMgrClient_) { + appScheduler->appMgrClient_.reset(mockAppMgrClient_); + GTEST_LOG_(INFO) << "mock appMgrClient_ ok"; + } +} + +void RunningInfosModuleTest::TearDownTestCase() +{ + delete mockAppMgrClient_; + mockAppMgrClient_ = nullptr; + OHOS::DelayedSingleton::DestroyInstance(); +} + +void RunningInfosModuleTest::SetUp() +{ + abilityMgrServ_ = OHOS::DelayedSingleton::GetInstance(); + OnStartAms(); +} + +void RunningInfosModuleTest::TearDown() +{ + OnStopAms(); + OHOS::DelayedSingleton::DestroyInstance(); +} + +/* + * Feature: AbilityManagerService + * Function: GetAbilityRunningInfos + * SubFunction: NA + * FunctionPoints:query ability running infos + * EnvConditions: NA + * CaseDescription: start page ability, mock object, call query function. + */ +HWTEST_F(RunningInfosModuleTest, GetAbilityRunningInfos_001, TestSize.Level1) +{ + std::string abilityName = "MusicAbility"; + std::string bundleName = "com.ix.hiMusic"; + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(1); + Want want = CreateWant(abilityName, bundleName); + + auto result = abilityMgrServ_->StartAbility(want); + EXPECT_EQ(OHOS::ERR_OK, result); + EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(1); + + std::vector infos; + abilityMgrServ_->GetAbilityRunningInfos(infos); + size_t infoCount {1}; + EXPECT_TRUE(infos.size() == infoCount); + if (infos.size() == infoCount) { + EXPECT_TRUE(infos[0].ability.GetAbilityName() == abilityName); + EXPECT_TRUE(infos[0].abilityState == static_cast(AbilityState::INITIAL)); + } +} + +/* + * Feature: AbilityManagerService + * Function: GetAbilityRunningInfos + * SubFunction: NA + * FunctionPoints:query ability running infos + * EnvConditions: NA + * CaseDescription: start service ability, mock object, call query function. + */ +HWTEST_F(RunningInfosModuleTest, GetAbilityRunningInfos_002, TestSize.Level1) +{ + std::string abilityName = "ServiceAbility"; + std::string bundleName = "com.ix.hiService"; + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(1); + Want want = CreateWant(abilityName, bundleName); + auto result = abilityMgrServ_->StartAbility(want); + EXPECT_EQ(OHOS::ERR_OK, result); + EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(1); + + std::vector infos; + abilityMgrServ_->GetAbilityRunningInfos(infos); + size_t infoCount {1}; + EXPECT_TRUE(infos.size() == infoCount); + if (infos.size() == infoCount) { + EXPECT_TRUE(infos[0].ability.GetAbilityName() == abilityName); + EXPECT_TRUE(infos[0].abilityState == static_cast(AbilityState::INITIAL)); + } +} + +/* + * Feature: AbilityManagerService + * Function: GetAbilityRunningInfos + * SubFunction: NA + * FunctionPoints:query ability running infos + * EnvConditions: NA + * CaseDescription: start launcher, mock object, call query function. + */ +HWTEST_F(RunningInfosModuleTest, GetAbilityRunningInfos_003, TestSize.Level1) +{ + std::string abilityName = "com.ohos.launcher.MainAbility"; + std::string bundleName = "com.ohos.launcher"; + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(1); + Want want = CreateWant(abilityName, bundleName); + auto result = abilityMgrServ_->StartAbility(want); + EXPECT_EQ(OHOS::ERR_OK, result); + EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(1); + + std::vector infos; + abilityMgrServ_->GetAbilityRunningInfos(infos); + size_t infoCount {1}; + EXPECT_TRUE(infos.size() == infoCount); + if (infos.size() == infoCount) { + EXPECT_TRUE(infos[0].ability.GetAbilityName() == abilityName); + EXPECT_TRUE(infos[0].abilityState == static_cast(AbilityState::INITIAL)); + } +} + +/* + * Feature: AbilityManagerService + * Function: GetAbilityRunningInfos + * SubFunction: NA + * FunctionPoints:query ability running infos + * EnvConditions: NA + * CaseDescription: start two page abilities, mock object, call query function. + */ +HWTEST_F(RunningInfosModuleTest, GetAbilityRunningInfos_004, TestSize.Level1) +{ + std::string abilityName = "MusicAbility"; + std::string bundleName = "com.ix.hiMusic"; + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(2); + Want want = CreateWant(abilityName, bundleName); + auto result = abilityMgrServ_->StartAbility(want); + EXPECT_EQ(OHOS::ERR_OK, result); + + auto topAbility = abilityMgrServ_->currentMissionListManager_->GetCurrentTopAbilityLocked(); + EXPECT_TRUE(topAbility); + topAbility->SetAbilityState(AbilityState::FOREGROUND_NEW); + + std::string abilityName2 = "MusicAbilityOther"; + std::string bundleName2 = "com.ix.hiMusicOther"; + want = CreateWant(abilityName2, bundleName2); + auto result2 = abilityMgrServ_->StartAbility(want); + EXPECT_EQ(OHOS::ERR_OK, result2); + EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(2); + + std::vector infos; + abilityMgrServ_->GetAbilityRunningInfos(infos); + size_t infoCount {2}; + EXPECT_TRUE(infos.size() == infoCount); + if (infos.size() == infoCount) { + EXPECT_TRUE(infos[0].ability.GetAbilityName() == abilityName2); + EXPECT_TRUE(infos[0].abilityState == static_cast(AbilityState::INITIAL)); + EXPECT_TRUE(infos[1].ability.GetAbilityName() == abilityName); + EXPECT_TRUE(infos[1].abilityState == static_cast(AbilityState::FOREGROUND_NEW)); + } +} + +/* + * Feature: AbilityManagerService + * Function: GetAbilityRunningInfos + * SubFunction: NA + * FunctionPoints:query ability running infos + * EnvConditions: NA + * CaseDescription: start two service abilities, mock object, call query function. + */ +HWTEST_F(RunningInfosModuleTest, GetAbilityRunningInfos_005, TestSize.Level1) +{ + std::string abilityName = "ServiceAbility"; + std::string bundleName = "com.ix.hiService"; + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(2); + Want want = CreateWant(abilityName, bundleName); + auto result = abilityMgrServ_->StartAbility(want); + EXPECT_EQ(OHOS::ERR_OK, result); + + std::string abilityName2 = "ServiceAbilityOther"; + std::string bundleName2 = "com.ix.hiServiceOther"; + want = CreateWant(abilityName2, bundleName2); + auto result2 = abilityMgrServ_->StartAbility(want); + EXPECT_EQ(OHOS::ERR_OK, result2); + EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(2); + + std::vector infos; + abilityMgrServ_->GetAbilityRunningInfos(infos); + size_t infoCount {2}; + EXPECT_TRUE(infos.size() == infoCount); + if (infos.size() == infoCount) { + EXPECT_TRUE(infos[0].ability.GetAbilityName() == abilityName); + EXPECT_TRUE(infos[0].abilityState == static_cast(AbilityState::INITIAL)); + EXPECT_TRUE(infos[1].ability.GetAbilityName() == abilityName2); + EXPECT_TRUE(infos[1].abilityState == static_cast(AbilityState::INITIAL)); + } +} + +/* + * Feature: AbilityManagerService + * Function: GetAbilityRunningInfos + * SubFunction: NA + * FunctionPoints:query ability running infos + * EnvConditions: NA + * CaseDescription: start two launcher abilities, mock object, call query function. + */ +HWTEST_F(RunningInfosModuleTest, GetAbilityRunningInfos_006, TestSize.Level1) +{ + std::string abilityName = "com.ohos.launcher.MainAbility"; + std::string bundleName = "com.ohos.launcher"; + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(2); + Want want = CreateWant(abilityName, bundleName); + auto result = abilityMgrServ_->StartAbility(want); + EXPECT_EQ(OHOS::ERR_OK, result); + + auto topAbility = abilityMgrServ_->currentMissionListManager_->GetCurrentTopAbilityLocked(); + EXPECT_TRUE(topAbility); + topAbility->SetAbilityState(AbilityState::FOREGROUND_NEW); + + std::string abilityName2 = "com.ohos.launcher.MainAbilityOther"; + std::string bundleName2 = "com.ohos.launcherOther"; + want = CreateWant(abilityName2, bundleName2); + auto result2 = abilityMgrServ_->StartAbility(want); + EXPECT_EQ(OHOS::ERR_OK, result2); + EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(2); + + std::vector infos; + abilityMgrServ_->GetAbilityRunningInfos(infos); + size_t infoCount {2}; + EXPECT_TRUE(infos.size() == infoCount); + if (infos.size() == infoCount) { + EXPECT_TRUE(infos[0].ability.GetAbilityName() == abilityName2); + EXPECT_TRUE(infos[0].abilityState == static_cast(AbilityState::INITIAL)); + EXPECT_TRUE(infos[1].ability.GetAbilityName() == abilityName); + EXPECT_TRUE(infos[1].abilityState == static_cast(AbilityState::FOREGROUND_NEW)); + } +} + +/* + * Feature: AbilityManagerService + * Function: GetExtensionRunningInfos + * SubFunction: NA + * FunctionPoints:query extension running infos + * EnvConditions: NA + * CaseDescription: start service ability, mock object, call query function. + */ +HWTEST_F(RunningInfosModuleTest, GetExtensionRunningInfos_001, TestSize.Level1) +{ + std::string abilityName = "hiExtension"; + std::string bundleName = "com.ix.hiExtension"; + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(1); + Want want = CreateWant(abilityName, bundleName); + auto result = abilityMgrServ_->StartAbility(want); + EXPECT_EQ(OHOS::ERR_OK, result); + EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(1); + + std::vector infos; + int upperLimit = 10; + abilityMgrServ_->GetExtensionRunningInfos(upperLimit, infos); + size_t infoCount {1}; + EXPECT_TRUE(infos.size() == infoCount); + if (infos.size() == infoCount) { + EXPECT_TRUE(infos[0].extension.GetAbilityName() == abilityName); + } +} + +/* + * Feature: AbilityManagerService + * Function: GetExtensionRunningInfos + * SubFunction: NA + * FunctionPoints:query extension running infos + * EnvConditions: NA + * CaseDescription: start service abilities, mock object, call query function. + */ +HWTEST_F(RunningInfosModuleTest, GetExtensionRunningInfos_002, TestSize.Level1) +{ + std::string abilityName = "hiExtension"; + std::string bundleName = "com.ix.hiExtension"; + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(2); + Want want = CreateWant(abilityName, bundleName); + auto result = abilityMgrServ_->StartAbility(want); + EXPECT_EQ(OHOS::ERR_OK, result); + + std::string abilityName2 = "hiExtensionOther"; + std::string bundleName2 = "com.ix.hiExtension"; + want = CreateWant(abilityName2, bundleName2); + auto result2 = abilityMgrServ_->StartAbility(want); + EXPECT_EQ(OHOS::ERR_OK, result2); + EXPECT_CALL(*mockAppMgrClient_, GetRunningProcessInfoByToken(_, _)).Times(2); + + std::vector infos; + int upperLimit = 10; + abilityMgrServ_->GetExtensionRunningInfos(upperLimit, infos); + size_t infoCount {2}; + if (infos.size() == infoCount) { + EXPECT_TRUE(infos[0].extension.GetAbilityName() == abilityName); + EXPECT_TRUE(infos[1].extension.GetAbilityName() == abilityName2); + } +} + +/* + * Feature: AbilityManagerService + * Function: GetProcessRunningInfos + * SubFunction: NA + * FunctionPoints:query process running infos + * EnvConditions: NA + * CaseDescription: start service ability, mock object, call query function. + */ +HWTEST_F(RunningInfosModuleTest, GetProcessRunningInfos_001, TestSize.Level1) +{ + std::string abilityName = "hiExtension"; + std::string bundleName = "com.ix.hiExtension"; + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(1); + Want want = CreateWant(abilityName, bundleName); + auto result = abilityMgrServ_->StartAbility(want); + EXPECT_EQ(OHOS::ERR_OK, result); + EXPECT_CALL(*mockAppMgrClient_, GetAllRunningProcesses(_)).Times(1); + + std::vector infos; + auto ret = abilityMgrServ_->GetProcessRunningInfos(infos); + EXPECT_EQ(OHOS::ERR_OK, ret); +} +} // namespace AAFwk +} // namespace OHOS \ No newline at end of file diff --git a/services/test/moduletest/start_option_display_id_test/BUILD.gn b/services/test/moduletest/start_option_display_id_test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..ba238c981189b89c478bda9b5b140a8c422c2934 --- /dev/null +++ b/services/test/moduletest/start_option_display_id_test/BUILD.gn @@ -0,0 +1,74 @@ +# Copyright (c) 2021-2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/aafwk/standard/aafwk.gni") + +module_output_path = "ability_runtime/mstabilitymgrservice" + +ohos_moduletest("start_option_display_id_test") { + module_out_path = module_output_path + + include_dirs = [ + "${services_path}/abilitymgr/test/mock/libs/system_ability_mock", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy/include", + "//foundation/distributedschedule/samgr/adapter/interfaces/innerkits/include/", + "//foundation/aafwk/standard/interfaces/innerkits/app_manager/include/appmgr", + "//foundation/aafwk/standard/frameworks/kits/ability/native/test/mock/include", + ] + + sources = [ "start_option_display_id_test.cpp" ] + sources += [ + "//foundation/aafwk/standard/services/abilitymgr/test/mock/libs/appexecfwk_core/src/appmgr/mock_app_scheduler.cpp", + "//foundation/aafwk/standard/services/common/src/permission_verification.cpp", + "//foundation/distributedhardware/devicemanager/test/unittest/mock/parameter.cpp", + ] + + configs = [ "${services_path}/abilitymgr:abilityms_config" ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + deps = [ + "${innerkits_path}/want:want", + "${services_path}/abilitymgr/test:abilityms_test_source", + "${services_path}/abilitymgr/test/mock/libs/aakit:aakit_mock", + "${services_path}/abilitymgr/test/mock/libs/appexecfwk_core:appexecfwk_appmgr_mock", + "${services_path}/abilitymgr/test/mock/libs/appexecfwk_core:appexecfwk_bundlemgr_mock", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//foundation/aafwk/standard/frameworks/kits/ability/native:dummy_classes", + "//foundation/aafwk/standard/interfaces/innerkits/app_manager:app_manager", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler:libeventhandler", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//third_party/libpng:libpng", + "//utils/native/base:utils", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "device_manager_base:devicemanagersdk", + "dsoftbus_standard:softbus_client", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] +} + +group("moduletest") { + testonly = true + + deps = [ ":start_option_display_id_test" ] +} diff --git a/services/test/moduletest/start_option_display_id_test/start_option_display_id_test.cpp b/services/test/moduletest/start_option_display_id_test/start_option_display_id_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..8ac9fd22876f007f0adb959410c73926ea38e428 --- /dev/null +++ b/services/test/moduletest/start_option_display_id_test/start_option_display_id_test.cpp @@ -0,0 +1,137 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#define private public +#define protected public +#include "ability_manager_service.h" +#include "ability_event_handler.h" +#include "ams_configuration_parameter.h" +#include "ability_stack_manager.h" +#undef private +#undef protected + +#include "app_process_data.h" +#include "system_ability_definition.h" +#include "ability_manager_errors.h" +#include "ability_scheduler.h" +#include "bundlemgr/mock_bundle_manager.h" +#include "sa_mgr_client.h" +#include "mock_ability_connect_callback.h" +#include "mock_ability_token.h" +#include "if_system_ability_manager.h" +#include "iservice_registry.h" +#include "os_account_manager.h" +#include "os_account_info.h" +using namespace testing; +using namespace testing::ext; +using namespace OHOS::AppExecFwk; +using namespace OHOS::AccountSA; +namespace OHOS { +namespace AAFwk { +namespace { +const int32_t USER_ID_U100 = 100; +constexpr int32_t DISPLAY_ID = 256; + +static void WaitUntilTaskFinished() +{ + const uint32_t maxRetryCount = 1000; + const uint32_t sleepTime = 1000; + uint32_t count = 0; + auto handler = OHOS::DelayedSingleton::GetInstance()->GetEventHandler(); + std::atomic taskCalled(false); + auto f = [&taskCalled]() { taskCalled.store(true); }; + if (handler->PostTask(f)) { + while (!taskCalled.load()) { + ++count; + if (count >= maxRetryCount) { + break; + } + usleep(sleepTime); + } + } +} +} // namespace + +class StartOptionDisplayIdTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); + +public: + std::shared_ptr abilityMgrServ_ {nullptr}; +}; + +void StartOptionDisplayIdTest::SetUpTestCase() +{ + OHOS::DelayedSingleton::GetInstance()->RegisterSystemAbility( + OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new BundleMgrService()); +} + +void StartOptionDisplayIdTest::TearDownTestCase() +{ + OHOS::DelayedSingleton::DestroyInstance(); +} + +void StartOptionDisplayIdTest::SetUp() +{ + abilityMgrServ_ = OHOS::DelayedSingleton::GetInstance(); + abilityMgrServ_->OnStart(); + WaitUntilTaskFinished(); + + abilityMgrServ_->StartUser(USER_ID_U100); + auto topAbility = abilityMgrServ_->GetListManagerByUserId(USER_ID_U100)->GetCurrentTopAbilityLocked(); + if (topAbility) { + topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND_NEW); + } +} + +void StartOptionDisplayIdTest::TearDown() +{ + abilityMgrServ_->OnStop(); + OHOS::DelayedSingleton::DestroyInstance(); +} + +/* + * Feature: AbilityManagerService + * Function: StartAbility + * SubFunction: NA + * FunctionPoints: AbilityManagerService StartAbility + * EnvConditions: NA + * CaseDescription: Set displayId, enable ability, get displayId value consistent with the setting + */ +HWTEST_F(StartOptionDisplayIdTest, start_option_001, TestSize.Level1) +{ + Want want; + ElementName element("device", "com.ix.hiMusic", "MusicAbility"); + want.SetElement(element); + StartOptions option; + option.SetDisplayID(DISPLAY_ID); + auto result = abilityMgrServ_->StartAbility(want, option, nullptr, 100, 0); + WaitUntilTaskFinished(); + EXPECT_EQ(OHOS::ERR_OK, result); + + auto topAbility = abilityMgrServ_->GetListManagerByUserId(USER_ID_U100)->GetCurrentTopAbilityLocked(); + EXPECT_TRUE(topAbility); + if (topAbility) { + auto defualtDisplayId = 0; + auto displayId = topAbility->GetWant().GetIntParam(Want::PARAM_RESV_DISPLAY_ID, defualtDisplayId); + EXPECT_EQ(displayId, DISPLAY_ID); + } +} +} // namespace AAFwk +} // namespace OHOS diff --git a/services/test/moduletest/static_start_ability_test/BUILD.gn b/services/test/moduletest/static_start_ability_test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..006c5e82d981c7b819b3b6ca81c225f911e1372e --- /dev/null +++ b/services/test/moduletest/static_start_ability_test/BUILD.gn @@ -0,0 +1,132 @@ +# Copyright (c) 2021-2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//foundation/aafwk/standard/aafwk.gni") + +module_output_path = "ability_runtime/mstabilitymgrservice" + +ohos_moduletest("static_start_ability_test") { + module_out_path = module_output_path + + include_dirs = [ + "${services_path}/test/mock/include", + "//third_party/jsoncpp/include", + "//foundation/aafwk/standard/frameworks/kits/ability/native/include/distributed_ability_runtime", + "//foundation/aafwk/standard/interfaces/innerkits/dataobs_manager/include", + "//base/hiviewdfx/hicollie/interfaces/native/innerkits/include/xcollie", + ] + + sources = [ "static_start_ability_test.cpp" ] + sources += [ + "//foundation/aafwk/standard/services/abilitymgr/src/ability_connect_callback_stub.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_connect_manager.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_event_handler.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_manager_proxy.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_manager_service.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_manager_stub.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_mission_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_record.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_record_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_scheduler_proxy.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_scheduler_stub.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_stack_manager.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/ability_token_stub.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/call_container.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/call_record.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/caller_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/connection_record.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/data_ability_manager.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/data_ability_record.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/launch_param.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/lifecycle_deal.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/lifecycle_state_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_description_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_option.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_record.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_record_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_snapshot.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_stack.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/mission_stack_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/pending_want_key.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/pending_want_manager.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/pending_want_record.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/power_storage.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/sender_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/stack_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/want_receiver_stub.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/want_sender_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/want_sender_stub.cpp", + "//foundation/aafwk/standard/services/abilitymgr/src/wants_info.cpp", + "//foundation/aafwk/standard/services/abilitymgr/test/mock/libs/sa_mgr/src/sa_mgr_client_mock.cpp", + "//foundation/aafwk/standard/services/test/mock/src/mock_app_mgr_client.cpp", + "//foundation/aafwk/standard/services/test/mock/src/mock_bundle_mgr.cpp", + ] + + configs = [ + "${services_path}/test:aafwk_module_test_config", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager_public_config", + "//foundation/aafwk/standard/services/abilitymgr/test/mock/libs/sa_mgr:sa_mgr_mock_config", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base_sdk_config", + "${aafwk_path}/interfaces/innerkits/app_manager:appmgr_sdk_config", + ] + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + deps = [ + "${aafwk_path}/interfaces/innerkits/app_manager:app_manager", + "${innerkits_path}/uri_permission:uri_permission_mgr", + "${innerkits_path}/want:want", + "${services_path}/common:perm_verification", + "//base/account/os_account/frameworks/osaccount/native:os_account_innerkits", + "//base/global/i18n_standard/frameworks/intl:intl_util", + "//base/startup/syspara_lite/interfaces/innerkits/native/syspara:syspara", + "//foundation/aafwk/standard/frameworks/kits/ability/native:abilitykit_native", + "//foundation/aafwk/standard/frameworks/kits/ability/native:dummy_classes", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", + "//foundation/ace/ace_engine/interfaces/innerkits/ui_service_manager:ui_service_mgr", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base:appexecfwk_base", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_core:appexecfwk_core", + "//foundation/appexecfwk/standard/interfaces/innerkits/libeventhandler:libeventhandler", + "//foundation/distributedschedule/dmsfwk/interfaces/innerkits/uri:zuri", + "//foundation/distributedschedule/safwk/interfaces/innerkits/safwk:system_ability_fwk", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy:samgr_proxy", + "//foundation/multimedia/image_standard/interfaces/innerkits:image_native", + "//third_party/googletest:gmock_main", + "//third_party/googletest:gtest_main", + "//third_party/jsoncpp:jsoncpp", + "//third_party/libpng:libpng", + "//utils/native/base:utils", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "bytrace_standard:bytrace_core", + "ces_standard:cesfwk_core", + "ces_standard:cesfwk_innerkits", + "dsoftbus_standard:softbus_client", + "hicollie_native:libhicollie", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "native_appdatamgr:native_appdatafwk", + "native_appdatamgr:native_dataability", + "native_appdatamgr:native_rdb", + ] +} + +group("moduletest") { + testonly = true + + deps = [ ":static_start_ability_test" ] +} diff --git a/services/test/moduletest/static_start_ability_test/static_start_ability_test.cpp b/services/test/moduletest/static_start_ability_test/static_start_ability_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..8202f4760d7e4f6efe089a741d907fafbc806b24 --- /dev/null +++ b/services/test/moduletest/static_start_ability_test/static_start_ability_test.cpp @@ -0,0 +1,322 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +#include +#include + +#define private public +#define protected public +#include "sa_mgr_client.h" +#include "mock_ability_connect_callback_stub.h" +#include "mock_ability_scheduler.h" +#include "mock_app_mgr_client.h" +#include "mock_bundle_mgr.h" +#include "ability_record_info.h" +#include "ability_manager_errors.h" +#include "sa_mgr_client.h" +#include "system_ability_definition.h" +#include "ability_manager_service.h" +#include "ability_connect_callback_proxy.h" +#include "ability_config.h" +#include "pending_want_manager.h" +#include "pending_want_record.h" +#undef private +#undef protected +#include "wants_info.h" +#include "want_receiver_stub.h" +#include "want_sender_stub.h" +#include "os_account_manager.h" + +using namespace std::placeholders; +using namespace testing::ext; +using namespace OHOS::AppExecFwk; +using OHOS::iface_cast; +using OHOS::IRemoteObject; +using OHOS::sptr; +using testing::_; +using testing::Invoke; +using testing::Return; + +namespace OHOS { +namespace AAFwk { +namespace { +const std::string COM_OHOS_Test = "com.ohos.test"; +const std::string MAIN_ABILITY = ".MainAbility"; +const std::string MY_APPLICATION = ".MyApplication"; +const std::string DESCRIPTION = "$string:mainability_description"; +const std::string LABEL = "$string:label"; +const std::string ICON = "$media:icon"; +const std::string THEME = "mytheme"; +const std::string KIND = "page"; +const std::string PROCESS = "p10"; +const std::string READ_PERMISSION = "readPermission"; +const std::string WRITE_PERMISSION = "writePermission"; +const std::string RESOURCE_PATH = "/data/app/com.ohos.test"; +const std::string SRC_PATH = "/resources/base/profile"; +const std::string SRC_LANGUAGE = "C++"; +const uint32_t NUMBER_ONE = 10001; +const uint32_t NUMBER_TWO = 10002; +const uint32_t NUMBER_THREE = 10003; +} // namespace +class StaticStartAbilityTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + bool MockAppClent(); + void SetActive(); + void WaitAMS(); + Want CreateWant(const std::string &abilityName, const std::string &bundleName); + std::shared_ptr GreatePageAbility(const std::string &abilityName, const std::string &bundleName); + + inline static std::shared_ptr mockAppMgrClient_ {nullptr}; + inline static std::shared_ptr abilityMgrServ_ {nullptr}; + inline static BundleMgrService *bundleObject_ {nullptr}; + std::shared_ptr stackManager_ {nullptr}; + sptr scheduler_ {nullptr}; + inline static bool doOnce_ = false; // In order for mock to execute once +}; + +void StaticStartAbilityTest::SetUpTestCase(void) +{ + OHOS::DelayedSingleton::GetInstance()->RegisterSystemAbility( + OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new (std::nothrow) BundleMgrService()); + abilityMgrServ_ = OHOS::DelayedSingleton::GetInstance(); + mockAppMgrClient_ = std::make_shared(); + + if (StaticStartAbilityTest::abilityMgrServ_) { + if (StaticStartAbilityTest::abilityMgrServ_->state_ == ServiceRunningState::STATE_RUNNING) { + return; + } + StaticStartAbilityTest::abilityMgrServ_->state_ = ServiceRunningState::STATE_RUNNING; + StaticStartAbilityTest::abilityMgrServ_->eventLoop_ = + AppExecFwk::EventRunner::Create(AbilityConfig::NAME_ABILITY_MGR_SERVICE); + EXPECT_TRUE(StaticStartAbilityTest::abilityMgrServ_->eventLoop_); + + StaticStartAbilityTest::abilityMgrServ_->handler_ =std::make_shared( + StaticStartAbilityTest::abilityMgrServ_->eventLoop_, StaticStartAbilityTest::abilityMgrServ_); + StaticStartAbilityTest::abilityMgrServ_->connectManager_ = std::make_shared(); + StaticStartAbilityTest::abilityMgrServ_->connectManagers_.emplace(0, + StaticStartAbilityTest::abilityMgrServ_->connectManager_); + EXPECT_TRUE(StaticStartAbilityTest::abilityMgrServ_->handler_); + EXPECT_TRUE(StaticStartAbilityTest::abilityMgrServ_->connectManager_); + + StaticStartAbilityTest::abilityMgrServ_->connectManager_-> + SetEventHandler(StaticStartAbilityTest::abilityMgrServ_->handler_); + + StaticStartAbilityTest::abilityMgrServ_->dataAbilityManager_ = std::make_shared(); + StaticStartAbilityTest::abilityMgrServ_->dataAbilityManagers_.emplace(0, + StaticStartAbilityTest::abilityMgrServ_->dataAbilityManager_); + EXPECT_TRUE(StaticStartAbilityTest::abilityMgrServ_->dataAbilityManager_); + + StaticStartAbilityTest::abilityMgrServ_->amsConfigResolver_ = std::make_shared(); + EXPECT_TRUE(StaticStartAbilityTest::abilityMgrServ_->amsConfigResolver_); + StaticStartAbilityTest::abilityMgrServ_->amsConfigResolver_->Parse(); + + StaticStartAbilityTest::abilityMgrServ_->currentMissionListManager_ = std::make_shared(0); + StaticStartAbilityTest::abilityMgrServ_->currentMissionListManager_->Init(); + + StaticStartAbilityTest::abilityMgrServ_->pendingWantManager_ = std::make_shared(); + EXPECT_TRUE(StaticStartAbilityTest::abilityMgrServ_->pendingWantManager_); + + int userId = StaticStartAbilityTest::abilityMgrServ_->GetUserId(); + StaticStartAbilityTest::abilityMgrServ_->SetStackManager(userId, true); + StaticStartAbilityTest::abilityMgrServ_->stackManagers_.emplace(0, + StaticStartAbilityTest::abilityMgrServ_->GetStackManager()); + StaticStartAbilityTest::abilityMgrServ_->eventLoop_->Run(); + + GTEST_LOG_(INFO) << "OnStart success"; + return; + } + + GTEST_LOG_(INFO) << "OnStart fail"; +} + +void StaticStartAbilityTest::TearDownTestCase(void) +{ + abilityMgrServ_->OnStop(); + mockAppMgrClient_.reset(); +} + +void StaticStartAbilityTest::SetUp(void) +{ + scheduler_ = new MockAbilityScheduler(); + if (!doOnce_) { + doOnce_ = true; + MockAppClent(); + } + WaitAMS(); +} + +void StaticStartAbilityTest::TearDown(void) +{} + +bool StaticStartAbilityTest::MockAppClent() +{ + if (!mockAppMgrClient_) { + GTEST_LOG_(INFO) << "MockAppClent::1"; + return false; + } + + if (!abilityMgrServ_->appScheduler_) { + GTEST_LOG_(INFO) << "MockAppClent::2"; + return false; + } + + abilityMgrServ_->appScheduler_->appMgrClient_.reset(mockAppMgrClient_.get()); + return true; +} + +void StaticStartAbilityTest::SetActive() +{ + if (!abilityMgrServ_) { + return; + } + + auto stackMgr = abilityMgrServ_->GetStackManager(); + if (stackMgr) { + auto topAbility = stackMgr->GetCurrentTopAbility(); + if (topAbility) { + topAbility->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE); + } + } +} + +void StaticStartAbilityTest::WaitAMS() +{ + const uint32_t maxRetryCount = 1000; + const uint32_t sleepTime = 1000; + uint32_t count = 0; + if (!abilityMgrServ_) { + return; + } + auto handler = abilityMgrServ_->GetEventHandler(); + if (!handler) { + return; + } + std::atomic taskCalled(false); + auto f = [&taskCalled]() { taskCalled.store(true); }; + if (handler->PostTask(f)) { + while (!taskCalled.load()) { + ++count; + if (count >= maxRetryCount) { + break; + } + usleep(sleepTime); + } + } +} + +Want StaticStartAbilityTest::CreateWant(const std::string &abilityName, const std::string &bundleName) +{ + ElementName element; + element.SetDeviceID(""); + element.SetAbilityName(abilityName); + element.SetBundleName(bundleName); + Want want; + want.SetElement(element); + return want; +} + +std::shared_ptr StaticStartAbilityTest::GreatePageAbility( + const std::string &abilityName, const std::string &bundleName) +{ + Want want = CreateWant(abilityName, bundleName); + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(1).WillOnce(Return(AppMgrResultCode::RESULT_OK)); + int testRequestCode = 1; + SetActive(); + abilityMgrServ_->StartAbility(want, 0, testRequestCode); + WaitAMS(); + + auto stack = abilityMgrServ_->GetStackManager(); + if (!stack) { + return nullptr; + } + auto topAbility = stack->GetCurrentTopAbility(); + if (!topAbility) { + return nullptr; + } + topAbility->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE); + + return topAbility; +} + +/* + * Feature: AaFwk + * Function: ability manager service + * SubFunction: StartAbility + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test the abilityInfo query in StartAbility. + */ +HWTEST_F(StaticStartAbilityTest, StaticStartAbility_001, TestSize.Level1) +{ + std::string abilityName = "com.ohos.test.MainAbility"; + std::string bundleName = "com.ohos.test"; + abilityMgrServ_->RemoveAllServiceRecord(); + Want want = CreateWant(abilityName, bundleName); + EXPECT_CALL(*mockAppMgrClient_, LoadAbility(_, _, _, _, _)).Times(1).WillOnce(Return(AppMgrResultCode::RESULT_OK)); + int testRequestCode = 1; + SetActive(); + abilityMgrServ_->StartAbility(want, 0, testRequestCode); + WaitAMS(); + + auto stack = abilityMgrServ_->GetStackManager(); + EXPECT_TRUE(stack); + std::shared_ptr record = stack->GetCurrentTopAbility(); + record->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE); + EXPECT_TRUE(record); + AbilityInfo abilityInfo = record->GetAbilityInfo(); + abilityMgrServ_->RemoveAllServiceRecord(); + EXPECT_EQ(abilityInfo.name, COM_OHOS_Test + MAIN_ABILITY); + EXPECT_EQ(abilityInfo.bundleName, COM_OHOS_Test); + EXPECT_EQ(abilityInfo.applicationInfo.bundleName, COM_OHOS_Test); + EXPECT_EQ(abilityInfo.applicationName, COM_OHOS_Test); + EXPECT_EQ(abilityInfo.applicationInfo.name, COM_OHOS_Test); + EXPECT_EQ(abilityInfo.bundleName, COM_OHOS_Test); + EXPECT_EQ(abilityInfo.bundleName, COM_OHOS_Test); + EXPECT_EQ(abilityInfo.bundleName, COM_OHOS_Test); + EXPECT_EQ(abilityInfo.bundleName, COM_OHOS_Test); + EXPECT_EQ(abilityInfo.moduleName, MY_APPLICATION); + EXPECT_EQ(abilityInfo.kind, KIND); + EXPECT_EQ(abilityInfo.process, PROCESS); + EXPECT_EQ(abilityInfo.labelId, NUMBER_ONE); + EXPECT_EQ(abilityInfo.label, LABEL); + EXPECT_EQ(abilityInfo.descriptionId, NUMBER_TWO); + EXPECT_EQ(abilityInfo.description, DESCRIPTION); + EXPECT_EQ(abilityInfo.iconId, NUMBER_THREE); + EXPECT_EQ(abilityInfo.iconPath, ICON); + EXPECT_EQ(abilityInfo.theme, THEME); + EXPECT_EQ(abilityInfo.readPermission, READ_PERMISSION); + EXPECT_EQ(abilityInfo.writePermission, WRITE_PERMISSION); + EXPECT_EQ(abilityInfo.resourcePath, RESOURCE_PATH); + EXPECT_EQ(abilityInfo.srcPath, SRC_PATH); + EXPECT_EQ(abilityInfo.srcLanguage, SRC_LANGUAGE); + EXPECT_FALSE(abilityInfo.multiUserShared); + EXPECT_FALSE(abilityInfo.supportPipMode); + EXPECT_FALSE(abilityInfo.grantPermission); + EXPECT_FALSE(abilityInfo.isLauncherAbility); + EXPECT_FALSE(abilityInfo.isNativeAbility); + EXPECT_FALSE(abilityInfo.enabled); + EXPECT_FALSE(abilityInfo.formEnabled); +} +} // namespace AAFwk +} // namespace OHOS \ No newline at end of file